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

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"

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"

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 *)

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.

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.
)

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);

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);
}