Ich stimme X'ian zu, dass das Problem nicht genau angegeben ist. Es gibt jedoch eine elegante, skalierbare, effiziente, effektive und vielseitige Lösung, die eine Überlegung wert ist.

Da das Produkt aus Stichprobenmittelwert und Stichprobengröße der Stichprobensumme entspricht, besteht das Problem darin, eine Zufallsstichprobe mit $ n $ span> -Werten in der Menge $ \ {1,2, \ ldots, k \} $ span> diese Summe zu $ s $ span> (unter der Annahme von $ n \ le s \ le kn, $ span> natürlich).

Um die vorgeschlagene Lösung zu erläutern und hoffentlich die Behauptung von elegance, , zu rechtfertigen, biete ich eine grafische Interpretation dieses Stichprobenschemas an. Legen Sie ein Raster aus $ k $ span> -Zeilen und $ n $ span> -Spalten an. Wählen Sie jede Zelle in der ersten Zeile aus. Wählen Sie zufällig (und einheitlich) $ sn $ span> der verbleibenden Zellen in den Zeilen $ 2 $ span> bis $ k. $ span> Der Wert der Beobachtung $ i $ span> in der Stichprobe ist die Anzahl der in Spalte $ i: $ span>

Dieses $ 4 \ times 100 $ span> -Raster wird durch schwarze Punkte an den nicht ausgewählten Zellen und farbige Flecken an den ausgewählten Zellen dargestellt. Es wurde generiert, um einen Mittelwert von $ 2, $ span> zu erzeugen, also $ s = 200. $ span> Also $ 200-100 = 100 $ span> Zellen wurden zufällig aus den obersten $ k-1 = 3 $ span> Zeilen ausgewählt. Die Farben repräsentieren die Anzahl der ausgewählten Zellen in jeder Spalte. Es gibt $ 28 $ span>, $ 47 $ span> zwei, $ 22 $ span> drei und $ 3 $ span> vier. Das geordnete Beispiel entspricht der Farbfolge von Spalte $ 1 $ span> bis Spalte $ n = 100. $ span>

Um die Skalierbarkeit und Effizienz zu demonstrieren, finden Sie hier einen R -Befehl zum Generieren einer Stichprobe nach diesem Schema. Die Frage betrifft den Fall $ k = 4, n = 100 $ span> und $ s $ span> ist $ n $ span> mal der gewünschte Durchschnitt der Stichprobe:

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

Weil sample.int $ O (sn) $ span> Zeit und $ O (benötigt (k-1) n) $ span> Raum und tabulate erfordern $ O (n) $ span> Zeit und Raum, dieser Algorithmus benötigt $ O (\ max (sn, n)) $ span> Zeit und $ O (kn) $ span> Speicherplatz : das ist scalable. Mit $ k = 4 $ span> und $ n = 100 $ span> benötigt meine Workstation nur 12 Mikrosekunden, um diese Berechnung durchzuführen : das ist efficient.

(Hier eine kurze Erläuterung des Codes. Beachten Sie, dass Ganzzahlen $ x $ span> in $ \ {1,2, \ ldots, (k-1) n \} $ span> kann eindeutig ausgedrückt werden als $ x = nj + i $ span> wobei $ j \ in \ {0,1, \ ldots, k-2 \} $ span> und $ i \ in \ {1,2, \ ldots, n \}. $ span> Der Code nimmt ein Beispiel eines solchen $ x, $ span> konvertiert sie in ihren $ ( i, j) $ span> Gitterkoordinaten, zählt, wie oft jedes $ i $ span> erscheint (der von reicht $ 0 $ span> bis $ k-1 $ span>) und fügt jeder Zählung $ 1 $ span> hinzu.)

Warum kann dies als effective angesehen werden? Ein Grund dafür ist, dass die Verteilungseigenschaften dieses Stichprobenplans einfach zu ermitteln sind:

