Achterrandom = 50

Zunächst: Sobald eine Bedingung gestellt wird (Summe gleich 50), können wir nicht mehr ausschließlich mit Zufallszahlen arbeiten. Mindestens eine Zahl muss einem Zwang unterliegen, ist also nicht zufällig. Trotzdem kann man eine Verteilung erzielen, die einigermaßen zufällig aussieht.

Ich habe folgende Vorgehensweise verwendet: Wir wollen die 50 in 8 "Zufallszahlen" unterteilen. Dazu teilen wir unsere Gesamtsumme erstmal in kleine Pakete auf, mit denen wir arbeiten können. Vier Pakete mit jeweils einer Größe von 12.5 klingen doch annehmbar (12.5 * 4 = 50). Wir erzeugen nun für das erste Paket eine Zufallszahl zwischen 0 und 12.5, beispielsweise 7.5... Dann "vervollständigen" wir das Paket mit der Rechnung 7.5 + X = 12.5 => X = 12.5 - 7.5 = 5. Damit haben wir unsere ersten beiden "Zufallszahlen". Das wiederholen wir nun noch für die anderen drei Pakete, und schon erhalten wir 8 Zufallszahlen, die in der Summe 50 ergeben.
5+7.5+4+8.5+1+11.5+2+10.5=50

In Skriptform:

Die Frage mit den "Doppelten" stellte sich mir auch.
Wenn Doppelte erlaubt sind, ginge auch folgende Variante:

Habe etwas gebastelt. Leider ist die Methode sehr ineffizient, war eben die erste die mir eingefallen ist Als Parameter hat man die Anzahl Zahlen sowie die gewünschte Summe und einen Mindestwert (z.B. 1).

Edit: Im vergleich zu Brute Force ist sie schon schnell. Bei mir braucht sie meistens ca. 1 Millisekunde...

Zitat von Alina

Micha_he: hier bekomme ich am Ende eine Summe von über 50 raus.

Ich habe es mehrfach getestet und es passte immer. Allein die Zeile 17 stimmt mir dabei eigentlich schon zu !
Wenn dem so ist, habe ich zur Zeit keine Idee...

Edit (sichere Gesamtsumme):

Die Zahlen sind zwar doof verteilt aber zufällig und in ihrer Summe immer 50:

Naja, wenn nur Ganzzahlen gefordert sind...
Bei meiner Lösung entstehen zwangsläufig 4 Kommazahlen. Diese kann man auch wieder als zwei 2er-Pärchen (a,b) betrachten. Dann kann man einfach von a 0.5 abziehen und zu b dann dementsprechend 0.5 dazurechnen. Die Summe ändert sich nicht, es werden aber ausschließlich natürliche Zahlen erzeugt.

(Der Quellcode ist deutlich nicht optimiert. Es ist klar, dass immer die zweite Zahl die Kommazahl sein muss, wenn man mein Päckchenschema betrachtet. Dieses Wissen wurde hier nicht genutzt, um den Vorgang in einen eigenen Code-Block zu packen, damit meine Idee besser nachverfolgbar ist.)

Gruß

Hier nochmal eine Version mit Kontrolle auf doppelte Zahlen. Die Rechenzeit geht dadurch natürlich in die Höhe (liegt bei mir teils bei > 4 ms). Wenn etwas in der Ausgabe Rot ist heißt das, dass das Ergebnis unmöglich ist (z.B. 10 Zahlen jeweils größer als 5 mit der Summe 20) oder nicht genügend Rechenzeit verteilt wurde.
Bei der "Zufälligkeit" von nichtdoppelten Zahlen gibts aber ein wichtiges Problem zu beachten. Wenn [Anzahl Zahlen] * [Mindestwert] in etwa im Bereich der [Summe] liegt existiert keine zufälligkeit. Extremfall ist z.B. 2,3,4. 3 Zahlen mit der Summe 9. Dafür gibt es nur eine Lösung wenn doppelte verboten sind -> Kein Zufall !

