도전 설명

몇 가지 정의부터 시작하겠습니다.

• 관계는 (우리가 정수를 사용하게 될이 도전) 요소의 순서쌍의 집합입니다

예를 들어, [(1, 2), (5, 1), (-9, 12), (0, 0), (3, 2)]관계입니다.

• 관계가 불려 전이 원소의 두 쌍에 대한 경우 (a, b)와 (b, c)이러한 관계에서, 한 쌍 (a, c)또한 존재하고,

• [(1, 2), (2, 4), (6, 5), (1, 4)]가 포함되어 있기 때문에, 이적이다 (1, 2)하고 (2, 4)있지만, (1, 4)뿐만 아니라,

• [(7, 8), (9, 10), (15, -5)]두 DNA의 기초하지 않기 때문에, 이행이며 (a, b), (c, d)본되도록 b=이 c.

• [(5, 9), (9, 54), (0, 0)](5, 9)과를 포함하지 않기 때문에 전 이적 (9, 54)이지 않습니다.(5, 54)

정수 쌍 목록이 제공되면 관계가 전이인지 여부를 판별하십시오.

입출력

합리적인 형식의 정수 쌍 목록이 제공됩니다. 관계를 고려

[(1, 6), (9, 1), (6, 5), (0, 0)]

다음 형식은 동일합니다.

[(1, 6), (9, 1), (6, 5), (0, 0)] # list of pairs (2-tuples)
[1, 9, 6, 0], [6, 1, 5, 0] # two lists [x1, x2, ..., xn] [y1, y2, ..., yn]
[[1, 6], [9, 1], [6, 5], [0, 0] # two-dimentional int array
[4, 1, 6, 9, 1, 6, 5, 0, 0] # (n, x1, y1, ..., xn, yn)
[1+6i, 9+i, 6+5i, 0+0i] # list of complex numbers

... many others, whatever best suits golfing purposes

결과 : 전이 관계에 대한 진실 된 가치, 그렇지 않으면 거짓. 입력이 하나 이상의 쌍으로 구성되고 쌍이 고유하다고 가정 할 수 있습니다.

하스켈, 42 바이트

f x=and[elem(a,d)x|(a,b)<-x,(c,d)<-x,b==c]

사용 예 : f [(1,2), (2,4), (6,5), (1,4)]-> True.

모든 쌍에 대한 (외부) 루프 (a,b)와 동일한 쌍에 대한 (내부) 루프 . 이미 존재하는 쌍 인지 여부를 확인할 (c,d)때마다 호출 됩니다 . 결과와 logical을 결합하십시오 .b==c(a,d)and

 프롤로그, 66 바이트

t(L):-not((member((A,B),L),member((B,C),L),not(member((A,C),L)))).

관계가되어 있지 우리가 (A, B) 등을 찾아 낼 수있는 경우는 이행 (B, C) (A, C)를 보유하지 않도록.

MATL , 27 25 바이트

7#u2e!l6MX>thl4$XQttY*g<~

입력 형식은 ;각 관계 쌍이 열인 행렬 ( 행 구분 기호로 사용)입니다. 예를 들어 테스트 사례

[(1, 2), (2, 4), (6, 5), (1, 4)]
[(7, 8), (9, 10), (15, -5)]
[(5, 9), (9, 54), (0, 0)]

각각으로 입력

[1 2 6 1; 2 4 5 4]
[7 9 15; 8 10 -5]
[5 9 0; 9 54 0]

Truthy 출력은 하나에 의해 형성된 매트릭스입니다. Falsy 는 하나 이상의 0을 포함하는 행렬입니다.

온라인으로 사용해보십시오!

설명

코드는 먼저 입력 정수를 고유 한 1 기반 정수 값으로 줄입니다. 이 값으로부터 인접 행렬이 생성됩니다. 행렬 자체로 곱합니다. 결과 행렬의 0이 아닌 값을 1로 변환합니다. 마지막으로 후자의 행렬에있는 항목이 인접 행렬의 항목을 초과하지 않는지 확인합니다.

자바 스크립트 (ES6), 69 67 바이트

a=>(g=f=>a.every(f))(([b,c])=>g(([d,e])=>c-d|!g(([d,c])=>b-d|c-e)))

@Cyoce의 아이디어 덕분에 2 바이트를 절약했습니다. 이전의 69 바이트 공식에는 네 가지가있었습니다.

a=>a.every(([b,c])=>a.every(([d,e])=>c-d|a.some(([d,c])=>b==d&c==e)))
a=>!a.some(([b,c])=>!a.some(([d,e])=>c==d&a.every(([d,c])=>b-d|c-e)))
a=>a.every(([b,c])=>a.every(([d,e])=>c-d|!a.every(([d,c])=>b-d|c-e)))
(a,g=f=>a.every(f))=>g(([b,c])=>g(([d,e])=>c-d|!g(([d,c])=>b-d|c-e)))

Brachylog , 24 바이트

'{psc[A:B:B:C],?'e[A:C]}