• Es ist austauschbar: Alle Permutationen einer Probe sind gleich wahrscheinlich.

• Die Wahrscheinlichkeit, dass der Wert $ x \ in \ {1,2, \ ldots, k \} $ span> an Position $ i, $ span>, den ich als $ \ pi_i (x), $ span> schreibe, wird durch ein grundlegendes hypergeometrisches Zählargument als $$ \ pi_i (x) = \ frac {\ binom {k-1} {x-1} \ binom {(n-1) (k-1)} {sn-x +1}} {\ binom {n (k-1)} {sn}}. $$ span> Zum Beispiel mit $ k = 4, $ span> $ n = 100, $ span> und ein Mittelwert von $ 2,0 $ span> (so dass $ s = 200 $ span>) Die Chancen stehen gut, dass $ \ pi = (0,2948, 0,4467, 0,2222, 0,03630), $ span> eng mit den Frequenzen übereinstimmt in der vorstehenden Stichprobe. Hier sind Diagramme von $ \ pi_1 (1), \ pi_1 (2), \ pi_1 (3), $ span> und $ \ pi_1 (4) $ span> als Funktion der Summe:

  

• Die Wahrscheinlichkeit, dass der Wert $ x $ span> an der Position $ i $ span> angezeigt wird, während der Der Wert $ y $ span> erscheint an der Position $ j $ span> wird ähnlich wie $$ \ 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}}. $$ span>

Diese Wahrscheinlichkeiten $ \ pi_i $ span> und $ \ pi_ {ij} $ span> ermöglichen das Anwenden des Horvitz-Thompson-Schätzer für dieses Wahrscheinlichkeitsstichproben-Design sowie zur Berechnung der ersten beiden Momente der Verteilung verschiedener Statistiken.

Schließlich ist diese Lösung versatile, sofern sie einfache, leicht analysierbare Variationen zur Steuerung der Stichprobenverteilung ermöglicht.Sie können beispielsweise Zellen im Raster mit bestimmten, aber ungleichen Wahrscheinlichkeiten in jeder Zeile oder mit einem urnenähnlichen Modell auswählen, um die Wahrscheinlichkeiten im Verlauf der Abtastung zu ändern und so die Häufigkeit der Spaltenanzahl zu steuern.

Die Frage ist insofern unterbestimmt, als die Einschränkungen für die Frequenzen \ begin {align} n_1 + 2n_2 + 3n_3 + 4n_4& = 100M \\ n_1 + n_2 + n_3 + n_4& = 100 \ end {align} span> Bestimmen Sie keine Verteilung: "zufällig" ist keiner bestimmten Verteilung zugeordnet, es sei denn, das OP bedeutet "einheitlich". Wenn zum Beispiel eine Lösung $ (n_1 ^ 0, n_2 ^ 0, n_3 ^ 0, n_4 ^ 0) $ span> für das obige System existiert, ist die Verteilung degeneriert Bei dieser Lösung wird eine zufällige Ziehung erzeugt, die immer $ (n_1 ^ 0, n_2 ^ 0, n_3 ^ 0, n_4 ^ 0) $ span> ist.

In dem Fall geht es darum, eine gleichmäßige Verteilung über das Gitter zu simulieren. \ begin {align} n_1 + 2n_2 + 3n_3 + 4n_4& = 100M \\ n_1 + n_2 + n_3 + n_4& = 100 \ end {align} span> Man kann immer einen Metropolis-Hastings-Algorithmus verwenden. Erstellen Sie ausgehend von $ (n_1 ^ 0, n_2 ^ 0, n_3 ^ 0, n_4 ^ 0) $ span> eine Markov-Kette, indem Sie symmetrische zufällige Störungen des Vektors $ (n_1 ^ t, n_2 ^ t, n_3 ^ t, n_4 ^ t) $ span> und akzeptiere, wenn das Ergebnis innerhalb von $ \ liegt {1,2,3,4 \} ^ 4 $ span> und erfüllt die Bedingungen.

