Xúc xắc không tự động là những đồ chơi nhỏ xinh xắn thách thức trực giác của chúng ta trong lý thuyết xác suất. Chúng ta sẽ cần một vài định nghĩa cho thử thách này:

Xét hai con xúc xắc A và B được ném cùng một lúc. Chúng ta nói rằng một nhịp đập B nếu xác suất Một cho thấy một số lượng lớn hơn B là Nghiêm lớn hơn xác suất của B cho thấy một số lượng lớn hơn Một .

Bây giờ hãy xem xét một bộ ba con xúc xắc, với các nhãn Một , B , C . Một bộ xúc xắc như vậy được gọi là không tự động nếu

• hoặc A đập B , B đánh bại C và C đánh bại A
• hoặc C nhịp đập B , B nhịp đập Một và Một nhịp đập C .

Là một trong những ví dụ yêu thích của tôi, hãy xem xét xúc xắc Grime , có các mặt sau:

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

^{Thật thú vị, giá trị trung bình của mỗi con súc sắc là 3,5, giống như một con súc sắc thông thường.}

Người ta có thể chỉ ra rằng:

• A đánh bại B với xác suất 7/12.
• B đánh bại C với xác suất 7/12.
• C đánh bại A với xác suất 25/4.

Bây giờ những con xúc xắc đặc biệt này thậm chí còn lạ hơn. Nếu chúng ta lăn mỗi lần chết hai lần và cộng các kết quả, thứ tự nhịp sẽ được đảo ngược:

• B đánh bại A với xác suất 85/144.
• C đánh bại B với xác suất 85/144.
• Một nhịp C với xác suất 671/1296.

Chúng ta hãy gọi một bộ súc sắc với thuộc tính này Grime-nontransitive .

Mặt khác, nếu xúc xắc vẫn giữ chu kỳ ban đầu của chúng khi sử dụng hai lần ném, chúng tôi gọi chúng là không tự động mạnh mẽ . (Nếu không có chu kỳ nào cho hai lần ném, chúng tôi chỉ cần gọi chúng là không tự động .)

Các thách thức

Với ba con xúc xắc sáu mặt, xác định các thuộc tính trên bộ này có, và một đầu ra của chuỗi kí tự sau: none, nontransitive, Grime-nontransitive, strongly nontransitive.

Bạn có thể viết chương trình hoặc hàm, nhận đầu vào thông qua STDIN, đối số dòng lệnh, đối số nhắc hoặc hàm và viết kết quả vào STDOUT hoặc trả về dưới dạng chuỗi.

Bạn có thể cho rằng tất cả các mặt là số nguyên không âm. Bạn không thể cho rằng các mặt hoặc xúc xắc theo thứ tự cụ thể. Bạn có thể lấy đầu vào trong bất kỳ danh sách thuận tiện hoặc định dạng chuỗi.

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Các trường hợp thử nghiệm

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

Nếu bạn muốn kiểm tra mã của mình kỹ lưỡng hơn nữa, Peter Taylor đã rất tử tế khi viết một triển khai tham chiếu, trong đó phân loại tất cả ~ 5000 bộ xúc xắc có các cạnh từ 1 đến 6 và trung bình là 3,5. Liên kết pastebin

APL Dyalog, 107 100 byte

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

(Cảm ơn @Tobia vì giải pháp đơn giản hơn, ngắn hơn, tốt hơn này)

Khái niệm cơ bản:

• ← phân công

• ⋄ phân cách câu lệnh

• {} hình thức lambda

• ⍺⍵ tranh luận trái và phải

• A:Bbảo vệ ("nếu Asau đó trở lại B")

Tlà hàm trả về 3 nếu A đánh B, B đánh C và C đánh A; -3 nếu ngược lại chính xác là trường hợp; và một cái gì đó giữa các khác. Chi tiết:

• 1⌽⍵là một vòng quay của ⍵. Nếu ⍵là ABC, phép quay là BCA.

• ∘.-tính toán một bảng trừ giữa hai vectơ ( 1 2...10 ∘.× 1 2...10sẽ là bảng nhân mà chúng ta biết từ trường). Chúng tôi áp dụng điều này giữa mỗi mục ( ¨) của mục ⍵và mục tương ứng của nó trong 1⌽⍵.

• × dấu hiệu của tất cả các số trong bảng trừ

• ∊¨ làm phẳng mỗi bàn

• +/¨và tổng hợp nó. Bây giờ chúng ta có ba số đại diện cho số dư: số lần thắng trừ các trường hợp thua cho mỗi A vs B, B vs C, C vs A.

• × dấu hiệu của những

• +/ tổng

Sau đó lần lượt xử lý các trường hợp:

• 3≠|S←T⍵:'none'nếu T⍵giá trị tuyệt đối không phải là 3, hãy trả về 'none'

• N←'nontransitive' chúng ta sẽ cần từ này rất nhiều

• S=D←T∘.+⍨¨⍵:'strongly ',Ntính toán Tcho các cặp súc sắc ( ∘.+⍨¨⍵← → ⍵((∘.+)¨)⍵) và trả về "mạnh ..." nếu các mối quan hệ tương tự giữa ABC vẫn giữ

• S=-D:'Grime-',N "Grime" nếu các mối quan hệ ở hai hướng ngược lại

• N nếu vẫn thất bại, chỉ "không tự động"

Con trăn 2, 269

Đây là một biểu thức nhỏ đẹp để đánh giá một hàm. Nó chấp nhận ba danh sách các số nguyên. Vượt qua tất cả các trường hợp thử nghiệm.

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 256 byte

