소개

퍼즐의 규칙 :

이진 ( Takuzu 또는 Subiku 라고도 함) 퍼즐 은 이해하기 매우 간단하며 몇 가지 규칙 만 있습니다.
게임 이름은 이진이므로 매우 분명하지만 0과 1 만 채울 수 있습니다.

1. 동일한 숫자 중 두 개 이하 만 서로 수직 또는 수평으로 인접 할 수 있습니다
2. 각 행과 각 열은 동일한 양의 0과 1을 포함해야합니다 (이는 암시 적으로 모든 이진 게임의 크기가 항상 동일 함을 의미합니다).
3. 중복 된 행과 중복 된 열이 없을 수 있습니다 (0과 1의 순서는 동일 함).

원한다면 www.binarypuzzle.com 에서 게임을 즐길 수 있습니다 .

전술:

규칙 1로 인해
다음과 같은 경우 항상 숫자를 채울 수 있습니다 .-같은 숫자 중 두 개가 서로 수직 또는 수평으로 인접 해 있습니다.이 경우 양쪽의 반대 자리를 채울 수 있습니다. 즉 .11...→ 0110...
-세로 또는 가로로 같은 숫자 중 두 개 사이에 간격이 하나만 있습니다. 즉 .1.1..→.101..

규칙 1로 인해 세 개의 공백이 남아 있고 동일한 숫자에 인접한 세 개의 숫자를 가질 수없는 경우 공백 중 하나를 채울 수 있습니다. 즉 .0.1.0→ 10.1.0(여전히 두 개를 채워야하며 중간에 세 개를 인접 할 수 없으므로 첫 번째 간격은이어야합니다 1.)

규칙 2로 인해 나머지 절반이 이미 반대 자리로 채워져 있으면 행이나 열의 나머지 간격을 항상 채울 수 있습니다. 즉 .1.011→010011

규칙 3으로 인해 똑같이 정렬 된 줄에 해결하기 위해 두 개만 남겨두면 항상 반대 자리를 채울 수 있습니다. 즉 101100 & 1..100→101100 & 110100

규칙 3으로 인해 3 개의 간격이 동일하게 정렬 된 선에 남아있을 때 간극을 채울 수 있습니다. 즉 010011 & .1.01.→ 010011 & .1.010(여기서 1끝에 a 를 채울 수 없습니다 . 다른 두 간격에서 0을 채워 두 줄을 순서대로 동일하게 만들어야하기 때문입니다.)

예:

우리는 다음과 같은 6x6 그리드로 시작합니다 .1과 0이 채워져 있습니다 (그리고 점은 아직 채우지 않은 간격입니다).

.1....
.10.0.
1.11..
.1....
...1.0
......

규칙 1과 2로 인해 다음 숫자를 채울 수 있습니다.

.1.01.
.1010.
101100
010011
.0.1.0
.010..

규칙 1로 인해 5 행 1 열에 1을 채울 수 있습니다.

.1.01.
.1010.
101100
010011
10.1.0
.010..

규칙 3으로 인해 행 1, 열 6에서 4를 볼 때 0을 채울 수 있습니다.

.1.010
.1010.
101100
010011
10.1.0
.010..

이제 규칙 1과 2로 인해 숫자로 공백을 계속 채울 수 있습니다.

.1.010
010101
101100
010011
10.1.0
.010.1

이제 규칙 3 (행 3을 볼 때)으로 인해 행 5를 완료 할 수 있습니다.

.1.010
010101
101100
010011
100110
.010.1

그리고 규칙 1과 2로 인해 퍼즐을 완성 할 수 있습니다.

011010
010101
101100
010011
100110
101001

도전:

도전은 간단합니다 : 시작 그리드가 주어지면 해결 된 퍼즐을 출력합니다.

참고 : 위의 규칙을 구현할 필요는 없습니다. 물론이 과제를 구현하는 방법에 대한 힌트를 제공 할 수 있지만 규칙을 염두에두고 솔루션을 무차별 처리하는 것은 완전히 좋습니다.
그것을 해결하는 방법은 당신에게 달려 있지만 문제는 해결 된 퍼즐을 출력하는 것입니다.

도전 규칙 :

• 그리드의 입력 및 출력 형식은 유연하지만 사용하는 내용을 적어주십시오. (즉, 2D 바이트 배열; 줄 바꿈이있는 문자열 등)
• 위의 내용은 사용 된 문자에도 적용됩니다. 이 예에서는을 사용 01.했지만 원하는 경우 ABx대신 사용할 수 있습니다 . 사용한 입력 / 출력 형식과 문자를 알려주십시오.
• 다음 격자 크기 만 사용한다고 가정 할 수 있습니다. 6x6; 8x8; 10x10; 12x12; 14x14; 16x16.

일반 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수가있는 기능 / 방법, 전체 프로그램을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

테스트 사례 :

점은 가독성을 위해 추가 된 것이므로 공백이나 원하는 간격을 자유롭게 사용하십시오. 입력 및 출력 형식 모두 유연합니다.

