Geçişsiz zar , olasılık teorisindeki sezgimize meydan okuyan hoş küçük oyuncaklardır. Bu meydan okuma için birkaç tanımlamaya ihtiyacımız olacak:

Aynı anda atılmış olan iki zar A ve B'yi düşünün . Biz söylemek A yener B olasılığı varsa A daha büyük sayısını gösteren B ihtimalinden çok sıkı büyüktür B den daha büyük bir sayı gösteren A .

Şimdi A , B , C etiketli üç zardan oluşan bir set düşünün . Zar Böyle bir kümesi denir geçişsiz ise

• ya bir atım B , B atım Cı ve Cı yener A
• ya da Cı- yener B , B yener bir ve bir atım C .

En sevdiğim örneklerden biri olarak , aşağıdaki taraflara sahip olan Grime zarını düşünün :

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

^{İlginçtir ki, her bir kalıbın ortalaması, normal bir kalıp gibi, 3.5'tir.}

Biri bunu gösterebilir:

• Bir yener B 7/12 bir olasılık ile.
• B , 7/12 olasılıkla C'yi yener .
• C 25/36 olasılıkla A'yı yener .

Şimdi bu özel zarlar daha da tuhaf. Her bir kalıbı iki kez yuvarlar ve sonuçları eklersek, attığı sıra tersine çevrilir:

• B yener A 85/144 bir olasılık ile.
• C 85/144 olasılık ile B yener .
• Bir yener C 671/1296 bir olasılık ile.

Bu özelliğe sahip Grime-nontitiveitive ile bir zar seti diyelim .

Öte yandan, iki atış kullanıldığında zar orijinal çevrimlerini koruyorsa, onlara güçlü bir şekilde geçişsiz diyoruz . (İki atış için hiç bir döngü yoksa, onlara geçişsiz diyoruz .)

Meydan okuma

Üç altı yüzlü zar, bu seti vardır Yukarıdaki özelliklerin belirlenmesi ve aşağıdaki dizeleri çıkış biri Verilen: none, nontransitive, Grime-nontransitive, strongly nontransitive.

Bir program veya işlev yazabilir, STDIN, komut satırı argümanı, hızlı ya da işlev argümanı yoluyla giriş alabilir ve sonucu STDOUT'a yazabilir veya bir dize olarak geri döndürebilirsiniz.

Tüm tarafların negatif olmayan tamsayılar olduğunu varsayabilirsiniz. Tarafların ya da zarların belirli bir sırada olduğunu kabul edemezsiniz. Herhangi bir uygun liste veya dize biçiminde giriş alabilirsiniz.

Bu kod golf, yani en kısa cevap (bayt cinsinden) kazanır.

Test Kılıfları

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

Eğer kodunuzu daha ayrıntılı bir şekilde test etmek istiyorsanız, Peter Taylor, yaklaşık ~ 1-5 arası zar gruplarını 1 ila 6 arasında olan ve ortalamaları 3.5 olan bir referans uygulaması yazmak için yeterliydi. Pastebin linki

Dyalog APL, 107 100 bayt

{({+/×+/¨,¨×⍵∘.-¨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}

(Bu daha basit, daha kısa, daha iyi çözüm için @ Tobia'ya teşekkürler)

Temelleri:

• ← atama

• ⋄ deyim ayırıcı

• {} lambda formu

• ⍺⍵ sol ve sağ argüman

• A:Bkoruma ("eğer Aöyleyse geri dön B")

TA, B'yi yenerse, B, C'yi yenerse ve C, A'yı yenerse, 3 döndüren bir işlevdir; -3 tam tersi durumda ise; ve başka türlü aralarında bir şey var. Detayda:

• 1⌽⍵tek dönüşüdür ⍵. Eğer ⍵ABC ise, rotasyon BCA olduğunu.

• ∘.-İki vektör arasında bir çıkarma tablosu hesaplar ( 1 2...10 ∘.× 1 2...10okuldan bildiğimiz çarpım tablosu olur). Bunu, içindeki her ( ¨) öğesi ile ⍵ilgili öğesinin arasına uygularız 1⌽⍵.

• × çıkarma tablolarındaki tüm sayıların işareti

• ∊¨ her masayı düzleştirmek

• +/¨ve topla. Şimdi dengeleri temsil eden üç sayıya sahibiz: A - B, B - C, C - A.

• × Bunların işareti

• +/ toplam

Sonra sırayla davaları ele:

• 3≠|S←T⍵:'none'eğer T⍵mutlak değer 3 değilse, 'none' döndür.

• N←'nontransitive' bu kelimeye çok ihtiyacımız olacak

• S=D←T∘.+⍨¨⍵:'strongly ',NEğer ABC arasındaki aynı ilişki devam ederse, Tzar çiftleri için hesaplamak ( ∘.+⍨¨⍵← → ⍵((∘.+)¨)⍵) ve "şiddetle ..." dön

• S=-D:'Grime-',N Relationships İlişkiler ters yöndeyse "Grime"

• N hepsi başarısız olursa, sadece "geçişsiz"

Python 2, 269

İşte bir işlevi değerlendiren hoş bir ifade. Üç tamsayı listesi kabul eder. Tüm test durumlarını geçer.

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 bayt

Güncelleme (13 Ocak 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'
)

Açıklama: Gerunds kullanarak, if.s ile @.s arasında sadeleştirin .

Eski versiyon:

İlk önce J'nin hem kodlamasını hem de golf oynamayı deneyin.

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

Aşağıdakine benzer bir sözdizimi kullanarak çalıştırın (netlik için fazladan boşluklar):

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

Açıklama:

gilk zarın
hatıp atmayacağını söyleyen iki diziyi alan bir diad olarak tanımlanır, ikinci zarın iki kez atıp topladığını söyleyen iki diziyi alan bir diad olarak tanımlanır, birinci zarın ikinci atım yapması
f, bir tablo alan ve dizeyle birlikte dönen bir dizedir. doğru cevap

Düzenleme: Pislik-geçişsiz durumda bir hata Fix (yerine ,birlikte *)

Pyth 129 133

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

Burada deneyin ya da en azından başarabilirsiniz, ancak çevrimiçi evallistelerin listelerine benzemiyor :( Orada denemek istiyorsanız, 3 zarlık bir listeyi el ile program tarafından kullanılmayan bir değişkende saklayın ve değiştirin. Qbu değişkenin tüm örnekleri : Örnek bir başlatma:

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

Bu, Martin'in tüm test davalarını geçiyor, kalbimin Peter'in tüm davalarından geçmediğini gördüm:

Açıklama (bu bir sarhoş olacak)

Lmsd^b2

Oldukça basit, yyinelenebilir her Kartezyen değer çiftinin toplamını döndüren bir işlev yapar . Eşdeğer için: def y(b):return map(lambda d:sum(d),product(b,repeats=2)). Bu, normal kalıpları iki kez atmayı simüle eden çok taraflı kalıplar oluşturmak için kullanılır.

Msmsm>bkGH

gBir kalıbın kaç kez diğerine attığını döndüren 2 argüman işlevini tanımlar . Eşdeğer def g(G,H):return sum(map(lambda k:sum(map(lambda b:b>k,G)),H).

DPNK-ghNeNgeNhNR?^tZ<KZKZ

PArgüman olarak iki zarın listesini alan bir fonksiyon tanımlar . İlk kalıp 'kaybederse' -1, ilk olarak 0 kazanır ve 1 kazanırsa 1 olur. Eşittir:

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

AGHAtar bir piton 2-lü atama gibi davranır. esasenG,H=(result)

msdCm,PkP,yhkyekm,@Qb@QhbUQ

Haritalar aracılığıyla geriye doğru açıklayacağım. m,@Qb@QhbUQb = 0..2'yi tekrarlar ve b indeksi ve b + 1 indeksiyle 2 tuples zar üretir. Bu bize (A, B), (B, C), (C, A) zarlarını verir (pyth otomatik olarak listenin uzunluğunu indeksler).

Daha m,PkP,yhkyeksonra, önceki haritanın sonucu üzerinde tekrar eder ve her zar çifti her çalıştırmada k olarak kaydedilir. İade tuple(P(k),P(tuple(y(k[0]),y(k[-1]))))her değer için. Bu, ('A, B?, 2 * A, 2 * B'yi yener), (B, C?, 2 * B, yener)' e düşer.)

Son olarak, msdCsıkıştırılmasından sonra önceki haritanın değerlerini toplar. Sıkıştırma işleminde zip, ilk zardaki tek zarların 'atma' değerlerine ve ikinci zardaki çift zar değerlerine neden olur.

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

Sonuçları çıkaran iğrenç bir şey. G, 0 ya da 3'e göre bölünemeyen bu mandallar bot +/- 3, (varsa |!G%G3), baskılar none, aksi following listesinin toplamı yazdırır: [not(G+H)*"Grime",(G==H)*"strongly ","nontransitive"]. Boolean'ların, sorudaki tanımlara gelince kendini açıklayıcı olduklarını düşünüyorum. Burada önceki kontrol tarafından yakalandığı için G'nin sıfır olamayacağını unutmayın.

J (204)

Çok uzun, doğru ipi seçmek için daha verimli bir sisteme sahip olmakla muhtemelen çok fazla golf oynayabilirsiniz.

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)

Çok kısa değil ve çok daha fazla golf oynayabileceğinden eminim, bu zorluğu çözmeye çalıştım çünkü çok eğlenceli bir iş olduğunu düşündüm, bu yüzden bu zorluğu yarattığı için teşekkürler @ MartinBüttner !

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

Burada neler olup bittiğini anlamaya çalışmak istiyorsanız bazı yorumlar ile tam uzunluk kodu. Bazı test senaryolarına tavşan dahil ettim ve giriş komutlarını hariç tuttum:

%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 bayt

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

Olasılıkta pek iyi değilim, bu yüzden sonuçlarımdan emin olmak için yüz binlerce kere zar atmayı tercih ederim.

İfade, yalnızca bir argümanla çağrılması gereken bir işlevi değerlendirir: üç tam sayı dizisi dizisi. Fiddle'ı kontrol etKodu kendiniz çalıştırabilmek .

İşte ungolfed versiyonu:

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