Sind diese Würfel nicht transitiv?

31

Nichttransitive Würfel sind hübsche Spielzeuge, die sich unserer Wahrscheinlichkeitstheorie widersetzen . Für diese Herausforderung benötigen wir einige Definitionen:

Betrachten Sie zwei Würfel A und B, die gleichzeitig geworfen werden. Wir sagen , dass A schlägt B , wenn die Wahrscheinlichkeit von A eine größere Zahl als zu zeigen , B streng größer als die Wahrscheinlichkeit ist B eine größere Zahl als zu zeigen , A .

Jetzt einen Satz von drei Würfeln betrachten, mit Etikett A , B , C . Ein solcher Würfelsatz heißt nichttransitiv, wenn

  • entweder A schlägt B , B schlägt C und C schlägt A
  • oder C schlägt B , B schlägt A und A schlägt C .

Betrachten Sie als eines meiner Lieblingsbeispiele die Grime-Würfel mit den folgenden Seiten:

A: 3 3 3 3 3 6
B: 2 2 2 5 5 5
C: 1 4 4 4 4 4

Interessanterweise beträgt der Mittelwert jedes Würfels 3,5, genau wie bei einem normalen Würfel.

Das kann man zeigen:

  • A schlägt B mit einer Wahrscheinlichkeit von 7/12.
  • B schlägt C mit einer Wahrscheinlichkeit von 7/12.
  • C schlägt A mit einer Wahrscheinlichkeit von 25/36.

Jetzt sind diese besonderen Würfel noch seltsamer. Wenn wir jeden Würfel zweimal würfeln und die Ergebnisse addieren, wird die Reihenfolge der Schläge umgekehrt:

  • B schlägt A mit einer Wahrscheinlichkeit von 85/144.
  • C schlägt B mit einer Wahrscheinlichkeit von 85/144.
  • A schlägt C mit einer Wahrscheinlichkeit von 671/1296.

Nennen wir eine Reihe von Würfeln mit dieser Eigenschaft Grime-nicht-transitiv .

Andererseits, wenn die Würfel ihren ursprünglichen Zyklus behalten, wenn sie zwei Würfe verwenden, nennen wir sie stark nicht-transitiv . (Wenn es für zwei Würfe überhaupt keinen Zyklus gibt, nennen wir sie einfach nichttransitiv .)

Die Herausforderung

Gegeben drei sechsseitige Würfel, festzustellen , welche der oben genannten Eigenschaften dieser Satz hat und die Ausgabe einer der folgenden Strings: none, nontransitive, Grime-nontransitive, strongly nontransitive.

Sie können ein Programm oder eine Funktion schreiben, Eingaben über STDIN, Befehlszeilenargument, Eingabeaufforderung oder Funktionsargument vornehmen und das Ergebnis in STDOUT schreiben oder als Zeichenfolge zurückgeben.

Sie können davon ausgehen, dass alle Seiten nicht negative ganze Zahlen sind. Sie können nicht davon ausgehen, dass die Seiten oder die Würfel in einer bestimmten Reihenfolge sind. Sie können Eingaben in einem beliebigen Listen- oder Zeichenfolgeformat vornehmen.

Dies ist Codegolf, daher gewinnt die kürzeste Antwort (in Bytes).

Testfälle

none
1 2 3 4 5 6, 6 5 4 3 2 1, 1 3 5 2 4 6
1 1 1 6 6 6, 4 4 4 5 5 5, 5 5 5 5 5 5
1 1 2 5 6 6, 2 2 3 4 4 6, 2 3 3 4 4 5
0 1 2 3 4 5, 1 1 2 3 3 5, 1 2 2 2 3 5
3 13 5 7 13 7, 5 7 11 5 7 13, 5 9 13 5 7 9

nontransitive
1 2 2 4 6 6, 1 2 3 5 5 5, 2 3 4 4 4 4
1 4 4 4 4 4, 2 2 2 4 5 6, 2 3 3 3 5 5
1 2 1 6 5 6, 3 1 3 6 2 6, 2 4 2 4 4 5
3 4 6 6 7 7, 4 4 4 7 7 7, 5 5 5 5 6 7
2 5 11 11 14 14, 5 5 5 14 14 14, 8 8 8 8 8 17

