다음과 같은 수의 열과 행으로 2 차원 배열을 취하는 함수 (가능한 한 적은 바이트 사용)를 작성하십시오.

• 0 빈 블록을 나타내고
• 1 뱀 블록을 나타냅니다.

이 함수는 뱀이 이동 한 가능한 경로 수를 반환해야합니다.

예 1 :

입력:

[
  [1,1,1,1,1],
  [0,0,0,0,1],
  [0,0,0,0,1],
]

산출: 2

위의 예 2에서 답은 다음 중 하나이므로 함수가 반환됩니다 .

예 2 :

입력:

[
  [1,1,1,1],
  [0,0,1,1],
  [0,0,1,1],
]

산출: 6

이 예에서 6답은 다음 중 하나이므로 함수가 반환됩니다 .

노트 :

입력을 평가할 때 다음을 가정 할 수 있습니다.

• 열을 나타내는 배열의 크기는 항상 동일하므로 배열은 사각형입니다.
• 하나 이상의 유효한 경로가 있습니다.
• 뱀은 가장자리를 통과 할 수 없습니다 (일부 버전의 뱀에서 발생할 수 있음).
• 뱀은 항상 최소 2 개의 블록을 가질 것입니다.
• 뱀은 대각선으로 움직일 수 없습니다.
• 경로가 지시됩니다. (따라서 다른 위치에서 끝나는 두 경로가 동일하게 보이지 않으면 동일한 경로가 아니므로 총계에 합산됩니다)

Wolfram Language (Mathematica) , 16 + 83 = 99 바이트

라이브러리 가져 오기 문 (16 바이트) :

