16 개의 치즈 더미가 4x4 정사각형에 놓입니다. $1$ 에서 $16$ 까지 레이블이 붙어 있습니다 . 가장 작은 파일은 $1$ 이고 가장 큰 파일 은 $16$ 입니다.

배고픈 마우스는 항상 가장 큰 더미 (즉, 바로가는 너무 배고프 $16$ )과 바로 먹는다.

그 후, 그것은 가장 큰 이웃 더미로 가서 빨리 그 더미를 먹습니다. (예 .. 정말 배가 고파요.) 그리고 더 이상 이웃 더미가 없어 질 때까지.

파일은 최대 8 개의 이웃 (가로, 세로 및 대각선)을 가질 수 있습니다. 랩 어라운드가 없습니다.

예

우리는 다음과 같은 치즈 더미로 시작합니다.

배고픈 마우스는 먼저 $16$ 먹은 다음 가장 큰 이웃 더미 인 $11$ 먹습니다 .

다음 동작은이 순서대로 $13$ , $12$ , $10$ , $8$ , $15$ , $14$ , $9$ , $6$ , $7$ 및 $3$ 입니다.

배고픈 마우스 주변에는 더 이상 치즈가 없으므로 거기서 멈 춥니 다.

도전

초기 치즈 구성을 고려할 때, 배고픈 마우스가 먹기를 멈 추면 코드에서 남은 말뚝의 합계를 인쇄하거나 반환해야합니다.

위의 예에서 예상 답변은 $12$ 입니다.

규칙

• 입력 행렬의 크기는 고정되어 있으므로 2D 배열 또는 1 차원 배열로 사용할 수 있습니다.
• $1$ 에서 $16$ 까지의 각 값은 정확히 한 번만 표시됩니다.
• 이것은 code-golf 입니다.

테스트 사례

[ [ 4,  3,  2,  1], [ 5,  6,  7,  8], [12, 11, 10,  9], [13, 14, 15, 16] ] --> 0
[ [ 8,  1,  9, 14], [11,  6,  5, 16], [13, 15,  2,  7], [10,  3, 12,  4] ] --> 0
[ [ 1,  2,  3,  4], [ 5,  6,  7,  8], [ 9, 10, 11, 12], [13, 14, 15, 16] ] --> 1
[ [10, 15, 14, 11], [ 9,  3,  1,  7], [13,  5, 12,  6], [ 2,  8,  4, 16] ] --> 3
[ [ 3,  7, 10,  5], [ 6,  8, 12, 13], [15,  9, 11,  4], [14,  1, 16,  2] ] --> 12
[ [ 8,  9,  3,  6], [13, 11,  7, 15], [12, 10, 16,  2], [ 4, 14,  1,  5] ] --> 34
[ [ 8, 11, 12,  9], [14,  5, 10, 16], [ 7,  3,  1,  6], [13,  4,  2, 15] ] --> 51
[ [13, 14,  1,  2], [16, 15,  3,  4], [ 5,  6,  7,  8], [ 9, 10, 11, 12] ] --> 78
[ [ 9, 10, 11, 12], [ 1,  2,  4, 13], [ 7,  8,  5, 14], [ 3, 16,  6, 15] ] --> 102
[ [ 9, 10, 11, 12], [ 1,  2,  7, 13], [ 6, 16,  4, 14], [ 3,  8,  5, 15] ] --> 103

파이썬 2 , ₁₃₃₁₃₀ 바이트

a=input();m=16
for i in range(m):a[i*5:i*5]=0,
while m:i=a.index(m);a[i]=0;m=max(a[i+x]for x in[-6,-5,-4,-1,1,4,5,6])
print sum(a)

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

평평한 16 개 요소 목록을 가져옵니다.

작동 원리

a=input();m=16

# Add zero padding on each row, and enough zeroes at the end to avoid index error
for i in range(m):a[i*5:i*5]=0,

# m == maximum element found in last iteration
# i == index of last eaten element
# eaten elements of `a` are reset to 0
while m:i=a.index(m);a[i]=0;m=max(a[i+x]for x in[-6,-5,-4,-1,1,4,5,6])
print sum(a)

파이썬 2 , 111 바이트

i=x=a=input()
while x:x,i=max((y,j)for j,y in enumerate(a)if i>[]or 2>i/4-j/4>-2<i%4-j%4<2);a[i]=0
print sum(a)

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

Bubbler 에서 채택한 방법 및 테스트 사례 . STDIN에 간단한 목록을 작성합니다.