온라인으로 사용해보십시오!

설명:

'{psc[A:B:B:C],?'e[A:C]}
'{                     } it is impossible to find
    c                    a flattened
   s                     subset of
  p                      a permutation of the input
     [A:B:B:C]           that has four elements, with the second and third equal
              ,?         and such that the input
                'e       does not contain
                  [A:C]  a list formed of the first and fourth element

다시 말해, 입력에 쌍 [A:B]과 가 포함되어 있으면 [B:C]입력을 시작하여 시작 [A:B]및 [B:C]시작시 다른 모든 요소를 ​​삭제하고 목록을 생성 할 수 [A:B:B:C]있습니다. 그런 다음 내부 술어에서 (진정한 프로그램 전체에서) 진실을 반환 [A:C]합니다.

CJam (22 바이트)

{__Wf%m*{z~~=*}%\-e_!}

온라인 테스트 스위트 . 이것은 익명 블록 (함수)으로 요소를 2 단계 배열로 사용하지만 테스트 스위트는 문자열 조작을 수행하여 입력을 적절한 형식으로 먼저 넣습니다.

해부

{         e# Begin a block
  _       e#   Duplicate the argument
  _Wf%    e#   Duplicate again and reverse each pair in this copy
  m*      e#   Cartesian product
  {       e#   Map over arrays of the form [[a b][d c]] where [a b] and [c d]
          e#   are in the relation
    z~~=* e#     b==c ? [a d] : []
  }%
  \-      e#   Remove those transitive pairs which were in the original relation
  e_!     e#   Test that we're only left with empty arrays
}

Pyth, 14 바이트

!-eMfqFhTCM*_M

테스트 스위트

입력 형식은 [[0, 0], [0, 1], ... ]

!-eMfqFhTCM*_M
!-eMfqFhTCM*_MQQQ    Variable introduction
            _MQ      Reverse all of the pairs
           *   Q     Cartesian product with all of the pairs
         CM          Transpose. We now have [[A2, B1], [A1, B2]] for each pair
                     [A1, A2], [B1, B2] in the input.
    f                Filter on
       hT            The first element (the middle two values)
     qF              Being equal
  eM                 Take the end of all remaining elements (other two values)
 -              Q    Remove the pairs that are in the input
!                    Negate. True if no transitive pairs were not in the input

매스 매 티카, 49 바이트

#/.{x=___,{a_,b_},x,{b_,c_},x}/;#~FreeQ~{a,c}:>0&

쌍의 목록을 취하는 순수한 기능. 입력리스트가 포함되어있는 경우 {a,b}와 {b,c}아닌 {a,c}일부 a, b, c, 그것을 대체합니다 0. Truthy는 입력 목록이고 Falsy는 0입니다.

C ++ 14, 140 바이트

참조 매개 변수를 통해 반환되는 명명되지 않은 람다. 입력이의 컨테이너 여야합니다 pair<int,int>. 지루한 O (n ^ 3) 방식을 취합니다.

[](auto m,int&r){r=1;for(auto a:m)for(auto b:m)if (a.second==b.first){int i=0;for(auto c:m)i+=a.first==c.first&&b.second==c.second;r*=i>0;}}

언 골프 및 사용법 :

#include<vector>
#include<iostream>

auto f=
[](auto m,int&r){
  r=1;                         //set return flag to true
  for(auto a:m)                //for each element
    for(auto b:m)              //check with second element
      if (a.second==b.first){  //do they chain?
        int i=0;               //flag for local transitivity
        for(auto c:m)          //search for a third element
          i+=a.first==c.first&&b.second==c.second;
        r*=i>0;                //multiply with flag>0, resulting in 0 forever if one was not found
      }
}
;

int main(){
 std::vector<std::pair<int,int>> m={
  {1, 2}, {2, 4}, {6, 5}, {1, 4}
 };

 int r;
 f(m,r);
 std::cout << r << std::endl;

 m.emplace_back(3,6);
 f(m,r);
 std::cout << r << std::endl;

 m.emplace_back(3,5);
 f(m,r);
 std::cout << r << std::endl;

}

파이썬 2 , 91 67 55 바이트

lambda s:all(b-c or(a,d)in s for a,b in s for c,d in s)

온라인으로 사용해보십시오!

Leaky Nun 덕분에 -24 바이트
Bubbler 덕분에 -12 바이트

공리 103 바이트

c(x)==(for i in x repeat for j in x repeat if i.2=j.1 and ~member?([i.1, j.2],x)then return false;true)

언 골프 :

c(x)==
  for i in x repeat
    for j in x repeat
       if i.2=j.1 and ~member?([i.1, j.2],x) then return false
  true

                                                                   Type: Void