Hier ist zum Beispiel ein grobes R-Rendering:

  cenM = 293
# Startpunkt (n¹, n³, n⁴)
n<-Probe (1: 100,3, rep = TRUE)
während ((Summe (n) >100) | (n [2] -n [1] + 2 * n [3]! = cenM-200))
    n<-Probe (1: 100,3, rep = TRUE)
# Markov Kette
für (t in 1: 1e6) {
  prop<-n + Probe (-10: 10,3, rep = TRUE)
  if ((sum (prop) <101) &
      (prop [2] -prop [1] + 2 * prop [3] == cenM-200) &
      (min (prop) >0))
        n = Stütze}
c (n [1], 100-Summe (n), n [-1])
 

mit der Verteilung von $ (n_1, n_3, n_4) $ span> über die 10⁶ Iterationen:

Wenn Sie die Ganzzahlen selbst zeichnen möchten,

  Probe (c (Wiederholung (1, n [1]), Wiederholung (2.100-Summe (n)), Wiederholung (3, n [2]), Wiederholung (4, n [3])) )
 

ist eine schnelle, schmutzige Methode von &, um eine Probe zu erstellen.

Ich möchte ... äh ... die erstaunliche Antwort von @ whuber "abschwächen", die laut @TomZinger zu schwer zu befolgen ist. Damit meine ich, dass ich es in Begriffen umschreiben möchte, die Tom Zinger meiner Meinung nach verstehen wird, weil es hier eindeutig die beste Antwort ist. Und da Tom nach und nach die Methode anwendet und feststellt, dass er beispielsweise die Verteilung der Proben kennen muss und nicht nur deren Mittelwert, wird die Antwort von whuber genau das sein, wonach er sucht.

Kurz gesagt: Hier gibt es keine originellen Ideen, nur eine einfachere Erklärung.

Sie möchten $ n $ span> Ganzzahlen von $ 1 $ span> bis $ 4 $ span> mit Mittelwert $ r $ span>. Ich werde vorschlagen, $ n $ span> Ganzzahlen von $ 0 $ span> bis $ 3 $ span> mit dem Mittelwert $ r-1 $ span>, und fügen Sie dann jedem einen hinzu. Wenn Sie das letztere tun können, können Sie das erste Problem lösen. Zum Beispiel, wenn wir 10 ganze Zahlen zwischen $ 1 $ span> und $ 4 $ span> mit dem Mittelwert $ 2.6 $ span>, Wir können diese $ 10 $ span> Ganzzahlen zwischen $ 0 $ span> und aufschreiben $ 3 $ span> ...

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

dessen Mittelwert $ 1.6 $ span> ist; Wenn wir jedes um $ 1 $ span> erhöhen, erhalten wir

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

dessen Mittelwert $ 2.6 $ span> ist. So einfach ist das.

Lassen Sie uns nun über die Zahlen $ 0 $ span> bis $ 3 $ span> nachdenken. Ich werde mir diese als "wie viele Gegenstände habe ich in einem 'kleinen' Set?" Ich habe möglicherweise keine Artikel, einen Artikel, zwei Artikel oder drei Artikel. Also die Liste

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

repräsentiert zehn verschiedene kleine Mengen. Der erste ist leer; Der zweite hat drei Elemente und so weiter. Die Gesamtzahl der Elemente in allen Sätzen ist die Summe der zehn Zahlen, d. H. $ 16 $ span>. Die durchschnittliche Anzahl der Elemente in jedem Satz ist diese Summe, geteilt durch $ 10 $ span>, also $ 1,6 $ span>.