Input:
1..0..
..00.1
.00..1
......
00.1..
.1..00

Output:
101010
010011
100101
011010
001101
110100

Input:
.1....
.10.0.
1.11..
.1....
...1.0
......

Output:
011010
010101
101100
010011
100110
101001

Input:
.......1..
.00..0..1.
.0..1..0.0
..1...1...
1.1......1
.......1..
.0..1...0.
....11...0
.0.0..1..0
0...0...1.

Output:
0110010101
1001100110
1001101010
0110011001
1010100101
0101010110
1001101001
0110110100
1010011010
0101001011

Brachylog , 34 바이트

{ℕ<2}ᵐ²&≜{d?ọᵐctᵐ=&{ḅlᵐ⌉<3}ᵐ}&\↰₂&

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

이것은 매우 느리기 때문에 TIO의 테스트 사례는 4x4입니다. 현재 컴퓨터에서 6x6 테스트 사례를 실행하여 시간이 얼마나 걸리는지 확인하고 있습니다.

목록의 목록을 입력으로 사용합니다. 알 수없는 값은 변수, 즉 모두 대문자 문자열로 표시해야합니다 (그렇지 않으면 일부 셀은 동일한 값을 가져야 함을 나타내므로 모두 달라야 함)

설명

우리는 값을 in로 제한 {0,1}한 다음 세 가지 규칙을 모두 준수 할 때까지 변수의 인스턴스화를 시도합니다. 이것이 느린 이유입니다 (하나를 찾을 때까지 모든 것을 시도하기 때문에; Brachylog가 충분히 구현되지 않았기 때문에 가능한 매트릭스를 시도하기 전에 제약 조건이 적용될 수 있기 때문입니다).

                                 &  Output = Input
{   }ᵐ²                             Map two levels on the Input (i.e. each cell):
 ℕ<2                                  The cell is either 0 or 1
       &≜                           Assign values to all cells
         {                  }       Define predicate 2:
          d?                          The Input with no duplicates is still the Input
                                        (i.e. all rows are different)
           ?ọᵐctᵐ=                    All occurences of 1s and 0s for each rows are equal
                  &{      }ᵐ          Map on rows:
                    ḅlᵐ                 Get the lengths of runs of equal values
                       ⌉<3              The largest one is strictly less than 3
                             &\↰₂   Apply predicate 2 on the transpose of the Input
                                      (i.e. do the same checks but on columns)

자바 스크립트 (ES6), (274) 270 바이트

빈 셀이로 표시된 2D 배열로 입력을 2받습니다. 가능한 모든 솔루션을 콘솔에 인쇄합니다.

f=(a,x=0,y=0,w=a.length,p,R=a[y])=>(M=z=>!a.some((r,y)=>/(0|1),\1,\1/.exec(s=r.map((v,x)=>(v=z?v:a[x][y],b-=v&1,c-=!v,m|=v&2,v),b=c=w/2))||b*c<0|o[b*c||s]&(o[s]=1),o={}))(m=0)&M(1)&&(m?R&&[0,1].map(n=>(p=R[x])==n|p>1&&(R[x]=n,f(a,z=(x+1)%w,y+!z),R[x]=p)):console.log(a))

작동 원리

코드의 첫 번째 부분은이 M()기능을 사용 하여 현재 보드의 유효성을 가로 및 세로로 확인합니다.

M = z =>
  !a.some((r, y) =>
    /(0|1),\1,\1/.exec(
      s = r.map((v, x) =>
        (
          v = z ? v : a[x][y],
          b -= v & 1,
          c -= !v,
          m |= v & 2,
          v
        ),
        b = c = w / 2
      )
    ) ||
    b * c < 0 |
    o[b * c || s] &
    (o[s] = 1),
    o = {}
  )

전체 행 또는 열을 문자열 s에 매핑합니다 . 이것은 실제로 문자열로 강제 배열 된 배열이므로 다음과 같습니다 "1,2,2,0,2,2".

다음을 사용합니다.

• /(0|1),\1,\1/3 개 이상의 연속 된 동일한 숫자를 감지 하는 정규식 입니다.
• 카운터 b 와 c 는 1 과 0 의 수를 추적합니다 . 두 카운터 모두 w / 2 로 초기화되고 1 또는 0이 (각각) 발생할 때 마다 감소합니다 . 이것은 다음 중 하나로 이어집니다.
  • B = C = O → B * C = O → 광고가 (많은 완전하고 정확한 제로 같은 것들 )
  • B> 0와 C> 0 → B * C> 0 → 라인이 완료하지만, 지금까지 정확하지 않습니다 (우리가없는 이상 / 2w 제로 또는 이상 / 2w 사람 )
  • b <0 OR c <0 → b * c <0 → 라인이 유효하지 않습니다
• 보드에 적어도 두 개가 남아 있으면 0이 아닌 플래그 m ( 'missing') .
• 객체 o를 지금까지 발생한 모든 라인 패턴을 추적합니다.