코드 검사 두 평면 인덱스 여부 i및 j두 행 다른 것을 선택하여 터치 셀을 나타내는 i/4-j/4컬럼 차가 i%4-j%4제 패스 대신 체크 자동 최대 엔트리가 인접 무시 발견되도록 성공했다 -2와 2 사이에 엄격하다.

MATL , 50 49 47 바이트

16:HZ^!"2G@m1ZIm~]v16eXK68E16b"Ky0)Y)fyX-X>h]s-

입력은 ;행 분리 자로 사용되는 행렬 입니다.

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

16:HZ^!  % Cartesian power of [1 2 ... 16] with exponent 2, transpose. Gives a 
         % 2-row matrix with 1st column [1; 1], 2nd [1; 2], ..., last [16; 16] 
"        % For each column, say [k; j]
  2      %   Push 2
  G@m    %   Push input matrix, then current column [k; j], then check membership.
         %   This gives a 4×4 matrix that contains 1 for entries of the input that
         %   contain k or j 
  1ZI    %   Connected components (based on 8-neighbourhood) of nonzero entries.
         %   This gives a 4×4 matrix with each connected component labeled with
         %   values 1, 2, ... respectively
  m~     %   True if 2 is not present in this matrix. That means there is only
         %   one connected component; that is, k and j are neighbours in the
         %   input matrix, or k=j
]        % End
v16e     % The stack now has 256 values. Concatenate them into a vector and
         % reshape as a 16×16 matrix. This matrix describes neighbourhood: entry 
         % (k,j) is 1 if values k and j are neighbours in the input or if k=j
XK       % Copy into clipboard K
68E      % Push 68 times 2, that is, 136, which is 1+2+...+16
16       % Push 16. This is the initial value eaten by the mouse. New values will
         % be appended to create a vector of eaten values
b        % Bubble up the 16×16 matrix to the top of the stack
"        % For each column. This just executes the loop 16 times
  K      %   Push neighbourhood matrix from clipboard K
  y      %   Copy from below: pushes a copy of the vector of eaten values
  0)     %   Get last value. This is the most recent eaten value
  Y)     %   Get that row of the neighbourhood matrix
  f      %   Indices of nonzeros. This gives a vector of neighbours of the last
         %   eaten value
  y      %   Copy from below: pushes a copy of the vector of eaten values
  X-     %   Set difference (may give an empty result)
  X>     %   Maximum value. This is the new eaten value (maximum neighbour not
         %   already eaten). May be empty, if all neighbours are already eaten
  h      %   Concatenate to vector of eaten values
]        % End
s        % Sum of vector of all eaten values
-        % Subtract from 136. Implicitly display

PHP, 177174171 바이트

for($v=16;$v;$u+=$v=max($p%4-1?max($a[$p-5],$a[$p-1],$a[$p+3]):0,$a[$p-4],$a[$p+4],$p%4?max($a[$p-3],$a[$p+1],$a[$p+5]):0))$a[$p=array_search($v,$a=&$argv)]=0;echo 120-$u;

로 실행하고 -nr, 행렬 요소를 인수로 제공하거나 온라인으로 시도하십시오 .

자바 스크립트, 122 바이트

나는 이것에 대해 두 번 이상 틀린 턴을했고 지금은 더 많은 골프를 할 시간이 부족하지만 적어도 작동하고 있습니다. 내가 1 분을 찾을 수 있다면 내일 다시 방문 할 것입니다.

a=>(g=n=>n?g([-6,-5,-4,-1,1,4,5,6].map(x=>n=a[x+=i]>n?a[x]:n,a[i=a.indexOf(n)]=n=0)|n)-n:120)(16,a=a.flatMap(x=>[...x,0]))

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

R , 128 124 123 112 110 바이트

function(r){r=rbind(0,cbind(0,r,0),0)
m=r>15
while(r[m]){r[m]=0
m=r==max(r[which(m)+c(7:5,1)%o%-1:1])}
sum(r)}

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

4x4 매트릭스를 만들어서 (물건을 시각화하는 데 도움이 됨) 0으로 채운 다음 16부터 시작하여 다음으로 가장 큰 "필"을 둘러 쌉니다.

결론적으로 경고를 출력하지만 결과는 없으며 결과를 변경하지 않습니다.

편집 : 행렬의 초기화를 1 줄로 압축하여 -4 바이트.

편집 : Robert Hacken 덕분에 -1

편집 : Giuseppe와 Robin Ryder의 제안을 결합한 -13 바이트.

숯 , 47 바이트

