Je suis d'accord avec X'ian pour dire que le problème est sous-spécifié. Cependant, il existe une solution élégante, évolutive, efficace, efficace et polyvalente à considérer.

Étant donné que le produit de la moyenne de l'échantillon et de la taille de l'échantillon est égal à la somme de l'échantillon, le problème concerne la génération d'un échantillon aléatoire de valeurs $ n $ dans l'ensemble $ \ {1,2, \ ldots, k \} $ cette somme à $ s $ (en supposant $ n \ le s \ le kn, $ bien sûr).

Pour expliquer la solution proposée et, je l'espère, justifier la revendication d'elegance, je propose une interprétation graphique de ce schéma d'échantillonnage. Disposez une grille de $ k $ lignes et $ n $ colonnes. Sélectionnez chaque cellule de la première ligne. Sélectionnez au hasard (et uniformément) $ sn $ des cellules restantes dans les lignes $ 2 $ à $ k. $ La valeur de l'observation $ i $ dans l'échantillon est le nombre de cellules sélectionnées dans la colonne $ i: $

Cette grille $ 4 \ times 100 $ est représentée par des points noirs au niveau des cellules non sélectionnées et des patchs colorés au niveau des cellules sélectionnées. Il a été généré pour produire une valeur moyenne de 2 $, $ donc $ s = 200. $ Ainsi, 200-100 $ = 100 $ Les cellules ont été sélectionnées au hasard parmi les premières $ k-1 = 3 $ lignes. Les couleurs représentent le nombre de cellules sélectionnées dans chaque colonne. Il y en a 28 $ , 47 $ deux, 22 $ trois et 3 $ $ quatre. L'échantillon ordonné correspond à la séquence de couleurs de la colonne $ 1 $ à la colonne $ n = 100. $

Pour démontrer l'évolutivité et l'efficacité, voici une commande R pour générer un échantillon selon ce schéma. La question concerne le cas où $ k = 4, n = 100 $ et $ s $ est $ n $ fois la moyenne souhaitée de l'échantillon:

  tabuler (sample.int ((k-1) * n, s-n) %% n + 1, n) + 1
 

Parce que sample.int nécessite $ O (sn) $ temps et $ O ( (k-1) n) $ espace, et tabulate nécessite $ O (n) $ temps et espace, cet algorithme nécessite $ O (\ max (sn, n)) $ temps et $ O (kn) $ espace : c'est scalable. Avec $ k = 4 $ et $ n = 100 $ , mon poste de travail ne prend que 12 microsecondes pour effectuer ce calcul : c'est efficient.

(Voici une brève explication du code. Notez que les entiers $ x $ dans $ \ {1,2, \ ldots, (k-1) n \} $ peut être exprimé uniquement comme $ x = nj + i $ où $ j \ in \ {0,1, \ ldots, k-2 \} $ et $ i \ in \ {1,2, \ ldots, n \}. $ Le code prend un échantillon de ces $ x, $ les convertit en leur $ ( i, j) $ coordonnées de la grille, compte le nombre de fois où chaque $ i $ apparaît (qui va de $ 0 $ à $ k-1 $ ) et ajoute $ 1 $ à chaque décompte.)

Pourquoi cela peut-il être considéré comme effective? L'une des raisons est que les propriétés de distribution de ce schéma d'échantillonnage sont simples à déterminer:

• Il est échangeable: toutes les permutations de n'importe quel échantillon sont également probables.

• La chance que la valeur $ x \ in \ {1,2, \ ldots, k \} $ apparaisse à la position $ i, $ que j'écrirai comme $ \ pi_i (x), $ est obtenu par un argument de comptage hypergéométrique de base comme $$ \ pi_i (x) = \ frac {\ binom {k-1} {x-1} \ binom {(n-1) (k-1)} {sn-x +1}} {\ binom {n (k-1)} {sn}}. $$ Par exemple, avec $ k = 4, $ $ n = 100, $ et une moyenne de 2,0 $ $ (de sorte que $ s = 200 $ ) les chances sont $ \ pi = (0.2948, 0.4467, 0.2222, 0.03630), $ d'être en accord étroit avec les fréquences dans l'échantillon précédent. Voici les graphiques de $ \ pi_1 (1), \ pi_1 (2), \ pi_1 (3), $ et $ \ pi_1 (4) $ en fonction de la somme:

  

