소개

최소 바이트를 사용하여 Hitori 퍼즐 의 솔버를 작성하십시오 .

도전

당신의 작업은 히토리 (일본어로 "독자"라는 단어; 게임 이름의 의미는 "나 혼자 남겨주세요")의 논리 퍼즐에 대한 솔버를 작성하는 것입니다. 규칙은 다음과 같습니다.

• nxn 셀 격자가 표시되며 각 셀은 1과 n 사이의 정수를 포함합니다 (포함).
• 목표는 다음 두 규칙에 표시된 제한에 따라 주어진 그리드에서 숫자를 제거하여 그리드의 각 행과 각 열에 숫자가 두 번 이상 나타나지 않도록하는 것입니다.
• 인접한 두 개의 (수평 또는 수직) 셀에서 두 개의 숫자를 제거 할 수 없습니다.
• 나머지 번호가 매겨진 셀은 모두 서로 연결되어 있어야합니다. 즉, 남아있는 두 개의 번호가 매겨진 셀은 인접한 나머지 숫자 (가로 또는 세로)를 연결하는 세그먼트로만 구성된 곡선으로 연결할 수 있습니다. (이것이 누락되었음을 지적 해 주신 @ user202729에게 감사합니다)

나는 지금까지 규칙이 명확 해지기를 바랍니다. 규칙이 명확하지 않은 경우 Wikipedia 페이지를 확인 하십시오 .

테스트 사례

숫자가 제거 된 셀은 0으로 표시됩니다.

Input  ->  Output

4
2 2 2 4      0 2 0 4
1 4 2 3  ->  1 4 2 3
2 3 2 1      2 3 0 1
3 4 1 2      3 0 1 2

4
4 2 4 3      0 2 4 3
4 1 1 2  ->  4 1 0 2
3 1 2 1      3 0 2 1
4 3 1 3      0 3 1 0

5
1 5 3 1 2      1 5 3 0 2
5 4 1 3 4      5 0 1 3 4
3 4 3 1 5  ->  3 4 0 1 5
4 4 2 3 3      4 0 2 0 3
2 1 5 4 4      2 1 5 4 0

8
4 8 1 6 3 2 5 7      0 8 0 6 3 2 0 7
3 6 7 2 1 6 5 4      3 6 7 2 1 0 5 4
2 3 4 8 2 8 6 1      0 3 4 0 2 8 6 1
4 1 6 5 7 7 3 5  ->  4 1 0 5 7 0 3 0
7 2 3 1 8 5 1 2      7 0 3 0 8 5 1 2
3 5 6 7 3 1 8 4      0 5 6 7 0 1 8 0
6 4 2 3 5 4 7 8      6 0 2 3 5 4 7 8
8 7 1 4 2 3 5 6      8 7 1 4 0 3 0 6

9
8 6 5 6 8 1 2 2 9      8 0 5 6 0 1 2 0 9
5 6 2 4 1 7 9 8 3      5 6 2 4 1 7 9 8 3
5 8 2 5 9 9 8 2 6      0 8 0 5 0 9 0 2 0
9 5 6 6 4 3 8 4 1      9 5 6 0 4 3 8 0 1
1 1 6 3 9 9 5 6 2  ->  0 1 0 3 9 0 5 6 2
1 1 4 7 3 8 3 8 6      1 0 4 7 0 8 3 0 6
3 7 4 1 2 6 4 5 5      3 7 0 1 2 6 4 5 0
3 3 1 9 8 7 7 4 5      0 3 1 9 8 0 7 4 5
2 9 7 5 3 5 9 1 3      2 9 7 0 3 5 0 1 0 

이 테스트 사례는 각각 Concept Is Puzzles , PuzzleBooks , Concept Is Puzzles , Wikipedia 및 Youtube 에서 가져옵니다 .

명세서

• 예외 처리에 대해 걱정할 필요가 없습니다.

• 당신은 할 수 입력이 항상있는 유효한 퍼즐이라고 가정 고유의 솔루션 당신은 당신의 코드를 작성하는이 활용할 수 있습니다.

• 이것은 가장 적은 바이트 수의이기는 code-golf 입니다.

• 4 <= n <= 9 (16은 원래 Stewie Griffin의 제안에 따라 9로 변경되었으며 IO의 일부 문제도 저장함)

• 표준 형식을 통해 입력 및 출력을 제공 할 수 있으며 형식을 자유롭게 선택할 수 있습니다.

• 출력 형식에 대한 몇 가지 제안은 다음과 같습니다 (그러나 이에 국한되지는 않음).

  • 최종 그리드 출력
  • 제거 된 모든 숫자를 포함하는 그리드 출력
  • 위 중 하나의 좌표 목록을 출력합니다.

• 평소와 같이 기본 허점 이 여기에 적용됩니다.

_{관련 (이 도전에서 영감을 얻은) : 매트릭스의 모든 요소가 연결되어 있는지 확인하십시오 .}

_{나의 마지막 도전 : Sevens of Game of Sevens}

하스켈 , 374 바이트

