비전 이성 주사위 는 확률 이론에서 우리의 직감을 무시하는 멋진 장난감입니다. 이 도전에 대한 몇 가지 정의가 필요합니다.

동시에 던져지는 두 개의 주사위 A 와 B 를 고려하십시오 . 우리는 말할 A가 뛰는 B를 확률 경우 A가 보다 더 많은 보여주는 B를 확률보다 확실히 큰 B 보다 더 큰 수를 보여주는 를 .

이제 레이블 A , B , C가 있는 3 개의 주사위 세트를 고려하십시오. . 주사위의 같은 세트라고 비전이 있는 경우

• 중 A는 박동 B를 , B는 박동 C 와 C는 박동 을
• 또는 C 는 B를 , B 는 A를 , A 는 C를 친다 .

내가 가장 좋아하는 예 중 하나로서 다음과 같은 측면을 가진 Grime dice를 고려하십시오 .

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

^{흥미롭게도 각 다이의 평균은 일반 다이와 마찬가지로 3.5입니다.}

다음을 보여줄 수 있습니다.

• A 는 7/12의 확률로 B 를 이깁니다 .
• B 는 7/12의 확률로 C 를 이깁니다 .
• C 는 25/36의 확률로 A 를 이깁니다 .

이제이 특정 주사위는 더 이상합니다. 각 주사위를 두 번 굴려서 결과를 합하면 비트의 순서가 반대로됩니다.

• B는 뛰는 을 1백44분의 85의 확률로.
• C 비트 B를 144분의 85의 확률.
• A는 뛰는 C를 1,296분의 671의 확률로.

하자의 호출이 속성 주사위 세트 피부를 깨끗하게 - 비전 이적 .

반면에 두 번의 던지기를 사용할 때 주사위가 원래의주기를 유지한다면, 우리는 그것들을 강하게 비전 이적 이라고 부릅니다 . (두 번의 던지기에 전혀 사이클이 없다면, 우리는 단순히 그것들을 비전 이적 이라고 부릅니다 .)

도전

3-6면 주사위 세트가있는 상기 등록 정보를 결정하고, 다음의 문자열 중 하나의 출력이 제공되면 none, nontransitive, Grime-nontransitive, strongly nontransitive.

프로그램 또는 함수를 작성하고 STDIN, 명령 행 인수, 프롬프트 또는 함수 인수를 통해 입력을 가져 와서 결과를 STDOUT에 쓰거나 문자열로 리턴 할 수 있습니다.

모든 변이 음이 아닌 정수라고 가정 할 수 있습니다. 측면이나 주사위가 특정 순서로되어 있다고 가정 할 수 없습니다. 편리한 목록 또는 문자열 형식으로 입력 할 수 있습니다.

이것은 코드 골프이므로 가장 짧은 대답 (바이트)이 이깁니다.

테스트 사례

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

코드를 더 철저히 테스트하려면 Peter Taylor가 참조 구현을 작성하기에 충분히 친절했습니다.이 구현은 1 ~ 6 개의 측면과 평균 3.5의 주사위로 구성된 ~ 5000 세트를 모두 분류했습니다. Pastebin 링크

Dyalog APL, 107 100 바이트

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

(@Tobia에게이 더 간단하고 짧으며 더 나은 솔루션을 주셔서 감사합니다)

기초:

• ← 할당

• ⋄ 문장 구분자

• {} 람다 양식

• ⍺⍵ 좌우 논쟁

• A:B 가드 ( "if A 반환하면 B")

TA가 B를, B가 C를, C가 A를 이길 경우 3을 반환하는 함수입니다. 만약 정반대의 경우라면 -3; 그리고 그렇지 않은 것 사이의 무언가. 상세히:

• 1⌽⍵의 1 회전입니다 ⍵. 만약⍵ ABC는, 회전은 BCA입니다.

• ∘.-두 벡터 사이의 빼기 테이블을 계산합니다 ( 1 2...10 ∘.× 1 2...10학교에서 우리가 알고있는 곱셈 테이블입니다). 우리는 이것을 각 ( ¨) 항목 ⍵과 해당 항목 사이에 적용합니다 .1⌽⍵ .

• × 빼기 테이블에있는 모든 숫자의 부호

• ∊¨ 각 테이블을 평평하게하다

• +/¨그리고 합산하십시오. 우리는 이제 균형을 나타내는 세 가지 숫자를가집니다 : A vs B, B vs C, C vs A 각각에 대한 승패 사례 수.

• × 그것들의 signum

• +/ 합집합

그런 다음 케이스를 차례로 처리하십시오.

• 3≠|S←T⍵:'none' 만약 T⍵ 의 절대 값이 3 아니며, 창 '없음'

• N←'nontransitive' 이 단어가 많이 필요합니다

• S=D←T∘.+⍨¨⍵:'strongly ',NT주사위 쌍 ( ∘.+⍨¨⍵← → ⍵((∘.+)¨)⍵)을 계산 하고 ABC간에 동일한 관계가 계속 유지되면 "강하게 ..."를 반환합니다.

• S=-D:'Grime-',N relationships 관계가 반대 방향 인 경우 "Grime"

• N 다른 모든 것이 실패하면 "비전 이적"

파이썬 2, 269

다음은 함수로 평가되는 멋진 표현입니다. 세 개의 정수 목록을 허용합니다. 모든 테스트 사례를 통과합니다.

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 바이트