• La probabilité que la valeur $ x $ apparaisse à la position $ i $ alors que le la valeur $ y $ apparaît à la position $ j $ se trouve de la même manière que $$ \ pi_ {ij} (x, y) = \ frac {\ binom {k-1} {x-1} \ binom {k-1} {y-1} \ binom {(n-1) (k-1)} {snx-y + 2}} {\ binom {n (k-1)} {sn}}. $$

Ces probabilités $ \ pi_i $ et $ \ pi_ {ij} $ permettent d'appliquer le L'estimateur Horvitz-Thompson à ce plan d'échantillonnage probabiliste ainsi que pour calculer les deux premiers moments des distributions de diverses statistiques.

Enfin, cette solution est versatile dans la mesure où elle permet des variations simples et facilement analysables pour contrôler la distribution d'échantillonnage.Par exemple, vous pouvez sélectionner des cellules de la grille avec des probabilités spécifiées mais inégales dans chaque ligne, ou avec un modèle de type urne pour modifier les probabilités au fur et à mesure de l'échantillonnage, contrôlant ainsi les fréquences des décomptes de colonnes.

La question est sous-spécifiée dans la mesure où les contraintes sur les fréquences \ begin {align} n_1 + 2n_2 + 3n_3 + 4n_4& = 100M \\ n_1 + n_2 + n_3 + n_4& = 100 \ end {align} ne déterminez pas une distribution: «aléatoire» n'est pas associé à une distribution particulière, sauf si l'OP signifie «uniforme». Par exemple, s'il existe une solution $ (n_1 ^ 0, n_2 ^ 0, n_3 ^ 0, n_4 ^ 0) $ au système ci-dessus, alors la distribution a dégénéré à cette solution produit un tirage au sort qui est toujours $ (n_1 ^ 0, n_2 ^ 0, n_3 ^ 0, n_4 ^ 0) $ .

Dans le cas où la question concerne la simulation d'une distribution uniforme sur la grille \ begin {align} n_1 + 2n_2 + 3n_3 + 4n_4& = 100M \\ n_1 + n_2 + n_3 + n_4& = 100 \ end {align} on peut toujours utiliser un algorithme Metropolis-Hastings. À partir de $ (n_1 ^ 0, n_2 ^ 0, n_3 ^ 0, n_4 ^ 0) $ , créez une chaîne de Markov en proposant des perturbations aléatoires symétriques du vecteur $ (n_1 ^ t, n_2 ^ t, n_3 ^ t, n_4 ^ t) $ et acceptez si le résultat est dans $ \ {1,2,3,4 \} ^ 4 $ et satisfait les contraintes.

Par exemple, voici un rendu R brut:

  cenM = 293
# point de départ (n¹, n³, n⁴)
n<-sample (1: 100,3, rep = TRUE)
tandis que ((somme (n) >100) | (n [2] -n [1] + 2 * n [3]! = cenM-200))
    n<-sample (1: 100,3, rep = TRUE)
#Markov chaîne
pour (t dans 1: 1e6) {
  prop<-n + échantillon (-10: 10,3, rep = TRUE)
  if ((somme (prop) <101) &
      (prop [2] -prop [1] + 2 * prop [3] == cenM-200) &
      (min (prop) >0))
        n = accessoire}
c (n [1], somme de 100 (n), n [-1])
 

avec la distribution de $ (n_1, n_3, n_4) $ sur les 10⁶ itérations:

Si vous voulez dessiner les entiers eux-mêmes,

  échantillon (c (rep (1, n [1]), rep (2,100-sum (n)), rep (3, n [2]), rep (4, n [3])) )
 

est un moyen rapide & de produire un échantillon.