Grime-nontransitive
3 3 3 3 3 6, 2 2 2 5 5 5, 1 4 4 4 4 4
1 1 4 5 5 5, 2 2 2 3 6 6, 3 3 3 4 4 4
2 1 4 6 4 4, 2 4 5 2 3 5, 3 3 6 3 3 3
11 11 13 15 15 16, 12 12 12 13 16 16, 13 13 13 14 14 14
4 4 7 16 19 19, 4 7 13 13 13 19, 4 10 10 10 16 19

strongly nontransitive
2 2 2 5 5 5, 2 3 3 3 5 5, 1 1 4 5 5 5
2 2 2 3 6 6, 2 2 2 5 5 5, 2 2 4 4 4 5
1 5 1 3 6 5, 6 6 4 2 2 1, 5 3 4 3 4 2
0 0 2 4 4 5, 0 1 1 3 5 5, 1 1 2 3 4 4
1 1 9 17 17 21, 1 5 5 13 21 21, 5 5 13 13 13 17

Wenn Sie Ihren Code noch ausführlicher testen möchten, hat Peter Taylor freundlicherweise eine Referenzimplementierung geschrieben, die alle ~ 5000 Würfelsätze mit den Seiten 1 bis 6 und einem Mittelwert von 3,5 klassifiziert. Pastebin-Link

Martin Ender
quelle
Ich hatte nichttransitive Würfel völlig vergessen. Vielen Dank :)
9.
Ist das erste nichttransitive Beispiel korrekt? 1 2 2 4 6 6, 1 2 3 5 5 5, 2 3 4 4 4 4Ich erhalte A <B 17/36, B> C 19/36, C <A 16/36.
Tobia
@Tobia Du vergisst, dass Ziehungen möglich sind. Sie müssen auch herausfinden, wie oft jeder Würfel gegen den anderen verliert, und prüfen, ob dies weniger als die Gewinnwahrscheinlichkeit ist: Ja A gewinnt gegen B mit 17/36, aber A verliert gegen B mit nur 16/36, also schlägt A B Ebenso gewinnt C gegen A mit 16/36, wie Sie sagten, aber C verliert gegen A mit nur 14/36, also schlägt C A.
Martin Ender

Antworten:

5

Dyalog APL, 107 100 Bytes

{({+/×+/¨,¨×⍵∘.-¨1⌽⍵}{3≠|a←⍺⍺⍵:1⋄a=b←⍺⍺∘.+⍨¨⍵:2⋄3+a=-b}⍵)⊃(⊂'none'),'strongly '⍬'Grime-',¨⊂'nontransitive'}

{T←{+/×+/¨∊¨×⍵∘.-¨1⌽⍵}⋄3≠|S←T⍵:'none'⋄N←'nontransitive'⋄S=D←T∘.+⍨¨⍵:'strongly ',N⋄S=-D:'Grime-',N⋄N}

(Danke @Tobia für diese einfachere, kürzere, bessere Lösung)

Grundlagen:

  • Zuordnung

  • Anweisungstrennzeichen

  • {} Lambda-Form

  • ⍺⍵ linkes und rechtes Argument

  • A:BWache ("wenn Adann zurück B")

Tist eine Funktion, die 3 zurückgibt, wenn A B schlägt, B C schlägt und C A schlägt; -3 wenn das genaue Gegenteil der Fall ist; und etwas dazwischen sonst. Im Detail:

  • 1⌽⍵ist die eine Umdrehung von . Wenn ABC ist, ist die Rotation BCA.

  • ∘.-berechnet eine Subtraktionstabelle zwischen zwei Vektoren ( 1 2...10 ∘.× 1 2...10wäre die Multiplikationstabelle, die wir aus der Schule kennen). Wir wenden dies zwischen jedem ( ¨) Element von und dem entsprechenden Element in an 1⌽⍵.

  • × Signum aller Zahlen in den Subtraktionstabellen

  • ∊¨ Flache jeden Tisch

  • +/¨und summiere es. Wir haben jetzt drei Zahlen, die das Gleichgewicht darstellen: Anzahl der Siege minus der Niederlagen für A gegen B, B gegen C, C gegen A.

  • × Zeichen von denen

  • +/ Summe

Behandeln Sie dann die Fälle der Reihe nach:

  • 3≠|S←T⍵:'none'Wenn T⍵der absolute Wert nicht 3 ist, wird 'none' zurückgegeben.

  • N←'nontransitive' Wir werden dieses Wort sehr brauchen

  • S=D←T∘.+⍨¨⍵:'strongly ',NBerechnen Sie Tfür Würfelpaare ( ∘.+⍨¨⍵← → ⍵((∘.+)¨)⍵) und geben Sie "stark ..." zurück, wenn die gleichen Beziehungen zwischen ABC immer noch bestehen

  • S=-D:'Grime-',N ⍝ "Schmutz", wenn die Beziehungen in die entgegengesetzte Richtung verlaufen

  • N Wenn alles andere fehlschlägt, einfach "nicht-transitiv"