Edit: Hier nochmal die Verteilung für Min = 1, Sum = 250, Anzahl = 20
[Blockierte Grafik: http://i.imgur.com/IfnGABU.png]
Sieht eigentlich ganz passabel aus finde ich...

Hallo, das Problem ließe sich in viele Richtungen lösen, jedoch sind nicht alle geeignet da sich die Wahrscheinlichkeit dass bestimmte Zahlen getroffen werden bei jedem Algorithmus unterscheidet. Die Schwierigkeit ist es, einen Algorithmus zu finden, der (wie beim echten Zufall) die Wahrscheinlichkeiten nicht verändert. Wer viel Zeit hat, kann sich ja mal im nachfolgenden die Theorie dazu durchlesen, ich versuche mal zu erklären wo genau das Problem liegt und wie man es lösen kann.

Gehen wir mal davon aus dass du die Summe 6 mit 2 Würfeln treffen möchtest. Jeder Würfel hat einen Wertbereich von 1 bis 4. So lässt sich das im Folgenden besser erklären.

Bei einem normalen Würfelwurf ist der Würfel eigentlich unabhängig von den anderen Würfeln. Das bedeutet, dass die Wahrscheinlichkeit für jede Seite des Würfels gleich ist getroffen zu werden. Sobald man aber auf eine bestimmte Summe hinaus spielt, verändern sich die Wahrscheinlichkeiten. Nun kommen nämlich die Variationen (nicht zu verwechseln mit den Kombinationen) ins Spiel, die alles so fürchterlich kompliziert machen. Weshalb Variationen? Ganz einfach, bei 2 Würfel mit jeweils 4 Augen können insgesamt 4² (also 16) mögliche Augenpaare getroffen werden. Aber nicht jedes Augenpaar entspricht der Summe 6. Siehe hier eine Liste:

1 + 1 = 2
1 + 2 = 3
1 + 3 = 4
1 + 4 = 5
2 + 1 = 3
2 + 2 = 4
2 + 3 = 5
2 + 4 = 6
3 + 1 = 4
3 + 2 = 5
3 + 3 = 6
3 + 4 = 7
4 + 1 = 5
4 + 2 = 6
4 + 3 = 7
4 + 4 = 8

Man sieht eindeutig, dass es Unterschiede gibt dass eine bestimmte Summe getroffen wird. Das liegt daran, dass auch die Anordnung der Würfel berücksichtigt werden muss. Wir haben also einen Summen-Bereich von 2 bis 8 vorliegen. Die Wahrscheinlichkeit eine bestimmte Summe zu treffen variiert also. Hier wieder eine Liste mit den Wahrscheinlichkeiten:

2 ->  1 von 16
3 ->  2 von 16
4 ->  3 von 16
5 ->  4 von 16
6 ->  3 von 16
7 ->  2 von 16
8 ->  1 von 16

Jetzt könnten wir natürlich solange neu würfeln lassen, bis wir die passende Summe erwischt haben, aber das kann je nach Summe und Anzahl der Würfel extrem lange dauern. Daher müssen wir nicht die Augenzahlen der Würfel zufällig bestimmen, sondern die Variationen. In diesem Beispiel sind also nur die Variationen (2|4) (3|3) (4|2) zulässig. Wenn wir diese in einem Array abspeichern, können wir also die Zufallszahlen anhand der Variation bestimmen und kämen auf jeden Fall auf unsere Summe.

Dim $aArr[3][2] = [[2, 4], [3, 3], [4, 2]]
Dim $iRnd = Random(0, 2, 1)

ConsoleWrite(' ' & $aArr[$iRnd][0] & ' + ' & $aArr[$iRnd][1] & ' = 6' & @CRLF)

Nun zu dem eigentlichen Problem, wir haben ja die Summe 50 und 8 Würfel. Der Wertbereich der Würfel soll zwischen 1 und 50 liegen. Das bedeutet dass wir nun alle Variationen erst einmal ermitteln müssen. Dazu hatte ich mal ein Thread aufgemacht wo eine durchaus brauchbare Funktion raussprang. Siehe mal hier: Kombinationen ermitteln

Und hier das Skript von Mars:

#include <Array.au3>

Global $a = _Calc(7, 4)
_ArrayDisplay($a)

Func _Calc($nErg, $iCnt)
Local $aRet[0][$iCnt], $u, $aCnt[$iCnt], $iPos = $iCnt - 1
Local $iSum
For $i = 0 To $iCnt - 1 Step 1
$aCnt[$i] = 1
Next
Do
$iSum = 0
For $i = 0 To $iCnt - 1 Step 1
$iSum += $aCnt[$i]
Next
If $iSum = $nErg Then
$u = UBound($aRet)
ReDim $aRet[$u+1][$iCnt]
For $i = 0 To $iCnt - 1 Step 1
$aRet[$u][$i] = $aCnt[$i]
Next
EndIf
Until Not _Array($iCnt, $aCnt, $iPos, $nErg)
Return $aRet
EndFunc ;==>_Calc

Func _Array(ByRef $iCnt, ByRef $aCnt, ByRef $iPos, $nErg)
$aCnt[$iPos] += 1
If $aCnt[$iPos] = $nErg And $iPos > 0 Then
$aCnt[$iPos] = 1
$iPos -= 1
_Array($iCnt, $aCnt, $iPos, $nErg)
$iPos += 1
EndIf
If $aCnt[0] = $nErg Then Return False
Return True
EndFunc ;==>_Array

Das müsste allerdings noch optimiert werden da dein Ergebnisraum zu groß ist. Das mache ich noch, aber nicht heute. Nur mal dass man ein Ansatz hat und die Wahrscheinlichkeit für jedes Ergebnis (wie bei einem Würfelwurf) auch gleich ist.

Achja, falls das irgendwer schon in seinem Skript umgesetzt hat, ich habe mir nicht alles durchgelesen.
Steinigt mich ansonsten. LG. Make

Zitat von AspirinJunkie

Die Zahlen sind zwar doof verteilt aber zufällig und in ihrer Summe immer 50:

Die (ersten 2-3) Zahlen sind (meistens) zwar (innerhalb der mathematischen Grenzen) zufällig, aber doof verteilt und in ihrer Summe immer 50. Vier bis fünf Einsen sind nicht ungewöhnlich!

Imho ist die Fragestellung bzw. die Anforderung schon gelinde gesagt fragwürdig!
Wie AspirinJunkie in seinem Script deutlich gezeigt hat! (Ich denke, das war deine Absicht, du Fuchs )
Man könnte mit minimalem Aufwand die Doppelten nicht zulassen, am Ergebnis würde sich nicht viel ändern!

Zitat von ShitDown

...Script...Das müsste allerdings noch optimiert werden da dein Ergebnisraum zu groß ist.

Der "Ergebnisraum" ist nicht zu groß, sondern aufgrund der Aufgabenstellung viel zu klein, s.o.

@Alina, woher kommt diese Aufgabenstellung?

Zitat von Andy

Wie AspirinJunkie in seinem Script deutlich gezeigt hat! (Ich denke, das war deine Absicht, du Fuchs )

Nö.
Eigentlich hatte ich bloß gerade mal kurz Zeit und hab da schnell ein Skript geschrieben.
Dass die Verteilung sich Richtung der kleineren Werte verschiebt war zwar klar aber so langweilig habe ich es dann auch nicht erwartet.

Mars' Grafik hat es dann aber sehr schön gezeigt wie die Verteilung tatsächlich aussieht.

Alina, ich verstehe dich nicht. Du möchtest "Zufällige" Zahlen. Ich hab natürlich nichts gegen AspirinJunkie, aber seine Funktion liefert im Regelfall hauptsächlich Einsen, das hat doch nix mit Zufällen zu tun.
Dann wurde nie wirklich gesagt ob Zahlen nun einzeln, oder auch mehrfach vorkommen sollen. Wir haben hier einige interessante Beiträge mit einigen interessanten resultierenden Verteilungen gefunden. (Falls ich etwas vergessen habe bitte schreit mich an, Die BF Methode hab ich absichtlich nicht 10.000x laufen lassen, hab keine Jahrzehnte Zeit :P)

Singe = Jede Zahl darf nur 1x vorkommen
Multi = Jede Zahl darf beliebig oft vorkommen
Micha_he - Der einzige der ne anständige (fast echte) Normalverteilung herzaubert (ist bei der Methode auch logisch)
Chesstiger - Hier bekommt der "Zufall" direkt noch eine Packung Kreativität verabreicht
AspirinJunkie - Klassischer Fall von 1/x² (oder sowas ähnliches)
Mars (Single) - Sieht für mich nach einer halbwegs gelungenen halben Normalverteilung aus. (ich glaube, dass diese Verteilung charakteristisch für das gegebene Problem ist)
Mars (Multi) - Auch irgendeine e Funktion

Überlege mal welche Anforderungen du an die Verteilung stellst. Vorallem das mit den Doppelten und der verlangten "Zufälligkeit" ist interessant. Beispielsweise geben Micha_he und Chesstiger hauptsächlich 5,6,7,8,9,10,11 aus. Chesstiger hat es geschafft in diesem Bereich eine (bis auf den Zacken) Gleichverteilung hinzubekommen, Micha_he eine Normalverteilung gebastelt. AspirinJunkie's Methode liefert abfallende Zahlen mit fast 50% Einsen (im schnitt nach 10.000 Versuchen).
[Blockierte Grafik: http://i.imgur.com/ixD9EOC.png]

Ich will meine Version einfach auch mal posten:

Global $aZahlen = FillArray()

Global $iSumme = 0
For $i = 0 To UBound($aZahlen) - 1
ConsoleWrite($aZahlen[$i] & @CRLF)
$iSumme += $aZahlen[$i]
Next
ConsoleWrite("Summe = " & $iSumme & @CRLF)

Func FillArray($iZahlen = 8, $iMax = 50)
Local $aZahlen[$iZahlen], $iSumme = Random(1, Int(($iMax - $iZahlen) / $iZahlen), 1), $i = 1
$aZahlen[0] = $iSumme
Do
$r = Random(1, Int(($iMax - $iSumme - $i) / 2) < 2 ? 2 : Int(($iMax - $iSumme - $i) / 2), 1)
If $r + $iSumme < $iMax Then
$iSumme += $r
$aZahlen[$i] = $r
$i += 1
EndIf
Until $i = $iZahlen
If $iMax - $iSumme Then $aZahlen[Random(0, $iZahlen - 1, 1)] += $iMax - $iSumme
Return $aZahlen
EndFunc

Keine Ahnung wie die Normalverteilung aussieht.

Gruß,
UEZ