Je veux ... euh ... "atténuer" la réponse étonnante de @ whuber, que @TomZinger dit est trop difficile à suivre. Je veux dire par là que je veux le re-décrire en des termes que je pense que Tom Zinger comprendra, car c'est clairement la meilleure réponse ici. Et au fur et à mesure que Tom utilise progressivement la méthode et découvre qu'il a besoin, par exemple, de connaître la distribution des échantillons plutôt que simplement leur moyenne, la réponse de Whuber sera exactement ce qu'il recherche.

En bref: il n'y a pas d'idées originales ici, seulement une explication plus simple.

Vous souhaitez créer des $ n $ entiers de $ 1 $ à $ 4 $ avec une moyenne $ r $ . Je vais suggérer de calculer des $ n $ entiers de $ 0 $ à $ 3 $ avec la moyenne $ r-1 $ , puis en ajoutant un à chacun d'eux. Si vous pouvez faire cette dernière chose, vous pouvez résoudre le premier problème. Par exemple, si nous voulons 10 entiers entre $ 1 $ et $ 4 $ avec une moyenne 2,6 $ , nous pouvons noter ces entiers $ 10 $ entre $ 0 $ et 3 $ $ ...

0,3,2,1,3,1,2,1,3,0

dont la moyenne est 1,6 $ ; si nous augmentons chacun de $ 1 $ , nous obtenons

1,4,3,2,4,2,3,2,4,1

dont la moyenne est 2,6 $ . C'est si simple.

Pensons maintenant aux nombres $ 0 $ à $ 3 $ . Je vais les considérer comme "combien d'articles ai-je dans un 'petit' ensemble?" Je n'ai peut-être aucun élément, un élément, deux éléments ou trois éléments. Donc la liste

0,3,2,1,3,1,2,1,3,0

représente dix petits ensembles différents. Le premier est vide; le second a trois éléments, et ainsi de suite. Le nombre total d'éléments dans tous les ensembles est la somme des dix nombres, c'est-à-dire 16 $ $ . Et le nombre moyen d'éléments dans chaque ensemble est ce total, divisé par 10 $ , d'où 1,6 $ .

L'idée de whuber est la suivante: supposons que vous vous fabriquiez dix petits ensembles, le nombre total d'éléments étant $ 10t $ pour un certain nombre $ t $ . Alors la taille moyenne des ensembles sera exactement $ t $ . De la même manière, si vous créez vous-même des ensembles de $ n $ avec un nombre total d'éléments étant $ nt $ span >, le nombre moyen d'éléments dans un ensemble sera $ t $ . Vous dites que vous êtes intéressé par le cas $ n = 100 $ .

Rendons ceci concret pour votre exemple: vous voulez 100 éléments entre 1 et 4 dont la moyenne est 1,9 $ . En utilisant l'idée de mon premier paragraphe, je vais changer cela en "make $ 100 $ ints entre $ 0 $ span> et 3 $ $ dont la moyenne est de 0,9 $ ". Quand j'aurai terminé, j'ajouterai $ 1 $ à chacun de mes entiers pour obtenir une solution à votre problème. Donc ma moyenne cible est $ t = 0,9 $ .

Je souhaite créer des ensembles de 100 $ $ , chacun avec entre $ 0 $ et 3 $ $ éléments dedans, avec une taille d'ensemble moyenne de 0,9 $ .

Comme je l'ai observé ci-dessus, cela signifie qu'il doit y avoir un total d'éléments 100 $ \ cdot 0.9 = 90 $ dans les décors. À partir des nombres $ 1, 2, \ ldots, 300 $ , je vais sélectionner exactement 90 $ . Je peux indiquer ceux sélectionnés en faisant une liste de 300 points et X:

..X .... X ... XX ...

où la liste ci-dessus indique que j'ai sélectionné les nombres 3, 9, 13, 14, et puis beaucoup d'autres que je n'ai pas montrés parce que j'en ai eu marre de taper. :) Je peux prendre cette séquence de 300 points et X et la diviser en trois groupes de 100 points chacun, que j'arrange les uns sur les autres pour obtenir quelque chose qui ressemble à ceci:

  ... X .... X..X ..... X ...
.X ... X ..... X ... X .....
..X ... X.X..X ...... X ..
 