ＥＡ⭆ι§αλ≔QθＷ›θA«≔⌕ＫＡθθＪ﹪θ⁴÷θ⁴≔⌈ＫＭθA»≔ΣＥＫＡ⌕αιθ⎚Ｉθ

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

ＥＡ⭆ι§αλ

입력 숫자를 알파벳 문자 (A = 0 .. Q = 16)로 변환하고 4x4 격자로 인쇄하십시오.

≔Qθ

Q, 즉 16을 먹는 것으로 시작하십시오.

Ｗ›θA«

먹을 것이있는 동안 반복하십시오.

≔⌕ＫＡθθ

더미가있는 곳을 찾으십시오. 이것은 행 주요 순서의 선형 뷰입니다.

Ｊ﹪θ⁴÷θ⁴

좌표로 변환하고 해당 위치로 이동하십시오.

≔⌈ＫＭθ

가장 큰 인접 파일을 찾으십시오.

A»

현재 더미를 먹는다.

≔ΣＥＫＡ⌕αιθ

더미를 다시 정수로 변환하고 합계를 가져옵니다.

⎚Ｉθ

캔버스를 지우고 결과를 출력하십시오.

파워 쉘, 143 141 136 130 122 121 바이트

$a=,0*5+($args|%{$_+0})
for($n=16;$i=$a.IndexOf($n)){$a[$i]=0
$n=(-1,1+-6..-4+4..6|%{$a[$i+$_]}|sort)[-1]}$a|%{$s+=$_}
$s

덜 골프 테스트 스크립트 :

$f = {

$a=,0*5+($args|%{$_+0})
for($n=16;$i=$a.IndexOf($n)){
    $a[$i]=0
    $n=(-1,1+-6..-4+4..6|%{$a[$i+$_]}|sort)[-1]
}
$a|%{$s+=$_}
$s

}

@(
    ,( 0  , ( 4,  3,  2,  1), ( 5,  6,  7,  8), (12, 11, 10,  9), (13, 14, 15, 16) )
    ,( 0  , ( 8,  1,  9, 14), (11,  6,  5, 16), (13, 15,  2,  7), (10,  3, 12,  4) )
    ,( 1  , ( 1,  2,  3,  4), ( 5,  6,  7,  8), ( 9, 10, 11, 12), (13, 14, 15, 16) )
    ,( 3  , (10, 15, 14, 11), ( 9,  3,  1,  7), (13,  5, 12,  6), ( 2,  8,  4, 16) )
    ,( 12 , ( 3,  7, 10,  5), ( 6,  8, 12, 13), (15,  9, 11,  4), (14,  1, 16,  2) )
    ,( 34 , ( 8,  9,  3,  6), (13, 11,  7, 15), (12, 10, 16,  2), ( 4, 14,  1,  5) )
    ,( 51 , ( 8, 11, 12,  9), (14,  5, 10, 16), ( 7,  3,  1,  6), (13,  4,  2, 15) )
    ,( 78 , (13, 14,  1,  2), (16, 15,  3,  4), ( 5,  6,  7,  8), ( 9, 10, 11, 12) )
    ,( 102, ( 9, 10, 11, 12), ( 1,  2,  4, 13), ( 7,  8,  5, 14), ( 3, 16,  6, 15) )
    ,( 103, ( 9, 10, 11, 12), ( 1,  2,  7, 13), ( 6, 16,  4, 14), ( 3,  8,  5, 15) )
) | % {
    $expected, $a = $_
    $result = &$f @a
    "$($result-eq$expected): $result"
}

산출:

True: 0
True: 0
True: 1
True: 3
True: 12
True: 34
True: 51
True: 78
True: 102
True: 103

설명:

먼저 0의 상단 및 하단 테두리를 추가하고 단일 차원 배열을 만듭니다.

0 0 0 0 0
# # # # 0
# # # # 0
# # # # 0
# # # # 0

     ↓

0 0 0 0 0 # # # # 0 # # # # 0 # # # # 0 # # # # 0

$null배열 끝의 값을 얻으려고하면 Powershell이 ​​반환 합니다.

둘째 , 루프 biggest neighbor pile는 16에서 0이 아닌 최대 값으로 시작되었습니다. 그리고 그것을 무효화하십시오 (배고픈 마우스가 먹습니다).

for($n=16;$i=$a.IndexOf($n)){
    $a[$i]=0
    $n=(-1,1+-6..-4+4..6|%{$a[$i+$_]}|sort)[-1]
}

셋째 , 남은 파일의 합입니다.

SAS, 236 219 바이트