whubers Idee ist folgende: Angenommen, Sie machen sich zehn kleine Sätze, wobei die Gesamtzahl der Elemente $ 10t $ span> für eine bestimmte Anzahl $ t $ span>. Dann ist die durchschnittliche Größe der Mengen genau $ t $ span>. Auf die gleiche Weise, wenn Sie sich $ n $ span> setzen, wobei die Gesamtzahl der Elemente $ nt $ span ist > Die durchschnittliche Anzahl von Elementen in einem Satz beträgt $ t $ span>. Sie sagen, Sie interessieren sich für den Fall $ n = 100 $ span>.

Lassen Sie uns dies für Ihr Beispiel konkretisieren: Sie möchten 100 Elemente zwischen 1 und 4, deren Durchschnitt $ 1.9 $ span> ist. Mit der Idee meines ersten Absatzes werde ich dies ändern, um " $ 100 $ span> Ints zwischen $ 0 $ zu machen. span> und $ 3 $ span>, deren Durchschnitt $ 0,9 $ span> "ist. Wenn ich fertig bin, füge ich jedem meiner Ints $ 1 $ span> hinzu, um eine Lösung für Ihr Problem zu finden. Mein Zieldurchschnitt ist also $ t = 0,9 $ span>.

Ich möchte $ 100 $ span> -Sätze mit jeweils zwischen $ 0 $ span> und $ 3 $ span> Elemente mit einer durchschnittlichen Set-Größe von $ 0,9 $ span>.

Wie ich oben bemerkt habe, bedeutet dies, dass insgesamt $ 100 \ cdot 0.9 = 90 $ span> Elemente vorhanden sein muss Die Sätze. Aus den Zahlen $ 1, 2, \ ldots, 300 $ span> werde ich genau $ 90 $ span> auswählen . Ich kann die ausgewählten angeben, indem ich eine Liste mit 300 Punkten und Xs erstelle:

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

wobei die obige Liste angibt, dass ich die Nummern 3, 9, 13, 14 und dann viele andere ausgewählt habe, die ich nicht angezeigt habe, weil ich es satt habe zu tippen. :) :) Ich kann diese Folge von 300 Punkten und Xs in drei Gruppen von jeweils 100 Punkten aufteilen, die ich übereinander anordne, um etwas zu erhalten, das so aussieht:

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

geht aber für volle 100 Elemente in jeder Zeile weiter. Die Anzahl der X in jeder Zeile kann unterschiedlich sein - es können beispielsweise 35 in der ersten Zeile, 24 in der zweiten und 31 in der dritten Zeile sein, und das ist in Ordnung. [Danke an whuber für den Hinweis, dass ich dies in einem ersten Entwurf falsch gemacht habe!]

Sehen Sie sich nun jede Spalte an: Jede Spalte kann als Satz betrachtet werden, und dieser Satz enthält zwischen 0 und 3 "X". Ich kann die Zahlen unter die Zeilen schreiben, um so etwas zu erhalten:

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

Das heißt, ich habe 100 Zahlen erzeugt, jede zwischen 1 und 3. Und die Summe dieser 100 Zahlen muss die Anzahl der X in allen drei Zeilen sein, die 90 war. Der Durchschnitt muss also sein $ 90/100 = 0.9 $ span> sein, wie gewünscht.

Hier sind die Schritte, um 100 Ganzzahlen zwischen 1 und 4 zu erhalten, deren Durchschnitt genau $ s $ span> ist.

1. Lassen Sie $ t = s - 1 $ span>.
2. Berechne $ k = 100 t $ span>; So viele Xs platzieren wir insgesamt in den Zeilen.
3. Erstellen Sie eine Liste mit 300 Punkten oder Xs, von denen $ k $ span> Xs sind.
4. Teilen Sie dies in drei Reihen mit 100 Punkten oder X auf, von denen jede mehr oder weniger etwa ein Drittel der X enthält.
5. Ordnen Sie diese in einem Array an und berechnen Sie Spaltensummen, wobei Sie 100 Ganzzahlen zwischen $ 0 $ span> und $ 3 $ span erhalten >. Ihr Durchschnitt ist $ t $ span>.
6. Fügen Sie jeder Spaltensumme eine hinzu, um 100 Ganzzahlen zwischen $ 1 $ span> und $ 4 $ span> zu erhalten, deren Durchschnitt ist $ s $ span>.
ol>