mais continue pour 100 éléments complets dans chaque ligne. Le nombre de X dans chaque ligne peut différer - il peut y en avoir 35 dans la première ligne, 24 dans la deuxième et 31 dans la troisième, par exemple, et c'est OK. [Merci à whuber d'avoir signalé que je me suis trompé dans un premier brouillon!]

Maintenant, regardez chaque colonne : chaque colonne peut être considérée comme un ensemble, et cet ensemble contient entre 0 et 3 "X". Je peux écrire les chiffres sous les lignes pour obtenir quelque chose comme ceci:

  ... X .... X..X ..... X ...
.X ... X ..... X ... X .....
..X ... X.X..X ...... X ..
011101102003000101100
 

C'est-à-dire que j'ai produit 100 nombres, chacun compris entre 1 et 3. Et la somme de ces 100 nombres doit être le nombre de X, total, dans les trois lignes, qui était de 90. La moyenne doit donc être $ 90/100 = 0.9 $ , comme vous le souhaitez.

Voici donc les étapes pour obtenir 100 entiers entre 1 et 4 dont la moyenne est exactement $ s $ .

1. Soit $ t = s - 1 $ .
2. Calculer $ k = 100 t $ ; c'est le nombre de X que nous placerons dans les lignes, au total.
3. Faites une liste de 300 points ou X, dont $ k $ sont des X.
4. Divisez-le en trois rangées de 100 points ou X, chacune contenant environ un tiers des X, plus ou moins.
5. Organisez-les dans un tableau et calculez les sommes des colonnes, en obtenant 100 entiers entre $ 0 $ et $ 3 $ span >. Leur moyenne sera $ t $ .
6. Ajoutez un à chaque somme de colonne pour obtenir 100 entiers entre 1 $ et 4 $ $ dont la moyenne est $ s $ .

Maintenant, la partie délicate de ceci est vraiment à l'étape 4: comment choisir des éléments $ 300 $ , $ k $ dont "X" et les autres 300-k $ dont "."? Eh bien, il s'avère que R a une fonction qui fait exactement cela.

Et puis whuber vous dit comment l'utiliser: vous écrivez

  tabuler (sample.int ((k-1) * n, s-n) %% n + 1, n)
 

Pour votre cas particulier, $ n = 100 $ , et $ s $ , le nombre total d'éléments dans tous les petits ensembles, est $ 100r $ , et vous voulez des nombres entre $ 1 $ et 4 $ $ , donc $ k = 4 $ , donc $ k -1 $ (la plus grande taille pour un 'petit ensemble') est 3, donc cela devient

  tabuler (sample.int (3 * 100, 100r-100) %% 100 + 1, n)
 

ou

  tabuler (sample.int (3 * 100, 100 * (r-1)) %% 100 + 1, 100)
 

ou, en utilisant mon nom $ t $ pour $ r - 1 $ , il devient

  tabuler (sample.int (3 * 100, 100 * t) %% 100 + 1, 100)
 

Le "+1" à la fin de sa formule originale est exactement l'étape nécessaire pour convertir des "nombres entre $ 0 $ et $ 3 $ " à "nombres entre $ 1 $ et $ 4 $ ".

Travaillons de l'intérieur et simplifions à $ n = 10 $ pour que je puisse montrer des exemples de résultats:

  tabuler (sample.int (3 * 10, 10 * t) %% 10 + 1, 10)
 

Et visons $ t = 1.9 $ , donc cela devient

  tabuler (sample.int (3 * 10, 10 * 1.9) %% 10 + 1, 10)
 

Commençant par sample.int (3 * 10, 10 * 1.9) : cela produit une liste d'entiers 19 $ entre $ 1 $ et 30 $ . (c'est-à-dire que cela a résolu le problème de la sélection de $ k $ nombres sur votre total - 300 $ dans votre vrai problème, $ 30 $ dans mon petit exemple).

Comme vous vous en souviendrez, nous voulons produire trois lignes de dix points et X chacune, quelque chose comme

  X.X.XX.XX.
 XXXX.XXX ..
 XX.X.XXX ..
 