ngn
quelle
1
Du warst schneller als ich! Ich habe vor 3 Tagen an diesem Problem gearbeitet, aber dann habe ich einfach aufgehört, meine Antwort zu schreiben. Es ist sowieso zu ähnlich zu deinem, also werde ich es einfach hier posten. Bei 100 Zeichen ist es etwas kürzer:{T←{+/×+/¨∊¨×⍵∘.-¨1⌽⍵}⋄3≠|S←T⍵:'none'⋄N←'nontransitive'⋄S=D←T∘.+⍨¨⍵:'strongly ',N⋄S=-D:'Grime-',N⋄N}
Tobia
@ MartinBüttner: Der korrekte Begriff im Titel lautet "Zeichen", da die Anzahl der Bytes je nach Zeichensatz, der zum Codieren der APL-Symbole verwendet wird, unterschiedlich ist. Traditionell wurden sie nach ASCII nur in der oberen Hälfte von 8-Bit-Bytes codiert. Heutzutage verwenden wir UTF-8, aber die alten Zeichensätze sind immer noch nützlich ... hauptsächlich, um die Anzahl der Bytes auf die Anzahl der Zeichen beim Golfen zu reduzieren!
Tobia
@Tobia Beim Codegolf trumpft man früher, damit man gewinnt! Ich bin nicht wirklich mit Golf-Etikette vertraut, aber ich denke, Sie sollten es als separate Antwort posten, da es wesentlich anders ist und Sie es unabhängig erreicht haben.
ngn
@Tobia Ich zähle auch lieber in Zeichen, aber wenn klassische Codierung vorausgesetzt wird, dann sind Bytes = Zeichen, also ist es vielleicht nicht wirklich wichtig, wie wir sie nennen ...
ngn
@Tobia Nun, es ist definitiv nutzlos, die Anzahl der Zeichen in einer Herausforderung anzugeben, die bytesweise punktet. Es hat jedoch noch niemand gesagt, dass wir UTF-8-Bytes bewerten. Tatsächlich besagt das Tag-Wiki ausdrücklich, dass für Zeichen außerhalb des ASCII-Bereichs eine andere vorhandene Kodierung verwendet werden kann. Und APL hat eine eigene Codepage, sodass der gesamte Zeichensatz in ein Byte passt. Die Richtlinie für PPCG lautet, diese Codepage zum Zählen von APL zu verwenden. Es ist kaum fair, APL zu bestrafen, wenn sie älter als ASCII ist.
Martin Ender
13

Python 2, 269

Hier ist ein netter kleiner Ausdruck, der zu einer Funktion ausgewertet wird. Es akzeptiert drei Listen mit ganzen Zahlen. Besteht alle Testfälle.

lambda A,B,C,w=lambda A,B:cmp(sum(cmp(a,b)for a in A for b in B),0),x=lambda A,B:cmp(sum(cmp(a+c,b+d)for a in A for b in B for c in A for d in B),0): (w(A,B)==w(B,C)==w(C,A)!=0)*((x(A,B)==x(B,C)==x(C,A))*["","strongly ","Grime-"][x(A,B)*w(A,B)]+"nontransitive")or"none"
Feersum
quelle
2

J - 311 257 Bytes

Update (13. Januar 2015):