<<Combinatorica`

실제 함수 본문 (83 바이트) :

Length@HamiltonianCycle[MakeGraph[#~Position~1~Join~{1>0},##||Norm[#-#2]==1&],All]&

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

질문은 그래프에서 해밀턴 경로의 수를 묻는 것입니다.

그러나 (어떤 이유로 든) HamiltonianPath함수는 실제로 유 방향 그래프 ( example ) 와 함께 작동하지 않습니다 . 따라서이 Mathematica.SE 질문에 설명 된 해결 방법을 사용했습니다 .

• True다른 모든 꼭짓점에 연결된 꼭짓점 ( )을 추가하십시오 .
• 결과 그래프에서 해밀턴 사이클 수를 계산합니다.

그래프는 MakeGraph부울 함수를 사용하여 (성가 적으로 직접 내장되어 있지 않음)를 사용하여 구성됩니다.이 함수 는 인수 중 하나가 있거나 두 정점 사이의 거리 가 인 경우에만 ##||Norm[#-#2]==1&반환 True합니다 .True1

Tr[1^x]대신 사용할 수 없습니다 Length@x, 그리고 <2대신 사용할 수 없습니다 ==1.

HamiltonianPath함수 본문이 84 바이트 (현재 제출보다 1 바이트 더 큼) 와 함께 그래프가 방향이 지정되지 않은 경우 사용할 수 있습니다 .

Length@HamiltonianPath[MakeGraph[#~Position~1,Norm[#-#2]==1&,Type->Undirected],All]&

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

자바 스크립트 (ES6) 154 134 바이트

m=>m.map((r,Y)=>r.map(g=(_,x,y,r=m[y=1/y?y:Y])=>r&&r[x]&&[-1,0,1,2].map(d=>r[r[x]=0,/1/.test(m)?g(_,x+d%2,y+~-d%2):++n,x]=1)),n=0)|n/4

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

어떻게?

방법

가능한 각 셀에서 시작하여 행렬을 플러딩하여 도중에 모든 셀을 지 웁니다. 행렬에 1 이 더 이상 포함되지 않을 때마다 가능한 경로 수 n 을 증가시킵니다 .

마지막 셀에서 선택한 방향으로 인해 각 유효한 경로는 4 번 계산되며 실제로는 중요하지 않습니다. 따라서 최종 결과는 n / 4 입니다.

재귀 함수

다음 과 같이 두 번째 map () 의 콜백에서 재귀 함수 g () 를 호출하는 대신 ...

m=>m.map((r,y)=>r.map((_,x)=>(g=(x,y,r=m[y])=>...g(x+dx,y+dy)...)(x,y)))

... 재귀 함수 g () 를 map () 의 콜백 으로 직접 정의합니다 .

m=>m.map((r,Y)=>r.map(g=(_,x,y,r=m[y=1/y?y:Y])=>...g(_,x+dx,y+dy)...))

y=1/y?y:Y초기 값 y 를 설정하는 데 필요한 다소 긴 공식에도 불구하고 전체적으로 2 바이트를 절약합니다.

주석이 달린 코드

m =>                           // given the input matrix m[][]
  m.map((r, Y) =>              // for each row r[] at position Y in m[][]:
    r.map(g = (                //   for each entry in r[], use g() taking:
      _,                       //     - the value of the cell (ignored)
      x,                       //     - the x coord. of this cell
      y,                       //     - either the y coord. or an array (1st iteration),
                               //       in which case we'll set y to Y instead
      r = m[y = 1 / y ? y : Y] //     - r = the row we're currently located in
    ) =>                       //       (and update y if necessary)
      r && r[x] &&             //     do nothing if this cell doesn't exist or is 0
      [-1, 0, 1, 2].map(d =>   //     otherwise, for each direction d,
        r[                     //     with -1 = West, 0 = North, 1 = East, 2 = South:
          r[x] = 0,            //       clear the current cell
          /1/.test(m) ?        //       if the matrix still contains at least one '1':
            g(                 //         do a recursive call to g() with:
              _,               //           a dummy first parameter (ignored)
              x + d % 2,       //           the new value of x
              y + ~-d % 2      //           the new value of y
            )                  //         end of recursive call
          :                    //       else (we've found a valid path):
            ++n,               //         increment n
          x                    //       \_ either way,
        ] = 1                  //       /  do r[x] = 1 to restore the current cell to 1
      )                        //     end of map() over directions
    ),                         //   end of map() over the cells of the current row
    n = 0                      //   start with n = 0
  ) | n / 4                    // end of map() over the rows; return n / 4

젤리 , 12 11 바이트

ŒṪŒ!ạƝ€§ÐṂL

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

설명.

ŒṪ               Positions of snake blocks.
  Œ!             All permutations.
                 For each permutation:
    ạƝ€             Calculate the absolute difference for each neighbor pair
       §            Vectorized sum.
                 Now we have a list of Manhattan distance between snake
                    blocks. Each one is at least 1.
        ÐṂL      Count the number of minimum values.
                    Because it's guaranteed that there exists a valid snake,
                    the minimum value is [1,1,1,...,1].

파이썬 (2) , 257 (246) 241 234 233 227 214 210 바이트

lambda b:sum(g(b,i,j)for j,l in e(b)for i,_ in e(l))
e=enumerate
def g(b,x,y):d=len(b[0])>x>-1<y<len(b);c=eval(`b`);c[d*y][d*x]=0;return d and b[y][x]and('1'not in`c`or sum(g(c,x+a,y)+g(c,x,y+a)for a in(1,-1)))

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

저장되었습니다

• Kevin Cruijssen 덕분에 -8 바이트
• user202729 덕분에 -14 바이트

파이썬 2, 158 바이트

E=enumerate
g=lambda P,x,y:sum(g(P-{o},*o)for o in P if x<0 or abs(x-o[0])+abs(y-o[1])<2)+0**len(P)
lambda L:g({(x,y)for y,r in E(L)for x,e in E(r)if e},-1,0)

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

하스켈 , 187155 바이트

r=filter
l=length
(a,b)?(x,y)=abs(a-x)+abs(b-y)==1
l#x=sum[p!r(/=p)l|p<-x]
p![]=1
p!l=l#r(p?)l
f x|l<-[(i,j)|i<-[0..l x-1],j<-[0..l(x!!0)-1],x!!i!!j>0]=l#l

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