펀치 카드에 입력, 그리드 당 한 줄 (공백으로 구분), 출력이 로그에 인쇄됩니다.

이 문제는 SAS의 일부 어레이 제한으로 인해 약간 복잡합니다.

• 다차원 데이터 단계 배열에서 일치하는 요소의 행 및 열 인덱스를 반환하는 방법은 없습니다. 배열을 1-d로 처리 한 다음 스스로 해결해야합니다.
• 범위를 벗어나면 SAS는 오류를 발생시키고 null / zero를 반환하지 않고 처리를 중단합니다.

업데이트 :

• 제거 된 infile cards;진술 (-13)
• (-4)가 a:아닌 배열 정의에 와일드 카드 사용a1-a16

골프 :

data;input a1-a16;array a[4,4]a:;p=16;t=136;do while(p);m=whichn(p,of a:);t=t-p;j=mod(m-1,4)+1;i=ceil(m/4);a[i,j]=0;p=0;do k=max(1,i-1)to min(i+1,4);do l=max(1,j-1)to min(j+1,4);p=max(p,a[k,l]);end;end;end;put t;cards;
    <insert punch cards here>
    ; 

언 골프 드 :

data;                /*Produce a dataset using automatic naming*/
input a1-a16;        /*Read 16 variables*/
array a[4,4] a:;     /*Assign to a 4x4 array*/
p=16;                /*Initial pile to look for*/
t=136;               /*Total cheese to decrement*/
do while(p);         /*Stop if there are no piles available with size > 0*/
  m=whichn(p,of a:); /*Find array element containing current pile size*/
  t=t-p;             /*Decrement total cheese*/
  j=mod(m-1,4)+1;    /*Get column number*/
  i=ceil(m/4);       /*Get row number*/
  a[i,j]=0;          /*Eat the current pile*/
                     /*Find the size of the largest adjacent pile*/
  p=0;
  do k=max(1,i-1)to min(i+1,4);
    do l=max(1,j-1)to min(j+1,4);
      p=max(p,a[k,l]);
    end;
  end;
end;
put t;              /*Print total remaining cheese to log*/
                    /*Start of punch card input*/
cards; 
  4  3  2  1  5  6  7  8 12 11 10  9 13 14 15 16 
  8  1  9 14 11  6  5 16 13 15  2  7 10  3 12  4 
  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 
 10 15 14 11  9  3  1  7 13  5 12  6  2  8  4 16 
  3  7 10  5  6  8 12 13 15  9 11  4 14  1 16  2 
  8  9  3  6 13 11  7 15 12 10 16  2  4 14  1  5 
  8 11 12  9 14  5 10 16  7  3  1  6 13  4  2 15 
 13 14  1  2 16 15  3  4  5  6  7  8  9 10 11 12 
  9 10 11 12  1  2  4 13  7  8  5 14  3 16  6 15 
  9 10 11 12  1  2  7 13  6 16  4 14  3  8  5 15 
;                    /*End of punch card input*/
                     /*Implicit run;*/

하스켈 , 163 바이트