g=:4 :'(+/,x>/y)>+/,y>/x'
h=:4 :'(,+/~x)g,+/~y'
f=: 3 :0
'a b c'=:y
if. (b g a)*(c g b)*a g c do.
a=.2{y
c=.0{y
end.
'none'([`]@.((a g b)*(b g c)*c g a))((''([`]@.((b h a)*(c h b)*a h c))'Grime-')([`]@.((a h b)*(b h c)*c h a))'strongly '),'nontransitive'
)

Erklärung: Vereinfachen Sie mit Gerunds die if.s zu @.s.

Ältere Version:

Versuchen Sie zuerst, sowohl in J zu codieren als auch Golf zu spielen.

g=:4 :'(+/,x>/y)>+/,y>/x'
h=:4 :'(,+/~x)g,+/~y'
f=: 3 :0
'a b c'=:y
if. (b g a)*(c g b)*a g c do.
a=.2{y
c=.0{y
end.
if. (a g b)*(b g c)*c g a do.
if. (a h b)*(b h c)*c h a do.
'strongly nontransitive'
elseif. (b h a)*(c h b)*a h c do.
'Grime-nontransitive'
elseif. do.
'nontransitive'
end.
else.
'none'
end.
)

Führen Sie es mit einer Syntax aus, die der folgenden ähnelt (zusätzliche Leerzeichen zur Verdeutlichung):

f 3 6 $          1 1 9 17 17 21, 1 5 5 13 21 21, 5 5 13 13 13 17

Erläuterung:

gist definiert als eine Diade zwei Arrays nehmen , die sagen , wenn die erste Würfel zweiten Würfel schlägt
hals eine Diade , wobei zwei Arrays definiert , die zweimal erzählt und Summieren , wenn werfen, tut erster Würfel zweiten schlagen
fist eine Monade , die eine Tabelle und gibt eine Zeichenkette mit dem Takes richtige Antwort

Bearbeiten: Behebung eines Fehlers in einem schmutzigen, nichttransitiven Zustand (Ersetzen ,durch *)

Jay Bosamiya
quelle
Ich würde mich über Verbesserungsvorschläge freuen. :)
Jay Bosamiya
@ Martinbüttner, ich hatte das anfangs versucht, wusste aber nicht, wie man über mehrere Zeilen (oder Sätze, wie es in J heißt) verkettet, ohne die Codelänge wesentlich zu erhöhen ... das Erlernen von "Gerunden" hat mich dazu veranlasst, das zu machen viele Sätze in einen, die den Code auch verkürzen ...
Jay Bosamiya
1

Pyth 129 133

Lmsd^b2Msmsm>bkGHDPNK-ghNeNgeNhNR?^tZ<KZKZAGHmsdCm,PkP,yhkyekm,@Qb@QhbUQ?"none"|!G%G3s[*!+GH"Grime-"*qGH"strongly ""nontransitive

Versuchen Sie es hier , oder zumindest könnten Sie es, aber das Online- evalSystem scheint Listen mit Listen nicht zu mögen :( Wenn Sie es dort versuchen möchten, speichern Sie manuell eine Liste mit 3 Würfeln in einer Variablen, die nicht vom Programm verwendet wird, und ersetzen Sie sie dann Alle Instanzen von Qmit dieser Variablen. Eine Beispielinitialisierung:

J[[3 3 3 3 3 6)[2 2 2 5 5 5)[1 4 4 4 4 4))

Damit sind alle Testfälle von Martin bestanden. Ich habe nicht das Herz, alle Fälle von Peter durchzugehen: P

Erklärung (das wird ein Trottel sein)

Lmsd^b2

Ziemlich einfach: Erstellt eine Funktion y, die die Summe aller kartesischen Wertepaare in einem Iterationsschritt zurückgibt. Entspricht: def y(b):return map(lambda d:sum(d),product(b,repeats=2)). Dies wird verwendet, um mehrseitige Würfel zu erstellen, die das zweimalige Werfen der regulären Würfel simulieren.

Msmsm>bkGH

Definiert eine Funktion gaus 2 Argumenten, die zurückgibt, wie oft ein Würfel einen anderen schlägt. Entspricht def g(G,H):return sum(map(lambda k:sum(map(lambda b:b>k,G)),H).

DPNK-ghNeNgeNhNR?^tZ<KZKZ

Definiert eine Funktion P, die eine Liste von zwei Würfeln als Argument verwendet. Dies ergibt -1, wenn der erste Würfel 'verliert', 0 für einen Gleichstand und 1, wenn der erste Würfel 'gewinnt'. Gleichwertig:

def P(N):
 K=g(N[0],N[-1]) - g(N[-1],N[0])
 return -1**(K<0) if K else 0

Das AGHAssigns verhält sich wie eine Python 2-Tupel-Zuweisung. Im WesentlichenG,H=(result)

msdCm,PkP,yhkyekm,@Qb@QhbUQ

Ich gehe zurück, um es in den Karten zu erklären. m,@Qb@QhbUQiteriert über b = 0..2 und erzeugt 2 Tupel Würfel mit Index b und Index b + 1. Dies gibt uns Würfel (A, B), (B, C), (C, A) (Pyth modifiziert die Indizes automatisch nach der Länge der Liste).

Nächster, m,PkP,yhkyek das Ergebnis der vorherigen Karte durchlaufen, wobei jedes Würfelpaar bei jedem Durchlauf in k gespeichert wird. Gibt tuple(P(k),P(tuple(y(k[0]),y(k[-1]))))für jeden Wert zurück. Das läuft auf `((A schlägt B ?, 2 * A schlägt 2 * B), (B schlägt C ?, 2 * B schlägt ..)) hinaus.

Schließlich msdCfasst die Werte der vorherigen Karte , nachdem es gezippt wurde. Der Reißverschluss bewirkt, dass alle Einzelwürfel im ersten Tupel und die Doppelwürfel im zweiten Tupel "Schläge" ergeben.

?"none"|!G%G3s[*!+GH"Grime-"*qGH"strongly ""nontransitive

Eine grobe Sache, die die Ergebnisse druckt. Wenn G 0 ist oder nicht durch 3 teilbar, diese bieten Fänge +/- 3, ( |!G%G3), druckt none, druckt sonst die Summe der follwing Liste: [not(G+H)*"Grime",(G==H)*"strongly ","nontransitive"]. Ich denke, die Booleschen sind in Bezug auf die Definitionen in der Frage ziemlich selbsterklärend. Beachten Sie, dass G hier nicht Null sein kann, da dies durch die vorherige Prüfung erfasst wird.

FryAmTheEggman
quelle
1

J (204)

Viel zu lange könnte man wahrscheinlich viel Golf spielen, wenn man ein effizienteres System zur Auswahl der richtigen Saite hätte.

f=:3 :'(<,>)/"1+/"2>"1,"2(<,>)/L:0{(,.(1&|.))y'
n=:'nontransitive'
d=:3 :0
if.+/*/a=.f y do.+/*/b=.f<"1>,"2+/L:0{,.~y if.a-:b do.'strongly ',n elseif.a-:-.b do.'Grime-',n elseif.do.n end.else.'none'end.
)
ɐɔıɐɔuʇǝɥʇs
quelle
1

Matlab (427)

Es ist nicht so kurz und ich bin sicher, dass es viel mehr Golf spielen kann. Ich habe nur versucht, diese Herausforderung zu lösen, weil ich dachte, dass es eine sehr lustige Aufgabe war. Vielen Dank an @ MartinBüttner für die Erstellung dieser Herausforderung!

a=input();b=input();c=input();
m = 'non';l=@(a)ones(numel(a),1)*a;n=@(a,b)sum(sum(l(a)>l(b)'));g=@(a,b)n(a,b)>n(b,a);s=@(a,b,c)sum([g(a,b),g(b,c),g(c,a)]);
x=s(a,b,c);y=s(a,c,b);if x~=3 && y~=3;m=[m,'e'];else m=[m,'transitive'];o=ones(6,1);a=o*a;a=a+a';a=a(:)';b=o*b;b=b+b';b=b(:)';c=o*c;c=c+c';c=c(:)';u=s(a,b,c);
v=s(a,c,b);if u==3|| v==3;if x==3&&u==3 || y==3&&v==3 m=['strongly ',m];else m=['Grime-',m];end;end;end;disp(m);

Hier der Code in voller Länge mit einigen Kommentaren, wenn Sie versuchen möchten, zu verstehen, was los ist. Ich habe einige Testfälle eingeschlossen und die Eingabebefehle ausgeschlossen:

%nontransitive
% a = [1 2 2 4 6 6];
% b = [1 2 3 5 5 5];
% c = [2 3 4 4 4 4];

%none
% a = [1 2 3 4 5 6];
% b = [6 5 4 3 2 1];
% c = [1 3 5 2 4 6];

%grime nontransitive
% a = [3 3 3 3 3 6];
% b = [2 2 2 5 5 5];
% c = [1 4 4 4 4 4];

%strongly nontransitive
% a = [2 2 2 5 5 5];
% b = [2 3 3 3 5 5];
% c = [1 1 4 5 5 5];

m = 'non';

l=@(a)ones(numel(a),1)*a;
n=@(a,b)sum(sum(l(a)>l(b)'));
%input as row vector, tests whether the left one beats the right one:
g=@(a,b)n(a,b)>n(b,a);
s=@(a,b,c)sum([g(a,b),g(b,c),g(c,a)]);
%if one of those x,y has the value 3, we'll have intransitivity
x=s(a,b,c); 
y=s(a,c,b);
if x~=3 && y~=3 %nontransitive
    m=[m,'e'];
else %transitive
    m=[m,'transitive'];
    o=ones(6,1);
    a=o*a;a=a+a';a=a(:)'; %all possible sums of two elements of a
    b=o*b;b=b+b';b=b(:)';
    c=o*c;c=c+c';c=c(:)';
    u=s(a,b,c);
    v=s(a,c,b);

    %again: is u or v equal to 3 then we have transitivity
    if u==3 || v==3 %grime OR strongly
        % if e.g. x==3 and u==3 then the 'intransitivity' is in the same
        % 'order', that means stronlgy transitive
        if x==3 && u==3 || y==3 && v==3%strongly
            m=['strongly ',m];
        else %grime
            m=['Grime-',m];
        end   
    end
end

disp(m);
Fehler
quelle
Ist es nicht kürzer, wenn Sie ein Array eins lesen input()und dann die drei Elemente zuweisen a,b,c? Verwenden Sie außerdem bitte die genauen Strings in der Spezifikation ( none, nontransitiveund aktiviert Grime) ... sollte wohl auch sparen Sie Bytes.
Martin Ender
Ja, das wäre wahrscheinlich kürzer, ich werde es mir ansehen. Die Zeichenfolgen sind genau die, in denen ich gerade die dispBefehle in der langen Version entfernt habe. Sie waren nur zum Testen des Programms gedacht, aber die endgültige Nachricht ist in gespeichert m. Und ich habe das korrigiert G.
Fehler
0

JavaScript - 276 Bytes

function(l){r=function(i){return l[i][Math.random()*6|0]};p=q=0;for(i=0;j=(i+1)%3,i<3;++i)for(k=0;k<1e5;++k){p+=(r(i)>r(j))-(r(i)<r(j));q+=(r(i)+r(i)>r(j)+r(j))-(r(i)+r(i)<r(j)+r(j))}alert((a=Math.abs)(p)>5e3?((a(q)>5e3?p*q>0?'strongly ':'Grime-':'')+'nontransitive'):'none')}

Die Wahrscheinlichkeit ist nicht sehr gut. Um sicher zu gehen, ziehe ich es vor, die Würfel hunderttausend Mal zu werfen.

Der Ausdruck ergibt eine Funktion, die nur mit einem Argument aufgerufen werden sollte: einem Array von drei Arrays von ganzen Zahlen. Überprüfen Sie die Geige , um den Code selbst ausführen zu können.

Hier ist die ungolfed Version:

function (diceList) {
    var getRandomValue = function (idDie) {
        return diceList[idDie][Math.floor(Math.random() * 6)];
    };

    var probabilitySimpleThrow = 0;
    var probabilityDoubleThrow = 0;

    for (var idDieA = 0; idDieA < 3; ++idDieA)
    {
        var idDieB = (idDieA + 1) % 3;
        for (var idThrow = 0; idThrow < 1e5; ++idThrow)
        {
            probabilitySimpleThrow += getRandomValue(idDieA) > getRandomValue(idDieB);
            probabilitySimpleThrow -= getRandomValue(idDieA) < getRandomValue(idDieB);

            probabilityDoubleThrow += getRandomValue(idDieA) + getRandomValue(idDieA) > getRandomValue(idDieB) + getRandomValue(idDieB);
            probabilityDoubleThrow -= getRandomValue(idDieA) + getRandomValue(idDieA) < getRandomValue(idDieB) + getRandomValue(idDieB);
        }
    }

    if (Math.abs(probabilitySimpleThrow) > 5e3) {
        if (Math.abs(probabilityDoubleThrow) > 5e3) {
            if (probabilitySimpleThrow * probabilityDoubleThrow > 0) {
                var result = 'strongly ';
            }
            else {
                var result = 'Grime-';
            }
        }
        else {
            var result = '';
        }

        result += 'nontransitive';
    }
    else {
        var result = 'none';
    }

    alert(result);
}
Schwarzes Loch
quelle
Hm, ich glaube nicht, dass dies wirklich im Geiste der Herausforderung liegt. Sie haben es im Grunde genommen von einer Wahrscheinlichkeitstheorie-Herausforderung in eine Statistik-Herausforderung verwandelt. ;) ... Anstelle von zufälligen Würfen können Sie einfach alle möglichen Würfe genau einmal aufzählen. Das würde Ihnen die genauen Ergebnisse liefern (und würde viel schneller ablaufen).
Martin Ender
Ich werde prüfen, ob dies zu einem präziseren Skript führt. Danke für deinen Rat :).
Blackhole