Nun ist der schwierige Teil davon wirklich in Schritt 4: Wie wählt man $ 300 $ span> Elemente aus, $ k $ span> von denen sind "X" und die anderen $ 300-k $ span> von denen sind "."? Nun, es stellt sich heraus, dass R eine Funktion hat, die genau das tut.

Und dann sagt Ihnen whuber, wie man es benutzt: Sie schreiben

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

Für Ihren speziellen Fall ist $ n = 100 $ span> und $ s $ span> die Gesamtzahl Die Anzahl der Elemente in allen kleinen Mengen beträgt $ 100r $ span>, und Sie möchten Zahlen zwischen $ 1 $ span> und $ 4 $ span>, also $ k = 4 $ span>, also $ k -1 $ span> (die größte Größe für eine 'kleine Menge') ist 3, daher wird dies

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

oder

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

oder unter Verwendung meines Namens $ t $ span> für $ r - 1 $ span> wird es

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

Das "+1" am Ende seiner ursprünglichen Formel ist genau der Schritt, der zum Konvertieren von "Zahlen zwischen $ 0 $ span> und $ 3 $ span>" bis "Zahlen zwischen $ 1 $ span> und $ 4 $ span>".

Lassen Sie uns von innen nach außen arbeiten und vereinfachen Sie $ n = 10 $ span>, damit ich Beispielausgaben anzeigen kann:

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

Und wollen wir $ t = 1.9 $ span> anstreben, also wird dies

  tabellieren (sample.int (3 * 10, 10 * 1,9) %% 10 + 1, 10)
 

Beginnend mit sample.int (3 * 10, 10 * 1.9) : Dies erzeugt eine Liste von $ 19 $ span> Ganzzahlen zwischen $ 1 $ span> und $ 30 $ span>. (dh es hat das Problem gelöst, $ k $ span> Zahlen aus Ihrer Gesamtzahl auszuwählen - $ 300 $ span> in Ihr eigentliches Problem, $ 30 $ span> in meinem kleineren Beispiel).

Wie Sie sich erinnern werden, möchten wir drei Reihen mit jeweils zehn Punkten und X erzeugen, so etwas wie

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

Wir können diese von links nach rechts von oben nach unten (d. h. normale Lesereihenfolge) lesen, um eine Liste von Positionen für Xs zu erstellen: Das erste Element ist ein Punkt; Das zweite und dritte sind Xs usw. Unsere Liste der Speicherorte beginnt also mit $ 1, 3, 5, 6, \ ldots $ span>. Wenn wir am Ende einer Zeile angelangt sind, zählen wir einfach weiter hoch. Für das obige Bild wären die X-Positionen $ 1, 3, 5, 6, 8, 9, 11, 12, 13, 14, 16, 17, 18, 21, 22, 24, 26, 27, 28 $ span>. Ist das klar?

Nun, Whubers-Code erzeugt genau diese Liste von Orten mit seinem innersten Abschnitt.