운동

(2) -> c([[1,2],[2,4],[6,5],[1,4]])
   Compiling function c with type List List PositiveInteger -> Boolean
   (2)  true
                                                                Type: Boolean
(3) -> c([[7,8],[9,10],[15,-5]])
   Compiling function c with type List List Integer -> Boolean
   (3)  true
                                                            Type: Boolean
(4) -> c([[5,9],[9,54],[0,0]])
   Compiling function c with type List List NonNegativeInteger ->
      Boolean
   (4)  false

Pyth- 22 21 바이트

.Am},hdedQfqFtPTsM^Q2

테스트 스위트 .

클로저, 56 53 바이트

업데이트 : 대신 사용하는 :when난 그냥 모든 쌍에 대한 것을 확인할 수 있습니다 [a b] [c d]중 하나 b != c또는 [a d]입력 세트에서 발견된다.

#(every? not(for[[a b]%[c d]%](=[b nil][c(%[a d])])))

기발한:

와우, Clojure for loops가 멋지다 : D 이것은 for루프가 잘못된 값을 생성하지 않는지 점검한다. 이것은 [a d]입력 세트에서 발견 되지 않으면 발생한다 .

#(not(some not(for[[a b]%[c d]% :when(= b c)](%[a d]))))

이 입력은 두 요소 벡터의 집합이어야합니다.

(f (set [[1, 2], [2, 4], [6, 5], [1, 4]]))
(f (set [[7, 8], [9, 10], [15, -5]]))
(f (set [[5, 9], [9, 54], [0, 0]]))

입력이 목록과 같아야 (%[a d])하는 ((set %)[a d])경우 추가 6 바이트 로 대체해야 합니다.

이 두 가지 솔루션 모두 순서 쌍의 목록을 입력 및 반환 True또는 로 사용하는 명명되지 않은 함수 False입니다.

Mathematica, 65 바이트

SubsetQ[#,If[#2==#3,{#,#4},Nothing]&@@@Join@@@#~Permutations~{2}]&

#~Permutations~{2}]입력에서 정렬 된 쌍의 모든 정렬 된 쌍의 목록을 작성하고 Join@@@정렬 된 사중으로 변환합니다. 그것들은 If[#2==#3,{#,#4},Nothing]&@@@시원한 속성을 가진 함수에 의해 작동됩니다 : 중간 두 요소가 같으면 첫 번째 숫자와 마지막 숫자로 구성된 순서 쌍을 반환합니다. 그렇지 않으면 Nothing목록에서 자동으로 사라지는 특수 Mathematica 토큰 인을 반환 합니다. 따라서 결과는 전이되기 위해 입력에 있어야하는 순서 쌍의 세트입니다. SubsetQ[#,...]해당 속성을 감지합니다.

Mathematica, 70 바이트

And@@And@@@Table[Last@i!=#&@@j||#~MemberQ~{#&@@i,Last@j},{i,#},{j,#}]&

Table[...,{i,#},{j,#}]iand로 색인화 된 2D 배열을 생성합니다.이 배열 j은 입력에서 직접 가져옵니다 (따라서 둘 다 정렬 된 쌍임). 이 두 지수의 기능은입니다. Last@i!=#&@@j||#~MemberQ~{#&@@i,Last@j}"의 두 번째 요소 i와 첫 번째 요소가 j일치하지 않습니다. 그렇지 않으면 입력에 첫 번째 요소 i와 마지막 요소 로 구성된 순서 쌍이 포함 j됩니다." 이렇게하면 부울의 2D 배열이 만들어져 And@@And@@@단일 부울로 병합됩니다.

APL (NARS), 39 자, 78 바이트

{∼∨/{(=/⍵[2 3])∧∼(⊂⍵[1 4])∊w}¨,⍵∘.,w←⍵}

테스트:

  f←{∼∨/{(=/⍵[2 3])∧∼(⊂⍵[1 4])∊w}¨,⍵∘.,w←⍵}
  f (1 2) (2 4) (6 5) (1 4)
1
  f (7 8) (9 10) (15 ¯5)
1
  f (5 9) (9 54) (0 0)
0

1 초 '솔루션'은 goto ways를 따릅니다.

r←q w;i;j;t;v
r←1⋄i←0⋄k←↑⍴w⋄→3
r←0⋄→0
→0×⍳k<i+←1⋄t←i⊃w⋄j←0
→3×⍳k<j+←1⋄v←j⊃w⋄→4×⍳t[2]≠v[1]⋄→2×⍳∼(⊂t[1]v[2])∊w

공통 리스프, 121 바이트

(lambda(x)(not(loop for(a b)in x thereis(loop for(c d)in x do(if(= b c)(return(not(member`(,a ,d) x :test #'equal))))))))

온라인으로 사용해보십시오!