업데이트 (2015 년 1 월 13 일) :

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

설명 : Gerunds를 사용하여 if.s를 @.s로 단순화하십시오 .

이전 버전 :

먼저 J 코딩과 골프를 모두 시도하십시오.

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 3 6 $          1 1 9 17 17 21, 1 5 5 13 21 21, 5 5 13 13 13 17

설명:

g첫 번째 주사위가 두 번째 주사위를 이길 지 알려주는 두 개의 배열을 취하는 기저귀로 정의됩니다. 두 번째 주사위를
h던지고 합산하면 첫 번째 주사위를 두 번째로이기는지를 알려주는 두 개의 배열을 취하는 기저귀로 정의됩니다.
f 로 입니다. 정답

편집 : 피부를 깨끗하게-비전이 상태에서 실수를 수정 (교체 ,로 *)

Pyth 129 133

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

여기 에서 시도해 보거나 적어도 할 수는 있지만 온라인 eval에서는 목록 목록을 좋아하지 않는 것 같습니다. (여기서 시도하려면 3 개의 주사위 목록을 프로그램에서 사용하지 않는 변수에 수동으로 저장 한 다음 교체하십시오 Q해당 변수 를 가진 모든 인스턴스 샘플 초기화 :

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

이것은 마틴의 모든 테스트 사례를 통과합니다. 나는 마음이 피터의 모든 사례를 거치지 않았습니다.

설명 (이것은 두지가 될 것입니다)

Lmsd^b2

매우 간단 y하며 반복 가능한 각 카티 전 값 쌍의 합을 반환 하는 함수 를 만듭니다 . 에 해당합니다 def y(b):return map(lambda d:sum(d),product(b,repeats=2)). 일반 다이를 두 번 던지는 것을 시뮬레이션하는다면 다이를 만드는 데 사용됩니다.

Msmsm>bkGH

g주사위가 다른 주사위를 몇 번 때리는지를 반환하는 2 개의 인수 함수 를 정의합니다 . 에 해당합니다 def g(G,H):return sum(map(lambda k:sum(map(lambda b:b>k,G)),H).

DPNK-ghNeNgeNhNR?^tZ<KZKZ

P두 주사위의 목록을 인수로 취하는 함수 를 정의합니다 . 첫 번째 주사위가 '손실'되면 -1을, 넥타이는 0을, 첫 번째 주사위가 '승리'하면 1을 반환합니다. 다음과 같습니다.

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

AGH양수인은 파이썬이 터플 할당과 같은 역할을합니다. 본질적으로G,H=(result)

msdCm,PkP,yhkyekm,@Qb@QhbUQ

지도를 거꾸로 설명하려고합니다. m,@Qb@QhbUQb = 0..2를 반복하고 인덱스 b와 인덱스 b + 1을 가진 2 튜플 주사위를 생성합니다. 이것은 우리에게 주사위 (A, B), (B, C), (C, A)를 제공합니다 (pyth는 목록의 길이에 따라 색인을 자동으로 수정합니다).

그런 다음 m,PkP,yhkyek이전 맵의 결과를 반복하고 각 주사위 쌍은 각 런에 k로 저장됩니다. 보고tuple(P(k),P(tuple(y(k[0]),y(k[-1]))))각 값에 대해 합니다. 그것은`((A는 B를 비트?, 2 * A는 2 * B를 비트), (B는 C를 비트, 2 * B 비트 ..))로 귀결됩니다.

마지막 msdC으로 압축 된 후 이전 맵의 값을 합산합니다. zip은 첫 번째 튜플의 모든 단일 주사위 '비트'값과 두 번째 주사위의 이중 주사위 값을 유발합니다.

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

결과를 출력하는 중대한 것. G가 0이거나 3으로 나눌 수없는 경우, 봇 +/- 3을 포착하고 ( |!G%G3)를 인쇄하고 none, 그렇지 않으면 다음과 같이 다음과 같은 목록을 출력합니다 [not(G+H)*"Grime",(G==H)*"strongly ","nontransitive"]. 부울은 문제의 정의와 관련하여 상당히 자명하다고 생각합니다. 이전 검사에서 포착 한 G는 0이 될 수 없습니다.

J (204)

너무 길면 올바른 줄을 고르는 데 더 효율적인 시스템을 사용하여 골프를 많이 할 수 있습니다.

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)

그것은 짧지 않고 더 많이 골프를 칠 수 있다고 확신합니다.이 도전을 매우 재미있는 작업으로 생각했기 때문에이 문제를 해결하려고 했습니다. 그래서이 도전을 만든 @ 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);

무슨 일이 일어나고 있는지 이해하고 싶다면 주석이 달린 전체 길이 코드가 있습니다. 몇 가지 테스트 사례를 포함하고 입력 명령을 제외했습니다.

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

자바 스크립트-276 바이트

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

나는 실제로 확률이 좋지 않기 때문에 결과를 확신하기 위해 주사위를 수십만 번 던지는 것을 선호합니다.

이 표현식은 함수로 평가되며, 하나의 인수로만 호출해야합니다. 세 개의 정수 배열로 구성된 배열입니다. 직접 코드를 실행할 수 있도록 Fiddle 을 확인 하십시오.

ungolfed 버전은 다음과 같습니다.

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