Cập nhật (ngày 13 tháng 1 năm 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'
)

Giải thích: Sử dụng Gerunds, đơn giản hóa if.s thành @.s.

Phiên bản cũ hơn:

Đầu tiên hãy thử cả mã hóa trong J cũng như chơi gôn.

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

Chạy nó bằng một cú pháp tương tự như sau (khoảng trắng thừa cho rõ ràng):

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

Giải trình:

gđược định nghĩa là một diad lấy hai mảng cho biết nếu xúc xắc thứ nhất đập xúc xắc thứ hai
hđược định nghĩa là một diad lấy hai mảng cho biết nếu ném hai lần và tính tổng, thì con xúc xắc thứ hai
fcó phải là một đơn vị lấy một bảng và trả về một chuỗi với câu trả lời đúng

Chỉnh sửa: Sửa lỗi trong điều kiện Grime-nontransitive (thay thế ,bằng *)

Tháp 129 133

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

Hãy thử ở đây hoặc ít nhất là bạn có thể, nhưng evaldường như trực tuyến không thích danh sách danh sách :( Nếu bạn muốn thử ở đó, hãy lưu trữ danh sách 3 con xúc xắc vào một biến không được chương trình sử dụng và sau đó thay thế tất cả các trường hợp Qvới biến đó. Một khởi tạo mẫu:

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

Điều này vượt qua tất cả các trường hợp thử nghiệm của Martin, tôi đã trải qua tất cả các trường hợp của Peter: P

Giải thích (đây sẽ là một doozy)

Lmsd^b2

Khá đơn giản, tạo một hàm ytrả về tổng của từng cặp giá trị của Cartesian trong một lần lặp. Tương đương với : def y(b):return map(lambda d:sum(d),product(b,repeats=2)). Điều này được sử dụng để tạo ra các khuôn nhiều mặt mô phỏng việc ném các khuôn thông thường hai lần.

Msmsm>bkGH

Xác định hàm g2 đối số trả về số lần chết của một đối số khác. Tương đương với def g(G,H):return sum(map(lambda k:sum(map(lambda b:b>k,G)),H).

DPNK-ghNeNgeNhNR?^tZ<KZKZ

Xác định một chức năng Plấy danh sách hai con xúc xắc làm đối số của nó. Điều này trả về -1 nếu chết đầu tiên 'thua', 0 cho hòa và 1 nếu chết đầu tiên 'thắng'. Tương đương với:

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

Các nhiệm vụ AGHhoạt động giống như một nhiệm vụ 2-python. bản chấtG,H=(result)

msdCm,PkP,yhkyekm,@Qb@QhbUQ

Đi để giải thích ngược thông qua các bản đồ. m,@Qb@QhbUQlặp lại trên b = 0..2 và tạo ra 2 con xúc xắc với chỉ số b và chỉ số b + 1. Điều này cho chúng ta xúc xắc (A, B), (B, C), (C, A) (pyth tự động sửa đổi chỉ mục theo độ dài của danh sách).

Tiếp theo, m,PkP,yhkyeklặp lại kết quả của bản đồ trước đó, với mỗi cặp súc sắc được lưu trữ trong k qua mỗi lần chạy. Trả về tuple(P(k),P(tuple(y(k[0]),y(k[-1]))))cho mỗi giá trị. Điều đó sôi xuống `((A beats B?, 2 * A beat 2 * B), (B beats C?, 2 * B beat ..)).

Cuối cùng, tính msdCtổng các giá trị của bản đồ trước đó sau khi được nén. Khóa kéo gây ra tất cả các giá trị của 'xúc xắc' trong bộ dữ liệu đầu tiên và các giá trị xúc xắc gấp đôi trong lần thứ hai.

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

Một điều thô mà in ra kết quả. Nếu G bằng 0 hoặc không chia hết cho 3, điều này sẽ bắt bot +/- 3, ( |!G%G3), in none, nếu không thì in tổng của danh sách follwing : [not(G+H)*"Grime",(G==H)*"strongly ","nontransitive"]. Tôi nghĩ rằng các booleans khá tự giải thích liên quan đến các định nghĩa trong câu hỏi. Xin lưu ý rằng G không thể bằng 0 ở đây, vì điều đó được kiểm tra trước đó.

J (204)

Quá lâu, có lẽ có thể bị đánh golf rất nhiều bằng cách có một hệ thống hiệu quả hơn để chọn đúng chuỗi.

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)

Nó không phải là ngắn và tôi chắc chắn rằng nó có thể được chơi golf nhiều hơn nữa, tôi chỉ cố gắng giải quyết thử thách này vì tôi nghĩ đó là một nhiệm vụ rất thú vị, vì vậy cảm ơn @ MartinBüttner đã tạo ra thử thách này!

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

Đây là đoạn mã đầy đủ với một số bình luận nếu bạn muốn cố gắng hiểu những gì đang diễn ra. Tôi đã bao gồm một số trường hợp kiểm tra thỏ và kêu lên các lệnh đầu vào:

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

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

Tôi không thực sự tốt về xác suất, vì vậy để chắc chắn về kết quả của mình, tôi thích ném xúc xắc hàng trăm ngàn lần.

Biểu thức ước lượng cho một hàm, nên được gọi chỉ với một đối số: một mảng gồm ba mảng số nguyên. Kiểm tra Fiddle để có thể tự chạy mã.

Đây là phiên bản chưa được chỉnh sửa:

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