보드가 유효하지 않으면 즉시 중지합니다. 보드가 유효하고 완성 된 경우 콘솔에 인쇄합니다. 그렇지 않으면 코드의 두 번째 부분에서 각 2 를 0 또는 재귀 호출이 있는 1 로 바꾸려고 시도 합니다.

[0, 1].map(n =>
  (p = a[y][x]) == n |
  p > 1 && (
    a[y][x] = n,
    f(a, z = (x + 1) % w, y + !z),
    a[y][x] = p
  )
)

데모

f=(a,x=0,y=0,w=a.length,p,R=a[y])=>(M=z=>!a.some((r,y)=>/(0|1),\1,\1/.exec(s=r.map((v,x)=>(v=z?v:a[x][y],b-=v&1,c-=!v,m|=v&2,v),b=c=w/2))||b*c<0|o[b*c||s]&(o[s]=1),o={}))(m=0)&M(1)&&(m?R&&[0,1].map(n=>(p=R[x])==n|p>1&&(R[x]=n,f(a,z=(x+1)%w,y+!z),R[x]=p)):console.log(a))

console.log('Example #1')
f([
  [1,2,2,0,2,2],
  [2,2,0,0,2,1],
  [2,0,0,2,2,1],
  [2,2,2,2,2,2],
  [0,0,2,1,2,2],
  [2,1,2,2,0,0]
])

console.log('Example #2')
f([
  [2,2,2,2,2,2,2,1,2,2],
  [2,0,0,2,2,0,2,2,1,2],
  [2,0,2,2,1,2,2,0,2,0],
  [2,2,1,2,2,2,1,2,2,2],
  [1,2,1,2,2,2,2,2,2,1],
  [2,2,2,2,2,2,2,1,2,2],
  [2,0,2,2,1,2,2,2,0,2],
  [2,2,2,2,1,1,2,2,2,0],
  [2,0,2,0,2,2,1,2,2,0],
  [0,2,2,2,0,2,2,2,1,2]
])

젤리 , 53 51 바이트

ṡ€3ḄFf0,7L
SḤnLṀȯÇ
⁻QȯÇ
Fṣ©2L’0,1ṗż@€®F€s€LÇÐḟZÇ$Ðḟ

함유 계통을 나타내는리스트의리스트 취하고 0, 1및 2(공간)를. 목록 목록의 목록을 리턴합니다. 각 목록 목록은 형식이 같지만 ( 2s 는 없지만 ) 입력에 대한 가능한 솔루션을 나타냅니다.

온라인으로 사용해보십시오! (이것은 메모리 제한으로 인해 질문의 테스트 사례를 실행하지 않습니다 ^.2 개의 ^nSpaces 그리드 모두 정수 목록 목록으로 작성되지만 단일 솔루션으로 비교적 ^무겁 습니다.) 바닥 글은 그리드를 분리하고 서식을 지정합니다.

순수 무차별 대입법-규칙을 구현하고 2s 중 하나 를 1s 또는 0s 로 바꾸어 형성 할 수있는 각 그리드에 대해 규칙을 확인합니다 .

ṡ€3ḄFf0,7L - Link 1, # of runs of 3 1s or 3 0s by row: list of lists
ṡ€3        - all contiguous slices of length 3 for €ach list
   Ḅ       - convert all results from binary
    F      - flatten into one list
     f     - filter keep values in:
      0,7  -   0 paired with 7: [0,7]
         L - length

SḤnLṀȯÇ - Link 2, unequal counts of 1s and 0s by column ...or link 1: list of lists
S       - sum (vectorises, hence "by column", counts 1s since only 1s or 0s appear)
 Ḥ      - double
   L    - length (number of rows - OK since square)
  n     - not equal? (vectorises)
    Ṁ   - maximum (1 if any not equal)
     ȯÇ - ... or last link (1) as a monad

⁻QȯÇ - Link 3, rows are unique ...or link 2: list of lists
 Q   - unique
⁻    - not equal?
  ȯÇ - ... or last link (2) as a monad

Fṣ©2L’0,1ṗż@€®F€s€LÇÐḟZÇ$Ðḟ - Main link: list of lists
F                           - flatten
 ṣ©2                        - split at 2s and copy the result to the register
    L                       - length (# of such slices)
     ’                      - decrement (# of 2s)
      0,1                   - 0 paired with 1
         ṗ                  - Cartesian power (all binary lists of length # of 2s)
             ®              - recall value from register (the flat version split at 2s)
          ż@€               - zip (reversed @rguments) for €ach (1s & 0s where 2s were)
              F€            - flatten €ach
                s€L         - split €ach into chunks of length length(input) (into rows)
                    Ðḟ      - filter discard if:
                   Ç        -   call last link(3) as a monad
                         Ðḟ - filter discard if:
                        $   -   last two links as a monad:
                      Z     -     transpose
                       Ç    -     call last link(3) as a monad