Das nächste Element ist %% 10 ; das nimmt eine Zahl und erzeugt seinen Rest bei Division durch zehn. Unsere Liste wird also zu $ 1, 3, 5, 6, 8, 9, 1, 2, 3, 4, 6, 7, 8, 1, 2, 4, 6, 7, 8 $ span>. Wenn wir das in drei Gruppen aufteilen - diejenigen, die aus Zahlen zwischen $ 1 $ span> und $ 10 $ span> stammen, diejenigen, die aus Zahlen von $ 11 $ span> bis $ 20 $ span> stammten, und diejenigen, die aus Zahlen $ 21 $ span> bis $ 30 $ span> erhalten wir $ 1, 3, 5, 6, 8, 9 $ span>, dann $ 1, 2, 3, 4, 6, 7, 8, $ span> und schließlich $ 1, 2, 4, 6, 7, 8 $ span>. Diese sagen Ihnen, wo sich die X in jeder der drei Zeilen befinden. Hier gibt es ein subtiles Problem: Wenn es in Position 10 in der ersten Zeile ein X gegeben hätte, wäre die erste unserer drei Listen $ 1, 3, 5, 6, 8, 9 gewesen , 0 $ span> und die Funktion tabulate mag "0" nicht. Whuber fügt also 1 zu jedem Element in der Liste hinzu, um $ 2, 4, 6, 7, 9, 10, 1 $ span> zu erhalten. Fahren wir mit der Gesamtberechnung fort:

  tabellieren (sample.int (3 * 10, 10 * 1,9) %% 10 + 1, 10)
 

Hier werden "nach diesen $ 30 $ span> -Nummern gefragt, die jeweils angeben, ob in einer Spalte ein X vorhanden ist. Geben Sie an, wie oft jede Spalte (ab $ 1 $ span> bis $ 10 $ span> --- das sagt Ihnen die letzte" 10 "), dh sagen Sie mir, wie viele Xs vorhanden sind sind in jeder Spalte. Das Ergebnis ist 0 3 2 2 2 1 3 2 3 1 welche (wegen der Verschiebung um eins) Sie lesen müssen als "es gibt keine Xs in der 10. Spalte; es gibt 3 Xs in der ersten Spalte; es gibt 2 Xs in der zweiten Spalte" und so weiter zu "es gibt ein X in der 9. Spalte".

Damit erhalten Sie zehn Ganzzahlen zwischen $ 0 $ span> und $ 3 $ span>, deren Summe $ 19 $ span>, daher der Durchschnitt $ 1,9 $ span>. Wenn Sie jeweils um 1 erhöhen, erhalten Sie zehn Ganzzahlen zwischen $ 1 $ span> und $ 4 $ span>, deren Summe $ 29 $ span>, daher ein Durchschnittswert von $ 2,9 $ span>.

Ich hoffe, Sie können auf $ n = 100 $ span> verallgemeinern.

Sie können sample () verwenden und für jede Ganzzahl bestimmte Wahrscheinlichkeiten auswählen. Wenn Sie das Produkt aus Wahrscheinlichkeiten und ganzen Zahlen summieren, erhalten Sie den erwarteten Wert der Verteilung. Wenn Sie also einen Mittelwert im Sinn haben, z. B. $ k $ span>, können Sie die folgende Gleichung lösen: $$ k = 1 \ mal P (1) + 2 \ mal P (2) + 3 \ mal P (3) + 4 \ mal P (4) $$ span > Sie können zwei der Wahrscheinlichkeiten beliebig auswählen und nach der dritten lösen, die die vierte bestimmt (weil $ P (1) = 1- (P (2) + P (3) + P) (4)) $ span>, da sich die Wahrscheinlichkeiten zu $ 1 $ span> summieren müssen). Beispiel: $ k = 2.3 $ span>, $ P (4) =. 1 $ span> und $ P (3) =. 2 $ span>. Dann haben wir das $$ k = 1 \ mal [1- (P (2) + P (3) + P (4)] + 2 \ mal P (2) + 3 \ mal P ( 3) + 4 \ mal P (4) $$ span> $$ 2.3 = [1 - (P (2) +. 1 + .2)] + 2 * P (2) + 3 \ mal .2 + 4 \ mal .1 $$ span> $$ 2.3 = .7 + P (2) + .6 + .4 $$ span> $$ P (2) =. 6 $$ span> $$ P (1) = 1- (P (2) + P (3) + P (4) = 1 - (.6 + .1 + .2) =. 1 $$ span>

Sie können also x <-sample (c (1, 2, 3, 4), 1e6, replace = TRUE, prob = c (.1, .6, .2, .1)) und mean (x) ist ungefähr $ 2.3 $ span>

Hier ist ein einfacher Algorithmus: Erstellen Sie $ n-1 $ span> zufällige Ganzzahlen im Bereich $ [1,4]$ span> und berechnen Sie die Ganzzahl $ n ^ {th} $ span>, damit der Mittelwert dem angegebenen Wert entspricht.Wenn diese Zahl kleiner als $ 1 $ span> oder größer als $ 4 $ span> ist, verteilen Sie nacheinander den Überschuss /Fehlen auf andere ganze Zahlen, zWenn die Ganzzahl $ 5 $ span> ist, haben wir $ 1 $ span> Überschuss;und wir können dies zur nächsten Ganzzahl hinzufügen, wenn es nicht $ 4 $ span> ist, sonst zur nächsten hinzufügen usw. Dann mischen Sie das gesamte Array.

Als Ergänzung zu Whubers Antwort habe ich ein Skript in Python geschrieben, das jeden Schritt des Stichprobenplans durchläuft. Beachten Sie, dass dies nur zur Veranschaulichung gedacht ist und nicht unbedingt performant ist.

Beispielausgabe:

  n = 10, s = 20, k = 4

Start
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
X X X X X X X X X X.

Raster ausgefüllt
X X. . X. X. . X.
. . X X X. . . . .
. . . . X X. . . .
X X X X X X X X X X.

Endgültiges Raster
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
 

Das Skript:

  importiere numpy als np

# Definieren Sie die Startparameter
ganze Zahlen = [1, 2, 3, 4]
n = 10
s = 20
k = len (ganze Zahlen)


def print_grid (Gitter, Titel):
    print (f '\ n {title}')
    für Zeile im Raster:
        print ('' .join ([str (Element) für Element in Zeile]))


# Erstellen Sie das Startraster
Gitter = []
für i im Bereich (1, k + 1):
    wenn ich < k:
        grid.append (['.' für j im Bereich (n)])
    sonst:
        grid.append (['X' für j im Bereich (n)])

# Drucken Sie das Startraster
print_grid (Raster, 'Startraster')

# Füllen Sie die verbleibenden Zeilen nach dem Zufallsprinzip und gleichmäßig aus
indexes = np.random.choice (Bereich ((k - 1) * n), s - n, replace = False)
für i in Indizes:
    row = i // n
    col = i% n
    grid [row] [col] = 'X'

# Drucken Sie das ausgefüllte Raster aus
print_grid (Gitter, 'Gitter ausgefüllt')

# Berechnen Sie, wie viele Zellen in jeder Spalte ausgewählt wurden
column_counts = []
für Spalte im Bereich (n):
    count = sum (1 für i im Bereich (k), wenn grid [i] [col] == 'X')
    column_counts.append (count)
grid.append (column_counts)

# Drucken Sie das endgültige Raster und überprüfen Sie, ob die Spaltenanzahl die Summe zu s ist
print_grid (Gitter, 'Endgitter')
drucken()
print (f'Zählt die Spalte die Summe zu {s}? {sum (column_counts) == s}. ')
 

Ich habe die Antwort von whuber in eine r-Funktion verwandelt.Ich hoffe es hilft jemandem.

• n gibt an, wie viele Ganzzahlen Sie möchten;

  whubernator<-Funktion (n = NULL, t = NULL, kMax = 5) {
  z = tabellarisch (sample.int (kMax * (n), (n) * (t), Ersetzen = F) %% (n) +1, (n))
  return (z)
}}
 

Es scheint wie erwartet zu funktionieren:

  > w = Whubernator (n = 10, t = 4,2)
> Mittelwert (w)
[1] 4.2
> Länge (w)
[1] 10
> w
 [1] 3 5 3 5 5 3 4 5 5 4
 

Es kann Nullen zurückgeben, was meinen Anforderungen entspricht.

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