import Data.Array;import Data.List;r=range;p=partition
c(e,f)=p(\(b,p)->any(==1)[(b-d)^2+(p-q)^2|(d,q)<-e])f
n#g=[s|(o,(e:f))<-[p((==0).(g!))$indices g],
 null.fst$c(o,o),null.snd$until(null.fst)c([e],f),
 s<-case[((l,c),d)|((l,c),h)<-assocs g,h>0,
 d<-[filter((==h).(g!))$r((l,c+1),(l,n))++r((l+1,c),(n,c))],d/=[]]
 of[]->[g];((c,d):_)->n#(g//[(c,0)])++n#(g//[(c,0)|c<-d])]

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

APL (Dyalog Unicode) , 133 바이트 ^SBCS

{q←{⊢/4 2⍴⍵}⌺3 3⋄g←⍵=⊂∪,⍵⋄⍵×~1⊃{((⌈/q b)⌈b<{2<≢∪0,,(⍵×⊢⌈⌈/∘q)⍣≡⍵×(⍴⍵)⍴1+⍳≢,⍵}¨~b∘⌈¨⊂⍤2∘.≡⍨⍳⍴b)(+/↑w<g×⌈.⌈⍨w×g)⌈w b←⍵}⍣≡×\(⌈/=∘⌽⍨q⍵)0}

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

규칙 # 4 (셀이 하나의 연결된 구성 요소를 구성해야 함)를 구현하는 것은 다소 낭비이지만 여전히 TIO에서 약 10 초 안에 모든 테스트를 통과합니다.

전체 알고리즘 : 상점이 부울 행렬 b과 w각각 검은 색과 흰색이 될 것이 거의 확실한 세포. b모두 0으로 초기화하십시오 . w일치하는 이웃이있는 셀에 대해서만 1로 초기화하십시오 .

까지 반복 b하고 w정착 :

• 추가로 b같은 행에있는 셀 (가로 또는 세로) 및 셀과 동일한 값w

• w모든 세포의 인접 이웃에 추가b

• w모든 컷 포인트에 추가 -제거하면 검은 색이 아닌 셀의 그래프가 여러 개의 연결된 구성 요소로 분할됩니다.

마지막으로 출력 not(b)에 원래 행렬을 곱한 값입니다.

젤리 , 62 바이트

다른 질문에서 user202729의 isConnected monadic 링크 를 사용합니다 .

FJṁa@µ«Ḋoµ€ZUµ4¡ÐLFQL<3
ḟ0ĠḊ€
¬T€œ&2\;Ç€FȦ
ZÇȯÇ_1Ŀ
2ḶṗLṗLa⁸ÇÞḢ

목록 목록의 표현을 인쇄하는 전체 프로그램.
무차별 적으로 작동하며 어리석게 비효율적입니다.

온라인으로 사용해보십시오! -60 초 TIO 한도 내에서 크기 4까지 실행하기에는 너무 비효율적이기 때문에 3 x 3입니다!

방법?

FJṁa@µ«Ḋoµ€ZUµ4¡ÐLFQL<3 - Link 1 isConnected? List of lists
...                     - 1 if connected 0 if not -- see linked answer in the header

ḟ0ĠḊ€ - Link 2, helperFor-AnyRepeatedValues: list
ḟ0    - filter out zeros
  Ġ   - group indices by value (i.e. [[indices of min],...,[indices of max]]
   Ḋ€ - dequeue €ach -- leaving a list of empty lists iff no repeated values
      -                 any remaining values are non-zero (1-based indexing in Jelly)

¬T€œ&2\;Ç€FȦ - Link 3, columnwiseAnyAdjacentZerosOrRowwiseAnyRepeatedValues: list of lists
¬            - logical not (convert all zeros to ones and all others to zeros)
 T€          - for €ach row get a list of truthy indexes (i.e. indexes of original zeros)
     2\      - pairwise reduction (i.e. for neighbouring rows) with:
   œ&        -   intersection (empty if no columnwise adjacent original zeros
             -                 any remaining values are non-zero due to 1-based indexing)
        Ç€   - call last link (1) as a monad for €ach row
       ;     - concatenate
          F  - flatten into a single list (empty iff no columnwise adjacent original zeros
             -                                   AND no rowwise repeated values)
           Ȧ - any and all (0 if empty [or contains any zero -- never] else 1)

ZÇȯÇ_1Ŀ - Link 4, validity check? list of lists
Z       - transpose
 Ç      - call last link (2) as a monad rowwiseAnyAdjacentZerosOrColumnwiseAnyRepeatedValues?
   Ç    - call last link (2) as a monad columnwiseAnyAdjacentZerosOrRowwiseAnyRepeatedValues?
  ȯ     - logical OR
     1Ŀ - call link 1 as a monad (isConnected?)
    _   - subtract
        - this yields -1 for valid, while it yields 0 or 1 if not.

2ḶṗLṗLa⁸ÇÞḢ - Main link: list of lists
2Ḷ          - lowered range of 2 -> [0,1]
   L        - length (number of rows in the input)
  ṗ         - Cartesian power (all lists of zeros and ones of length L)
     L      - length (number of rows in the input again)
    ṗ       - Cartesian power (all grids of zeros and ones of same shape as the input)
       ⁸    - the input
      a     - logical AND -- effectively uses each of the formed grids as a mask
         Þ  - sort by:
        Ç   -   last link (3) as a monad
          Ḣ - head
            - implicit print