o f=foldl1 f.concat
r=[0..3]
q n=take(min(n+2)3).drop(n-1)
0#m=m
v#m=[o max$q y$q x<$>n|y<-r,x<-r,m!!y!!x==v]!!0#n where n=map(z<$>)m;z w|w==v=0|0<1=w
f=o(+).(16#)

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

이 f함수는 입력을 4 개의 정수로 된 4 개의 목록으로 가져옵니다.

약간 골퍼

-- helper to fold over the matrix
o f = foldl1 f . concat

-- range of indices
r = [0 .. 3]

-- slice a list (take the neighborhood of a given coordinate)
-- first we drop everything before the neighborhood and then take the neighborhood itself
q n = take (min (n + 2) 3) . drop (n - 1)

-- a step function
0 # m = m -- if the max value of the previous step is zero, return the map
v # m = 
    -- abuse list comprehension to find the current value in the map
    -- convert the found value to its neighborhood,
    -- then calculate the max cell value in it
    -- and finally take the head of the resulting list
    [ o max (q y (q x<$>n)) | y <- r, x <- r, m!!y!!x == v] !! 0 
       # n -- recurse with our new current value and new map
    where 
        -- a new map with the zero put in place of the value the mouse currently sits on 
        n = map (zero <$>) m
        -- this function returns zero if its argument is equal to v
        -- and original argument value otherwise
        zero w 
            | w == v = 0
            | otherwise = w

-- THE function. first apply the step function to incoming map,
-- then compute sum of its cells
f = o (+) . (16 #)

JavaScript (ES7), 97 바이트

평평한 배열로 입력을받습니다.

f=(a,s=p=136,m,d)=>a.map((v,n)=>v<m|(n%4-p%4)**2+(n-p)**2/9>d||(q=n,m=v))|m?f(a,s-m,a[p=q]=0,4):s

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

댓글

f = (                    // f= recursive function taking:
  a,                     // - a[] = flattened input array
  s =                    // - s = sum of cheese piles, initialized to 1 + 2 + .. + 16 = 136
      p = 136,           // - p = position of the mouse, initially outside the board
  m,                     // - m = maximum pile, initially undefined
  d                      // - d = distance threshold, initially undefined
) =>                     // 
  a.map((v, n) =>        // for each pile v at position n in a[]:
    v < m |              //   unless this pile is not better than the current maximum
    (n % 4 - p % 4) ** 2 //   or (n % 4 - p % 4)²
    + (n - p) ** 2 / 9   //      + (n - p)² / 9
    > d ||               //   is greater than the distance threshold:
    (q = n, m = v)       //     update m to v and q to n
  )                      // end of map()
  | m ?                  // if we've found a new pile to eat:
    f(                   //   do a recursive call:
      a,                 //     pass a[] unchanged
      s - m,             //     update s by subtracting the pile we've just eaten
      a[p = q] = 0,      //     clear a[q], update p to q and set m = 0
      4                  //     use d = 4 for all next iterations
    )                    //   end of recursive call
  :                      // else:
    s                    //   stop recursion and return s

APL (Dyalog Unicode) , 42 41 바이트 ^SBCS

16{×⍺:a∇⍨+/,m×⌈/⌈/⊢⌺3 3⊢a←⍵×~m←⍺=⍵⋄+/,⍵}⊢

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

Java 10, 272 248 바이트

m->{int r=0,c=0,R=4,C,M=1,x,y,X=0,Y=0;for(;R-->0;)for(C=4;C-->0;)if(m[R][C]>15)m[r=R][c=C]=0;for(;M!=0;m[r=X][c=Y]=0)for(M=-1,C=9;C-->0;)try{if((R=m[x=r+C/3-1][y=c+C%3-1])>M){M=R;X=x;Y=y;}}catch(Exception e){}for(var Z:m)for(int z:Z)M+=z;return M;}

셀은 모든 단일 여덟 도전에 대한 내 대답 과 동일하게 확인 됩니다. @ OlivierGrégoire
덕분에 -24 바이트 .

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

설명:

m->{                       // Method with integer-matrix parameter and integer return-type
  int r=0,                 //  Row-coordinate for the largest number, starting at 0
      c=0,                 //  Column-coordinate for the largest number, starting at 0
      R=4,C,               //  Row and column indices (later reused as temp integers)
      M=1,                 //  Largest number the mouse just ate, starting at 1
      x,y,X=0,Y=0;         //  Temp integers
  for(;R-->0;)             //  Loop `R` in the range (4, 0]:
    for(C=4;C-->0;)        //   Inner loop `C` in the range (4, 0]:
      if(m[R][C]>15)       //    If the current cell is 16:
        m[r=R][c=C]        //     Set `r,c` to this coordinate
          =0;              //     And empty this cell
  for(;M!=0;               //  Loop as long as the largest number isn't 0:
      ;                    //    After every iteration:
       m[r=X][c=Y]         //     Change the `r,c` coordinates,
         =0)               //     And empty this cell
    for(M=-1,              //   Reset `M` to -1
        C=9;C-->0;)        //   Inner loop `C` in the range (9, 0]:
          try{if((R=       //    Set `R` to:
            m[x=r+C/3-1]   //     If `C` is 0, 1, or 2: Look at the previous row
                           //     Else-if `C` is 6, 7, or 8: Look at the next row
                           //     Else (`C` is 3, 4, or 5): Look at the current row
             [y=c+C%3-1])  //     If `C` is 0, 3, or 6: Look at the previous column
                           //     Else-if `C` is 2, 5, or 8: Look at the next column
                           //     Else (`C` is 1, 4, or 7): Look at the current column
               >M){        //    And if the number in this cell is larger than `M`
                 M=R;      //     Change `M` to this number
                 X=x;Y=y;} //     And change the `X,Y` coordinate to this cell
          }catch(Exception e){}
                           //    Catch and ignore ArrayIndexOutOfBoundsExceptions
                           //    (try-catch saves bytes in comparison to if-checks)
  for(var Z:m)             //  Then loop over all rows of the matrix:
    for(int z:Z)           //   Inner loop over all columns of the matrix:
      M+=z;                //    And sum them all together in `M` (which was 0)
  return M;}               //  Then return this sum as result

J, 82 바이트

g=.](]*{:@[~:])]_1}~[:>./]{~((,-)1 5 6 7)+]i.{:
[:+/[:(g^:_)16,~[:,0,~0,0,0,.~0,.]

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

나는이 더 내일 골프 계획, 아마이 비슷한 더 J-틱 솔루션 쓰기 를 ,하지만 난 그 전에하지했기 때문에 나는 평평하게 접근 방식을 시도 거라고 생각.

빨강 , 277 바이트

func[a][k: 16 until[t:(index? find load form a k)- 1
p: do rejoin[t / 4 + 1"x"t % 4 + 1]a/(p/1)/(p/2): 0
m: 0 foreach d[-1 0x-1 1x-1 -1x0 1x0 -1x1 0x1 1][j: p + d
if all[j/1 > 0 j/1 < 5 j/2 > 0 j/2 < 5 m < t: a/(j/1)/(j/2)][m: t]]0 = k: m]s: 0
foreach n load form a[s: s + n]s]

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

정말 긴 솔루션이며 만족스럽지 않지만 TIO에서 작동하도록 수정하는 데 많은 시간을 보냈습니다 (분명히 Win의 안정적인 버전과 Linux의 안정적인 버전 사이에는 많은 차이가 있습니다).

더 읽기 쉬운 :

f: func [ a ] [
    k: 16
    until [
        t: (index? find load form a n) - 1
        p: do rejoin [ t / 4 + 1 "x" t % 4 + 1 ]
        a/(p/1)/(p/2): 0
        m: 0
        foreach d [ -1 0x-1 1x-1 -1x0 1x0 -1x1 0x1 1 ] [
            j: p + d
            if all[ j/1 > 0
                    j/1 < 5
                    j/2 > 0
                    j/2 < 5 
                    m < t: a/(j/1)/(j/2)
            ] [ m: t ]
        ]
        0 = k: m
    ]
    s: 0
    foreach n load form a [ s: s + n ]
    s
]

젤리 ,  31 30  29 바이트

³œiⱮZIỊȦ
⁴ṖŒPŒ!€Ẏ⁴;ⱮṢÇƇṪ
FḟÇS

방법에 마우스 시작으로 60에서 실행하기 너무 느리므로 16이 그녀를 시작 9하고 그녀가 먹을 만 수 있도록 그녀의 능력을 제한 9들 이하 온라인으로보십시오! (따라서 그녀는 9, 2, 7, 4, 8, 6, 3떠나는 것을 먹는다 97).

어떻게?

³œiⱮZIỊȦ - Link 1, isSatisfactory?: list of integers, possiblePileChoice
³        - (using a left argument of) program's 3rd command line argument (M)
   Ɱ     - map across (possiblePileChoice) with:
 œi      -   first multi-dimensional index of (the item) in (M)
    Z    - transpose the resulting list of [row, column] values
     I   - get the incremental differences
      Ị  - insignificant? (vectorises an abs(v) <= 1 test)
       Ȧ - any and all? (0 if any 0s are present in the flattened result [or if it's empty])

⁴ṖŒPŒ!€Ẏ⁴;ⱮṢÇƇṪ - Link 2, getChosenPileList: list of lists of integers, M
⁴               - literal 16
 Ṗ              - pop -> [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
  ŒP            - power-set -> [[],[1],[2],...,[1,2],[1,3],...,[2,3,7],...,[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]]
      €         - for each:
    Œ!          -   all permutations
       Ẏ        - tighten (to a single list of all these individual permutations)
        ⁴       - (using a left argument of) literal 16
          Ɱ     - map across it with:
         ;      -   concatenate (put a 16 at the beginning of each one)
           Ṣ    - sort the resulting list of lists
             Ƈ  - filter keep those for which this is truthy:
            Ç   -   call last Link as a monad (i.e. isSatisfactory(possiblePileChoice)
              Ṫ - tail (get the right-most, i.e. the maximal satisfactory one)

FḟÇS - Main Link: list of lists of integers, M
F    - flatten M
  Ç  - call last Link (2) as a monad (i.e. get getChosenPileList(M))
 ḟ   - filter discard (the resulting values) from (the flattened M)
   S - sum

최선이 아니야 확실한 개선이 이루어 int[]졌고, 아마도 사용 된 알고리즘의 기초가 될 것입니다 .- 만 사용하여 향상시킬 수는 있지만 확실하게 이웃을 그렇게 열거하는 방법을 알 수는 없습니다. 1 차원 배열 만 사용하는 PowerShell 솔루션을보고 싶습니다!

PowerShell 코어 , 348 바이트

Function F($o){$t=120;$a=@{-1=,0*4;4=,0*4};0..3|%{$a[$_]=[int[]](-join$o[(3+18*$_)..(3+18*$_+13)]-split',')+,0};$m=16;while($m-gt0){0..3|%{$i=$_;0..3|%{if($a[$i][$_]-eq$m){$r=$i;$c=$_}}};$m=($a[$r-1][$c-1],$a[$r-1][$c],$a[$r-1][$c+1],$a[$r][$c+1],$a[$r][$c-1],$a[$r+1][$c-1],$a[$r+1][$c],$a[$r+1][$c+1]|Measure -Max).Maximum;$t-=$m;$a[$r][$c]=0}$t}

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

더 읽기 쉬운 버전 :

Function F($o){
    $t=120;
    $a=@{-1=,0*4;4=,0*4};
    0..3|%{$a[$_]=[int[]](-join$o[(3+18*$_)..(3+18*$_+13)]-split',')+,0};
    $m=16;
    while($m-gt0){
        0..3|%{$i=$_;0..3|%{if($a[$i][$_]-eq$m){$r=$i;$c=$_}}};
        $m=($a[$r-1][$c-1],$a[$r-1][$c],$a[$r-1][$c+1],$a[$r][$c+1],$a[$r][$c-1],$a[$r+1][$c-1],$a[$r+1][$c],$a[$r+1][$c+1]|Measure -Max).Maximum;
        $t-=$m;
        $a[$r][$c]=0
    }
    $t
}

C (gcc), 250 바이트

x;y;i;b;R;C;
g(int a[][4],int X,int Y){b=a[Y][X]=0;for(x=-1;x<2;++x)for(y=-1;y<2;++y)if(!(x+X&~3||y+Y&~3||a[y+Y][x+X]<b))b=a[C=Y+y][R=X+x];for(i=x=0;i<16;++i)x+=a[0][i];return b?g(a,R,C):x;}
s(int*a){for(i=0;i<16;++i)if(a[i]==16)return g(a,i%4,i/4);}

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

참고 :이 제출은 입력 배열을 수정합니다.

s()변경 가능한의 인자로 호출하는 함수 int[16](AS를 메모리 동일 int[4][4]무엇입니까 g()로 해석)은.

s()16배열에서 의 위치를 ​​찾은 다음이 정보를로 전달합니다.이 정보 g는 위치를 가져 와서 해당 위치의 숫자를 0으로 설정하는 재귀 함수입니다.

• 인접한 양수가 있으면 가장 큰 인접 숫자의 위치로 반복합니다.

• 그렇지 않으면 배열의 숫자 합계를 반환하십시오.

Wolfram Language (Mathematica) , 149 바이트

(g@p_:=#&@@Position[s,Max@p];m=g[s=#];While[Tr[b=s[[##]]&@@#&/@Select[#+m&/@Tuples[{-1,0,1},2],Max@#<5&&Min@#>0&]]>0,m=g@b;s[[##&@@m]]=0];Tr[Tr/@s])&

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

추가 ++ 281 바이트

D,f,@@,VBFB]G€=dbLRz€¦*bMd1_4/i1+$4%B]4 4b[$z€¦o
D,g,@@,c2112011022200200BD1€Ω_2$TAVb]8*z€kþbNG€lbM
D,k,@~,z€¦+d4€>¦+$d1€<¦+$@+!*
D,l,@@#,bUV1_$:G1_$:
D,h,@@,{l}A$bUV1_$:$VbU","jG$t0€obU0j","$t€iA$bUpVdbLRG€=€!z€¦*$b]4*$z€¦o
y:?
m:16
t:120
Wm,`x,$f>y>m,`m,$g>x>y,`y,$h>x>y,`t,-m
Ot

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

Oof, 이것은 복잡한 것입니다.

모든 테스트 사례 확인

작동 원리

이 설명을 위해 입력을 사용합니다

$M = \left[\begin{matrix} 3 & 7 & 10 & 5 \\ 6 & 8 & 12 & 13 \\ 15 & 9 & 11 & 4 \\ 14 & 1 & 16 & 2 \\ \end{matrix}\right]$

$x$$1 \le x \le 16$$M$$4\text{x}4$

• $f(x, M)$$4\text{x}4$$x$$M$$x = 16$$M$$f(x, M) = (4, 3)$

• $g(M, y)$$f(x, M)$$g(M, f(x, M)) = 11$

  이것은 두 가지 도우미 기능을 구현합니다.

  $k(x)$

  $l(M, y)$

• $h(y, M)$$0$

$0$$16$$120 \: (1 + 2 + \cdots + 14 + 15)$

다음으로 우리는 while 루프를 입력합니다. m 은 이 아닙니다.$0$ 합니다. 루프의 단계는

$\neq 0$

• $f(\textbf{y}, \textbf{m})$$16$$M$$x := (4, 3)$ 이 예에서)
• $g(\textbf{x}, \textbf{y})$$0$
• $h(\textbf{x}, \textbf{y})$$16$$0$
• $\textbf{t} - \textbf{m}$

마지막으로 출력 t , 즉 수집되지 않은 나머지 값.

C # (. NET 코어) 258 바이트

LINQ없이. using System.Collections.Generic은 이후의 서식을 지정하는 데 사용됩니다.이 기능에는 필요하지 않습니다.

e=>{int a=0,b=0,x=0,y=0,j=0,k;foreach(int p in e){if(p>15){a=x=j/4;b=y=j%4;}j++;}e[x,y]=0;while(1>0){for(j=-1;j<2;j++)for(k=-1;k<2;k++){try{if(e[a+k,b+j]>e[x,y]){x=a+k;y=b+j;}}catch{}}if(e[x,y]<1)break;e[x,y]=0;a=x;b=y;}a=0;foreach(int p in e)a+=p;return a;}

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

펄 (6) , 151 (136) 126 125 119 바이트

{my@k=$_;my $a=.grep(16,:k)[0];while @k[$a] {@k[$a]=0;$a=^@k .grep({2>$a+>2-$_+>2&$a%4-$_%4>-2}).max({@k[$_]})};[+] @k}

초라한 솔루션. 평평한 배열로 입력을받습니다.

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

펄 5 -MList::Util=sum -p , 137 바이트

splice@F,$_,0,0for 12,8,4;map{$k{++$,}=$_;$n=$,if$_&16}@F;map{map{$n=$_+$"if$k{$"+$_}>$k{$n}&&!/2|3/}-6..6;$k{$"=$n}=0}@F;$_=sum values%k

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

K (ngn / k) , 49 바이트

{{h[,x]:0;*>(+x+0,'1-!3 3)#h}\*>h::(+!4 4)!x;+/h}

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

입력 ( x)은 1d 배열입니다

(+!4 4)!x 좌표 쌍을 다음의 값에 매핑하는 사전 x

h:: 전역 변수에 할당 h

*> 최대 값에 해당하는 키

{ }\ 수렴까지 반복하여 목록에서 중간 값을 수집합니다.

h[,x]:0 현재 위치를 제로

+x+0,'1-!3 3 이웃 위치

( )#hh더 작은 사전으로 필터링

*>어느 이웃이 최대 값을 가지고 있습니까? 새 반복의 현재 위치가됩니다.

+/h마지막으로, h남은 값 의 합을 반환

Wolfram Language (Mathematica) , 124115 바이트

(p=#&@@Position[m=Join@@ArrayPad[#,1],16];Do[m[[p]]=0;p=MaximalBy[#&@@p+{0,-1,1,-5,5,-6,6,-7,7},m[[#]]&],16];Tr@m)&

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

이것은 2D 배열을 가져 와서 양쪽에 패딩 한 다음 즉시 평평하게하므로 바이트 인덱싱에 소비 할 필요가 없습니다. 이것에 대한 유일한 비용은 Join@@납작하게하는 것입니다. 그 후 다음과 같이 진행됩니다.

2D 어레 이용 124 바이트 버전 : 온라인으로 사용해보십시오!

J42161217의 149 바이트 답변 에서 파생 된 비트가있는 대부분 내 작품 .

언 골프 드 :

(p = #& @@ Position[m = #~ArrayPad~1,16];     m = input padded with a layer of 0s
                                              p = location of 16
Do[
    m = MapAt[0&,m,p];                        Put a 0 at location p
    p = #& @@ MaximalBy[                      Set p to the member of
        p+#& /@ Tuples[{0,-1,1},2],             {all possible next locations}
        m~Extract~#&],                        that maximizes that element of m,
                                              ties broken by staying at p+{0,0}=p.
16];                                        Do this 16 times.
Tr[Tr/@m]                                   Finally, output the sum of m.
)&