Takuzu는 0s와 1s를 포함하는 셀로 그리드를 완성해야하는 논리 게임입니다 . 그리드는 3 가지 규칙을 따라야합니다.

1. 3 개의 수평 또는 수직 연속 셀은 동일 할 수 없습니다.
2. 각 행과 열에 동일한 수의 0s와 1s 가 있어야합니다 .
3. 두 행이 같을 수 없으며 두 열이 같을 수도 없습니다.

완성 된 그리드를 살펴 보겠습니다.

0011
1100
0101
1010

당신이 볼 수 있듯이,이 보드는 규칙을 다음 1, 2하고 3. 동일한 3 개의 수평 또는 수직 셀이 없으며 모든 행과 열에 동일한 수의 0s와 1s가 포함되며 두 행과 두 열이 동일하지 않습니다.

유효하지 않은 그리드를 봅시다 :

110100
010011
011010
101100
100011
001101

이 그리드에는 많은 문제가 있습니다. 예를 들어, 행 5에는 행 에 세 개의 0s가 있고 열에 2는 1행에 세 개의 0s가 있고 그 뒤에 세 개가 있습니다. 따라서 이것은 유효한 그리드가 아닙니다.

태스크:

당신의 임무는 n* n 0와 1s 의 2D 배열이 주어진 보드가 유효하고 완성 된 Takuzu 보드인지 확인하기 위해 보드를 검증 하는 프로그램을 만드는 것 입니다.

예 :

0011
1100
0101
1010

이 보드는 모든 규칙을 따르므로 유효한 Takuzu 보드입니다. 이것에 대해 진실한 가치를 돌려 주어야합니다.

11
00

이것은 유효한 보드 행 1이 규칙을 따르지 않습니다 2. 이에 대한 잘못된 값을 반환해야합니다.

100110
101001
010101
100110
011010
011001

이것은 유효한 보드가 아니며 규칙 3으로 인해 실패합니다 (첫 번째와 네 번째 행이 동일합니다).

110100
001011
010011
101100
100110
011001

이것은 유효한 보드가 아니며 규칙 3으로 인해 실패합니다 (첫 번째와 네 번째 열은 동일합니다).

011010
010101
101100
010011
100110
101001

이것은 유효한 보드입니다.

규칙 및 사양 :

• 모든 보드가 치수의 제곱이라고 가정 할 수 있습니다 n * n. 여기서 n양의 정수는 정수입니다.
• 모든 보드가 완성되었다고 가정 할 수 있습니다.
• 넌 나타내는 값을 포함하는 2 차원 배열로 입력 걸릴 수 0및 1또는 문자열.
• 진실과 거짓 보드에 대해 일관된 진실과 거짓 값을 출력해야하며 "truthy"와 "falsey"를 나타내는 값은 같을 수 없습니다.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

Brachylog , 20 18 바이트

≠\≠,?¬{∋s₃=|∋ọtᵐ≠}

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

설명

≠                           All rows are different
 \                          Transpose
  ≠                         All columns are different
   ,?                       Append the list of rows to the list of columns
     ¬{          }          It is impossible that:
       ∋                      A row/column of the matrix…
        s₃=                   …contains a substring of 3 equal elements
           |                Or that:
            ∋ọ                The occurences of 1s and 0s in a row/column…
              tᵐ≠             …are not equal

껍질 , 19 18 바이트