Nous pouvons lire ceci de gauche à droite de haut en bas (c'est-à-dire dans l'ordre de lecture normal) pour produire une liste d'emplacements pour Xs: le premier élément est un point; les deuxième et troisième sont des X, et ainsi de suite, donc notre liste d'emplacements commence par $ 1, 3, 5, 6, \ ldots $ . Quand nous arrivons à la fin d'une ligne, nous continuons à compter, donc pour l'image ci-dessus, les emplacements X seraient $ 1, 3, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 21, 22, 24, 26, 27, 28 $ . Est-ce clair?

Eh bien, le code whubers produit exactement cette liste d'emplacements avec sa section la plus interne.

L'élément suivant est %% 10 ; cela prend un nombre et produit son reste par dix. Notre liste devient donc $ 1, 3, 5, 6, 8, 9, 1, 2, 3, 4, 6, 7, 8, 1, 2, 4, 6, 7, 8 $ . Si nous divisons cela en trois groupes - ceux qui proviennent de nombres compris entre $ 1 $ et 10 $ , ceux qui proviennent de nombres de 11 $ à 20 $ , et ceux qui proviennent de nombres 21 $ à 30 $ , nous obtenons 1, 3, 5, 6 $, 8, 9 $ , puis $ 1, 2, 3, 4, 6, 7, 8, $ et enfin 1, 2, 4, 6, 7, 8 $ . Ceux-ci vous indiquent où se trouvent les X dans chacune des trois lignes. Il y a un problème subtil ici: s'il y avait eu un X en position 10 dans la première ligne, la première de nos trois listes aurait été $ 1, 3, 5, 6, 8, 9 , 0 $ , et la fonction tabuler n'aime pas "0". Ainsi, whuber ajoute 1 à chaque élément de la liste pour obtenir 2 $, 4, 6, 7, 9, 10, 1 $ . Passons au calcul global:

  tabuler (sample.int (3 * 10, 10 * 1.9) %% 10 + 1, 10)
 

Ceci demande "pour ces 30 $ $ nombres, chacun indiquant s'il y a un X dans une colonne, dites-moi combien de fois chaque colonne (à partir de $ 1 $ à $ 10 $ --- c'est ce que le" 10 "final vous dit) apparaît, c'est-à-dire, dites-moi combien de X sont dans chaque colonne. Le résultat est 0 3 2 2 2 1 3 2 3 1 que (à cause du décalage de un), vous devez lire comme "il n'y a pas de X dans la 10e colonne; il y a 3 X dans la première colonne; il y a 2 X dans la deuxième colonne", et ainsi de suite à "il y a un X dans la 9ème colonne".

Cela vous donne dix entiers entre $ 0 $ et 3 $ $ dont la somme est 19 $ , d'où une moyenne de 1,9 $ . Si vous augmentez chacun d'eux de 1, vous obtenez dix entiers entre 1 $ et 4 $ $ dont la somme est 29 $ , d'où une valeur moyenne de 2,9 $ .

Vous pouvez généraliser à $ n = 100 $ , j'espère.

Vous pouvez utiliser sample () et sélectionner des probabilités spécifiques pour chaque entier. Si vous additionnez le produit des probabilités et des nombres entiers, vous obtenez la valeur attendue de la distribution. Donc, si vous avez une valeur moyenne en tête, disons $ k $ , vous pouvez résoudre l'équation suivante: $$ k = 1 \ fois P (1) + 2 \ fois P (2) + 3 \ fois P (3) + 4 \ fois P (4) $$ span > Vous pouvez choisir arbitrairement deux des probabilités et résoudre pour la troisième, qui détermine la quatrième (car $ P (1) = 1- (P (2) + P (3) + P (4)) $ car les probabilités doivent totaliser $ 1 $ ). Par exemple, laissez $ k = 2,3 $ , $ P (4) =. 1 $ et $ P (3) =. 2 $ . Alors on a ça $$ k = 1 \ fois [1- (P (2) + P (3) + P (4)] + 2 \ fois P (2) + 3 \ fois P ( 3) + 4 \ fois P (4) $$ $$ 2,3 = [1 - (P (2) +. 1 + .2)] + 2 * P (2) + 3 \ times .2 + 4 \ times .1 $$ $$ 2,3 = .7 + P (2) + .6 + .4 $$ $$ P (2) =. 6 $$ $$ P (1) = 1- (P (2) + P (3) + P (4) = 1 - (.6 + .1 + .2) =. 1 $$

Vous pouvez donc exécuter x <- sample (c (1, 2, 3, 4), 1e6, replace = TRUE, prob = c (.1, .6, .2, .1)) et mean (x) est d'environ 2,3 $ $

Voici un algorithme simple: Créez $ n-1 $ des entiers aléatoires dans la plage $ [1,4]$ et calculez l'entier $ n ^ {th} $ pour que la moyenne soit égale à la valeur spécifiée.Si ce nombre est inférieur à 1 $ ou supérieur à 4 $ $ , distribuez un par un le surplus /manque sur d'autres entiers, par exemplesi l'entier est 5 $ $ , nous avons un surplus de 1 $ ;et nous pouvons ajouter ceci au prochain entier si ce n'est pas $ 4 $ , sinon ajouter au suivant etc. Ensuite, mélangez tout le tableau.

En complément de la réponse de whuber, j'ai écrit un script en Python qui parcourt chaque étape du schéma d'échantillonnage. Notez que ceci est destiné à des fins d'illustration et n'est pas nécessairement performant.

Exemple de sortie:

  n = 10, s = 20, k = 4

Grille de départ
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
X X X X X X X X X X

Rempli dans la grille
X X. . X . X . . X
. . X X X. . . . .
. . . . X X. . . .
X X X X X X X X X X

Grille finale
X X. . X . X . . X
. . X X X. . . . .
. . . . X X. . . .
X X X X X X X X X X
2 2 2 2 4 2 2 1 1 2
 

Le script:

  importer numpy comme np

# Définir les paramètres de départ
entiers = [1, 2, 3, 4]
n = 10
s = 20
k = len (entiers)


def print_grid (grille, titre):
    imprimer (f '\ n {titre}')
    pour la ligne dans la grille:
        print ('' .join ([str (élément) pour élément dans la ligne]))


# Créer la grille de départ
grille = []
pour i dans la plage (1, k + 1):
    si je < k:
        grid.append (['.' for j in range (n)])
    autre:
        grid.append (['X' pour j dans range (n)])

# Imprimer la grille de départ
print_grid (grille, 'Grille de départ')

# Remplissez aléatoirement et uniformément les lignes restantes
index = np.random.choice (range ((k - 1) * n), s - n, replace = False)
pour i dans les index:
    row = i // n
    col = i% n
    grid [row] [col] = 'X'

# Imprimer la grille remplie
print_grid (grille, 'Rempli dans la grille')

# Calculez le nombre de cellules sélectionnées dans chaque colonne
column_counts = []
pour col dans la plage (n):
    count = sum (1 for i in range (k) if grid [i] [col] == 'X')
    column_counts.append (nombre)
grid.append (colonnes_compte)

# Imprimez la grille finale et vérifiez que la colonne compte somme à s
print_grid (grille, 'Grille finale')
impression()
print (f'La colonne compte-t-elle une somme à {s}? {sum (column_counts) == s}. ')
 

J'ai transformé la réponse de Whuber en fonction r.J'espère que cela aide quelqu'un.

• n est le nombre d'entiers que vous voulez;
• t est le moyen que vous voulez;et
• k est la limite supérieure que vous souhaitez pour vos valeurs renvoyées

  whubernator<-function (n = NULL, t = NULL, kMax = 5) {
  z = tabuler (sample.int (kMax * (n), (n) * (t), replace = F) %% (n) +1, (n))
  retour (z)
}
 

Cela semble fonctionner comme prévu:

  > w = whubernator (n = 10, t = 4,2)
> moyenne (w)
[1] 4,2
Longueur > (w)
[1] 10
> w
 [1] 3 5 3 5 5 3 4 5 5 4
 

Il peut renvoyer des 0, ce qui correspond à mes besoins.

  > whubernator (n = 2, t = 0,5)
[1] 1 0