S=‼(Tf§=LṁDum(ṁ↑2g

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

H.PWiz 덕분에 1 바이트가 절약되었습니다!

주요 아이디어는 유효한 보드의 ID 인 입력에 일련의 변환을 적용하고 최종 결과가 원래 입력과 동일한 지 확인하는 것입니다.

설명

S=‼(Tf§=LṁDum(ṁ↑2g
            m(ṁ↑2g    in each line, take at most two items for each sequence of equal items
           u          remove duplicate lines
     f§=LṁD          keep only those lines where the sum of each element doubled is equal to the length of the line
    T                 transpose the matrix (swap rows with columns)
  ‼                   do all the previous operations again
S=                    check if the final result is equal to the original input

젤리 , 17 바이트

-*S;E3Ƥ€F$TȯQZµ⁺⁼

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

마일 과 Jonathan Allan 덕분에 -6 바이트 .

수학, 143 바이트

And@@Flatten@(((s=#;Equal@@(Count[s,#]&/@{0,1})&&FreeQ[Subsequences@s,#]&/@{{1,1,1},{0,0,0}})&/@#)&&(DeleteDuplicates@#==#)&/@{#,Transpose@#})&

입력

[{{0, 0, 1, 1}, {1, 1, 0, 0}, {0, 1, 0, 1}, {1, 0, 1, 0}}]

파이썬 2 , 127 바이트

a=input()
n=len(a)
b=zip(*a)
print[n/2]*n*2==map(sum,a+b)>len(set(a))==len(set(b))==n<'0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`

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

n n 튜플 목록을 입력으로 읽습니다 .

1/(…)대신 코드를 작성하여 종료 코드로 출력 할 수 는 print…있지만 어지럽습니다. 내가해야합니까?

설명

n보드의 크기입니다. b열의 목록입니다 (조옮김 a). 나머지는 하나의 긴 체인 비교입니다.

• [n/2]*n*2==map(sum,a+b) 규칙 2를 확인합니다. 각 행과 열의 합은 n / 2 여야합니다.
• map(sum,a+b)>len(set(a)) 항상 참입니다 (list> int).
• len(set(a))==len(set(b))==n 규칙 3을 확인합니다.
• n<'0, 0, 0' 항상 참입니다 (int <str).

• '0, 0, 0'not in`a+b`>'1, 1, 1'not in`a+b`검사 규칙 1 `a+b`은 모든 행과 열의 문자열 표현입니다. TIO의 입력 예는

  "[(0, 0, 1, 1), (1, 1, 0, 0), (0, 1, 0, 1), (1, 0, 1, 0), (0, 1, 0, 1), (0, 1, 1, 0), (1, 0, 0, 1), (1, 0, 1, 0)]"

  `a+b`>'1, 1, 1'이 문자열로 시작 보장되기 때문에 중앙에 항상 사실 "["보다 큰, "1".

껍질 , 27 25 바이트

Λ§&Λȯ¬VEX3§&Λ§=#0#1S=uSeT

입력리스트의 목록 출력은 1위해 True및 0대한False

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

설명

                      SeT    Create a list with the input and itself transposed
Λ                            Is the following function true for all in the list
 §&                          And the results of the following functions
   Λȯ¬VEX3                     Test for rule 1
          §&                   The and of:
            Λ§=#0#1                Test for rule 2
                   S=u             Test for rule 3

시험 1

Λȯ¬VEX3
Λ         Is it True for all ...
   V      Are any of the ...
     X3   Substrings of length 3 ...
    E     All equal
 ȯ¬       Logical not

시험 2

Λ§=#0#1
Λ         Is it true for all that ...
 §=       The results of the two functions are equal
   #0         Number of 0s
     #1       Number of 1s

시험 3

S=u
S=    Is the result of the following function equal two its argument
  u   Remove duplicates

망막 , 129 89 85 바이트

.+
$&,$&
O#$`.(?=.*,)
$.%`
.+
$&;$&
+`(01|10)(?=.*;)

1ms`(.)\1\1|\d,?;|(\D\d+\b).*\2

온라인으로 사용해보십시오! 유효하면 0을, 유효하지 않으면 1을 출력합니다. 편집 : @MartinEnder 덕분에 4 바이트가 절약되었습니다. 설명:

.+
$&,$&

각 행을 복제 ,구분 기호를 사용 .

O#$`.(?=.*,)
$.%`

첫 번째 사본을 바꿉니다.

.+
$&;$&

이번에도 다시 복제 ; 구분 기호로 .

+`(01|10)(?=.*;)

세미콜론 앞에 오는 일치하는 모든 숫자 쌍을 삭제하십시오.

1ms`(.)\1\1|\d,?;|(\D\d+\b).*\2

열 또는 행이 규칙에 실패하는지 확인하십시오. (.)\1\1행에서 동일한 3 자리 숫자를 \d,?;확인하고 짝을 이루지 않은 숫자를 (\D\d+\b).*\2확인하고 중복을 확인합니다.

Pyth , 31 바이트

@Leaky Nun 에게 감사합니다 .

.Asm++mqy/k\0lQdm<hk3srL8d{Id,C

모든 테스트 사례를 확인 하거나 여기에서 시도하십시오!

피스 ,  48 46 44  42 바이트

이것이 초기 솔루션입니다.

&{IQ&{I.TQ.Am&q/d\0/d\1!+/d*3\0/d*3\1sC,.T

모든 테스트 사례를 확인 하거나 여기에서 시도하십시오!

& {IQ & {I.TQ.Am & q / d \ 0 / d \ 1! + / d * 3 \ 0 / d * 3 \ 1sC, .T 암시 적 입력의 전체 프로그램.

 {IQ 중복 제거시 입력이 변하지 않습니까?
& {I.TQ 그리고 그것의 조옮김도 변하지 않습니까?
                                        .TQ 조옮김.
                                           Q 입력.
                                     sC, 위의 Zip, [^, ^^] (그리고 평평하게).
    & 다음 조건이 충족됩니까?
          .Am ^^에 매핑 할 때 모든 요소가 정직합니다.
              q / d \ 0 / d \ 1 0만큼 1이 있습니다.
             &! + / d * 3 \ 0 / d * 3 \ 1 그리고 3 개의 동일한 요소가 없습니다.

MATL , 27 바이트

,G@?!]tEqts~w7BZ+|3<bXBSdvA

입력 함유하는 행렬 0과 1. 결과는 0허위, 1진실입니다.

온라인으로 사용해보십시오! 또는 테스트 사례를 참조하십시오 : 1 , 2 , 3 , 4 , 5 .

설명

,       % Do twice. First iteration will use the input, second its transpose
  G     %   Push input
  @     %   Push iteration index: first 0, then 1
  ?     %   If nonzero
    !   %     Transpose
  ]     %   End
  t     %   The top of the stack contains the input or its transpose. Duplicate
  Eq    %   Convert to bipolar form, i.e. replace 0 by -1
  t     %   Duplicate
  s     %   Sum of each column
  ~     %   Negate. If all results are true, condition 2 is fulfilled
  w     %   Swap. Moves copy of bipolar input/transposed input to top
  7B    %   Push [1 1 1], obtained as 7 converted to binary
  Z+    %   2D convolution. Gives a matrix of the same size as the input
  |3<   %   Is each entry less than 3 in absolute value? If all results are true,
        %   condition 1 is fulfilled
  b     %   Bubble up. Moves copy of input/transposed input to top
  XB    %   Convert each row from binary to a number
  Sd    %   Sort, consecutive differences. If all results are nonzero, condition 3
        %   is fulfilled
  v     %   Concatenate all results so far into a column vector
  A     %   True if all entries are nonzero
        % End (implicit). Display (implicit)

R , 114 107 바이트

Giuseppe 덕분에 -7 기능을 잘못 호출하고 조건을 실제로 압축

function(x)any(f(x),f(t(x)))
f=function(x)c(apply(x,1,function(y)max(rle(y)$l)>2+mean(y)-.5),duplicated(x))

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

이것은 규칙을 행렬의 열에 적용한 다음 행렬의 조옮김 열에 적용합니다.

다음과 같은 형식으로 입력을받습니다.

matrix(c(0,0,1,1,1,1,0,0,0,1,0,1,1,0,1,0), ncol=4)

R이 2D 배열을 취하는 방식입니다.

실패에 대해서는 TRUE, 패스에 대해서는 FALSE를 출력합니다.

펄 6 ,100 93 바이트

정션 FTW! 7 바이트를 절약합니다.

당분간, 이것은 비 골프 언어로 작성된 다른 모든 제출물을 때리는 것 같습니다. 이피!

{!max (@(.map(*.join)).&{.repeated| |.map:{$_~~/000|111/|.comb(0)-.comb(1)}}for @^a,[Z] @^a)}

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

설명 : 보드를 목록의 목록으로 가져 오는 블록입니다. 우리는 전치사를 만듭니다 [Z] @^a(zip 연산자로 목록 목록을 줄입니다). @^a,[Z] @^a보드 목록과 조옮김도 마찬가지 입니다. 우리는 이것을 for정확히 반복합니다 map.이 경우 1 문자 저렴합니다.

내부에서는 먼저 행을 구성하는 목록을 문자열로 결합하므로 목록 목록 ( @(.map(*.join))) 대신 문자열 목록이 있습니다 . 그런 다음 익명 차단 ( .&{...})을 사용하여 규칙을 실제로 평가합니다. 행 단위로만 평가합니다. (원래 배열과 조옮김에도 적용됩니다.)

꽤 많은 것을 절약하기 위해 !약간의 논리를 사용하고 테스트 대신 (NO repeated rows) AND (NO 3 consecutive same symbols) AND (NOT different counts of 0 and 1)테스트합니다.NOT[ (repeated rows) OR (3 consecutive same symbols) OR (different counts) ] 합니다. 그것이 익명 블록에서 수행하는 작업입니다. .repeated두 번 이상 발생하는 모든 행을 제공 한 다음 행을 매핑하고 정규 표현식을 사용하여 3 개의 연속 기호를 일치시키고 0과 1의 수를 뺍니다. 이것들은으로 OR됩니다 |. (실제로 junction 이라는 매우 강력한 것을 만들지 만 그 힘을 사용하지는 않습니다.)이 모든 후에 2 개의 "bools"(접히지 않은 junction) 목록이 나타납니다. 우리는 마침내 또는 (을 사용하여 max) 부정하고 ( !) 원하는 결과를 얻습니다.

J, _{40 38} 55 바이트

0=[:([:+/^:_(3(0=3|+/)\"1 ]),:-.@~:,:#=[:+/"1+:@])|:,:]

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

정사각 행렬을 입력으로 사용하는 함수를 정의합니다.

적어도 Pyth를 꺾고 있습니다 (현재는 ... ). J는 또한 그 자체에 적합하기 때문에 코드에 숨겨진 이모티콘을 세는 것으로 돌아 가야합니다.

[: /^: :1 |: :] :-.@ :# :@] :~@

설명 (약간 구식)

이것은 내 대답과 다르게 보이며 업데이트 할 수 있습니다. 그것의 일부는 여전히 동일합니다. 방금 전에 규칙 3을 확인하지 않고 규칙 2를 잘못 확인하지 않았습니다.

몇 가지 기능으로 나눠지고 ungolfed :

join_trans  =. |: ,: ]
part_3      =. 3 (0 = 3 | +/)\"1 ]
f           =. 1 - 2 * ]
main        =. 0 = [: ([: +/^:_ part_3 , f) join_trans

join_trans

|: ,: ]
|:       Transpose
   ,:    Laminated to
      ]  Input

이것은 행렬의 전치를 결합하여 행렬의 배열을 만듭니다.

part_3

3 (0 = 3 | +/)\"1 ]
                  ]  Input (matrix and transpose)

3 행의 파티션 합계를 행 단위로 검사하여 3 또는 0인지 확인합니다 (이 둘 중 하나는 유효하지 않은 보드이므로). 매트릭스와 전치 모두에서 작동하기 때문에 작동합니다.

에프

1 - 2 * ]

더 나은 이름이 없으면 이것을 호출합니다 f. 0을 _1로 바꾸고 1을 그대로 둡니다. 이것은 결국 각 행과 열에서 0과 1의 수가 같은지 확인할 수 있도록합니다 (각 행의 합계는 0이어야 함).

본관

0 = [: ([: +/^:_ part_3 , f) join_trans
                             join_trans  Join transpose to input
                 part_3 , f              Apply the validity checks and join them
           +/^:_                         Sum until it converges
0 =                                      Equate to 0

기본적으로, 나는 그래서 그것을 설정 한 사실 활용 f join_trans및 part_3 join_trans이사회가 유효 IFF에 모두 0으로 요약해야한다. part_3유효한 보드의 경우 모두 0이어야하고 유효한 보드의 경우 전체의 f합이 0이어야합니다. 즉, 합계의 합은 유효한 보드의 경우에만 0입니다.

하스켈 , 137 (136) 127 바이트

Lynn 덕분에 9 바이트가 절약되었습니다!

import Data.List
j=isSubsequenceOf
l x=x==nub x&&and[sum y*2==length x&&not(j[0,0,0]y||j[1,1,1]y)|y<-x]
g x=l x&&l(transpose x)

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

자바 (8) 350 326 325 312 303 299 298 259 255 바이트

int r,z,c,p,i,j,k,d,u,v=1;int c(int[][]b){v(b);k=v-=u=1;v(b);return r;}void v(int[][]b){String m="",x;for(d=b.length;j<d|k<d;k+=u,j+=v,r=m.contains(x)|z!=0?1:r,m+=x)for(x="#",c=0,k*=u,j*=v;j<d&k<d;z+=i|i-1,c*=i^p^1,x+=p=i,r=++c>2?1:r,k+=v,j+=u)i=b[k][j];}

0유효한 보드 인 경우 반환 합니다. 1세 가지 규칙 중 하나 이상에 유효하지 않은 경우

@Nevay 덕분에 -95 바이트 .

설명:

여기에서 시도하십시오.

int r,z,c,p,i,j,k,d,u,v=1;
                     // Temp integers on class-level

int c(int[][]b){     // Method (1) with int-matrix parameter and int return-type
  v(b);              //  Validate the rows
  k=v-=u=1;          //  Switch rows with columns, and reset `u` to 1
  v(b);              //  Validate the columns
  return r;          //  Return the result
}                    // End of method (1)

void v(int[][]b){    // Separated method (2) with int-matrix parameter and no return-type
  String m="",s;     //  Two temp Strings to validate uniqueness of rows
  for(d=b.length;    //  Set the dimension of the matrix to `d`
      j<d|k<d        //  Loop (1) as long as either `j` or `k` is smaller than `d`
    ;                //   After every iteration:
     k+=u,j+=v       //    Increase the loop-indexes
     r=m.contains(s) //    If we've found a duplicated row,
     |z!=0?          //    or if the amount of zeroes and ones on this row aren't equal
      1:r,           //     Set `r` to 1 (invalid due to either rule 2 or 3)
     m+=s)           //    Append the current row to the String `m`
    for(s=",",       //   Set String `x` to a separator-character
        c=0,         //   Reset the counter to 0
        k*=u,j*=v,   //   Increase the loop-indexes
        j<d&k<d      //   Inner loop (2) as long as both `j` and `k` are smaller than `d`
     ;               //    After every iteration:
      z+=i|i-1,      //     Increase or decrease `z` depending on whether it's a 0 or 1
      c*=i^p^1,      //     Reset `c` if current digit `i` does not equal previous `p`
      s+=p=i,        //     Set previous `p` to current digit, and append it to String `s`
      r=++c>2?       //     If three of the same adjacent digits are found:
         1:r;        //      Set `r` to 1 (invalid due to rule 1)
        k+=v,j+=u)   //      Increase the loop-indexes
      i=b[k][j];     //    Set `i` to the current item in the matrix
                     //   End of inner loop (2) (implicit / single-line body)
                     //  End of loop (2) (implicit / single-line body)
}                    // End of separated method (2)

파이썬 3, 187 바이트

lambda m,c=lambda m:all([len({*m})==len(m),sum(~-("000"in x)*~-("111"in x)and x.count("1")==x.count("0")for x in m)==len(m)]):c(["".join(x[i]for x in m)for i in range(len(m[0]))])and c(m)

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

행 목록으로 입력을받습니다.

05AB1E , 29 바이트

ø‚D€ÙQIDøì©O·IgQP®εŒ3ù€Ë_P}PP

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

설명

규칙 : 3

ø‚        # pair the input with the zipped input
  D       # duplicate
   €Ù     # deduplicate each
     Q    # check for equality with the unmodified copy

규칙 : 2

IDøì          # prepend zipped input to input
    ©         # store a copy in register for rule 1
     O        # sum each row/column
      ·       # double
       IgQ    # check each for equality to length of input
          P   # product

규칙 : 1

®ε            # apply to each row/column in register
  Œ3ù         # get sublists of length 3
     €Ë       # check each if all elements are equal
       _      # logical not
        P     # product
         }    # end apply
          P   # product

그런 다음 세 가지 규칙의 결과를 곱하여 P

Dyalog APL, 64 52 51 49 48 바이트

필요 ⎕IO←0

{⍲/{(∨/∊⍷∘⍵¨3/¨⍳2)∧((⊢≡∪)↓⍵)∧∧/(≢=2×+/)⍵}¨⍵(⍉⍵)}

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

PHP, 245 + 1 바이트

이 부피가 크다. 줄 바꿈은 읽기 편의만을위한 것입니다.

$t=_;foreach($a=($i=str_split)($s=$argn)as$i=>$c)$t[$i/($e=strlen($s)**.5)+$i%$e*$e]=$c;
for(;$k++<2;$s=$t)$x|=preg_match("#000|111|(\d{"."$e}).*\\1#s",chunk_split($s,$e))
|($m=array_map)(array_sum,$m($i,$i($s,$e)))!=array_fill(0,$e,$e/2);echo!$x;

줄 바꿈없이 단일 문자열을 가져 와서 인쇄 1 을 취하고, 진실을 위해 하고, 거짓을 위해 아무것도 하지 않습니다.

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .