Mười sáu đống phô mai được đặt trên một hình vuông 4 x 4. Chúng được dán nhãn từ $1$ đến $16$ . Cọc nhỏ nhất là $1$ và lớn nhất là $16$ .

Chuột Hungry đói đến mức nó luôn đi thẳng đến đống lớn nhất (tức là $16$ ) và ăn nó ngay lập tức.

Sau đó, nó đi đến đống lân cận lớn nhất và cũng nhanh chóng ăn nó. (Yeah ... Nó thực sự đói.) Và cứ thế cho đến khi không còn hàng xóm nào nữa.

Một đống có thể có tới 8 hàng xóm (theo chiều ngang, chiều dọc và đường chéo). Không có sự bao bọc.

Thí dụ

Chúng tôi bắt đầu với những đống phô mai sau:

Chuột Hungry đầu tiên ăn $16$ , và sau đó là đống hàng xóm lớn nhất của nó, đó là $11$ .

Các bước tiếp theo của nó là $13$ , $12$ , $10$ , $8$ , $15$ , $14$ , $9$ , $6$ , $7$ và $3$ theo thứ tự chính xác này.

Không còn phô mai nữa quanh Hungry Mouse, nên nó dừng ở đó.

Các thách thức

Với cấu hình phô mai ban đầu, mã của bạn phải in hoặc trả lại tổng số cọc còn lại sau khi Chuột Hungry ngừng ăn chúng.

Đối với ví dụ trên, câu trả lời dự kiến ​​là $12$ .

Quy tắc

• Vì kích thước của ma trận đầu vào là cố định, bạn có thể lấy nó dưới dạng mảng 2D hoặc mảng một chiều.
• Mỗi giá trị từ $1$ đến $16$ được đảm bảo xuất hiện chính xác một lần.
• Đây là mã golf .

Các trường hợp thử nghiệm

[ [ 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

Python 2 , ₁₃₃ 130 byte

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)

Hãy thử trực tuyến!

Đưa ra một danh sách phẳng gồm 16 yếu tố.

Làm thế nào nó hoạt động

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)

Python 2 , 111 byte

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)

Hãy thử trực tuyến!

Phương pháp và trường hợp thử nghiệm thích nghi từ Bubbler . Đưa ra một danh sách phẳng trên STDIN.

Mã kiểm tra xem hai chỉ số phẳng ivà jbiểu thị các ô chạm nhau bằng cách kiểm tra xem cả hai hàng khác nhau i/4-j/4và chênh lệch cột i%4-j%4có đúng giữa -2 và 2. Lần đầu tiên thay vào đó kiểm tra này tự động thành công để tìm thấy mục lớn nhất bất chấp sự phụ thuộc.

MATL , 50 49 47 byte

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

Đầu vào là một ma trận, sử dụng ;như dấu phân cách hàng.

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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, 177 174 171 byte

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;

Chạy với -nr, cung cấp các yếu tố ma trận làm đối số hoặc thử trực tuyến .

JavaScript, 122 byte

Tôi đã thực hiện nhiều hơn một vài lượt sai cho lần này và bây giờ tôi đã hết thời gian để chơi gôn nhưng ít nhất nó vẫn hoạt động. Sẽ gặp lại vào ngày mai (hoặc, biết tôi, trên chuyến tàu về nhà tối nay!), Nếu tôi có thể tìm thấy một phút.

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]))

Dùng thử trực tuyến

R , 128 124 123 112 110 byte

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)}

Hãy thử trực tuyến!

Nó tạo ra một ma trận 4 x 4 (giúp tôi hình dung mọi thứ), đệm nó bằng 0, sau đó bắt đầu từ 16 và tìm kiếm các "cọc" xung quanh cho lớn nhất tiếp theo, v.v.

Sau khi kết luận, nó đưa ra một cảnh báo, nhưng nó không có kết quả và không thay đổi kết quả.

EDIT: -4 byte bằng cách nén việc khởi tạo ma trận thành 1 dòng.

EDIT: -1 nhờ Robert Hacken

EDIT: -13 byte kết hợp các đề xuất của Giuseppe và Robin Ryder.

Than , 47 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＥＡ⭆ι§αλ

Chuyển đổi các số đầu vào thành các ký tự chữ cái (A = 0 .. Q = 16) và in chúng dưới dạng lưới 4 x 4.

≔Qθ

Bắt đầu bằng cách ăn Q, tức là 16.

Ｗ›θA«

Lặp lại trong khi có một cái gì đó để ăn.

≔⌕ＫＡθθ

Tìm nơi đóng cọc. Đây là một chế độ xem tuyến tính theo thứ tự hàng lớn.

Ｊ﹪θ⁴÷θ⁴

Chuyển đổi sang tọa độ và nhảy đến vị trí đó.

≔⌈ＫＭθ

Tìm cọc liền kề lớn nhất.

A»

Ăn đống hiện tại.

≔ΣＥＫＡ⌕αιθ

Chuyển đổi các cọc trở lại số nguyên và lấy tổng.

⎚Ｉθ

Xóa khung vẽ và xuất kết quả.

Powershell, 143 141 136 130 122 121 byte

$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

Kịch bản kiểm tra ít chơi gôn hơn:

$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"
}

Đầu ra:

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

Giải trình:

Đầu tiên , thêm viền trên và dưới bằng 0 và tạo một mảng một chiều:

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

     ↓

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

Powershell trả về $nullnếu bạn cố gắng lấy giá trị phía sau cuối mảng.

Thứ hai , vòng lặp biggest neighbor pilebắt đầu từ 16 đến khác không tối đa. Và vô hiệu hóa nó (Con chuột đói ăn nó).

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

Thứ ba , tổng các cọc còn lại.

SAS, 236 219 byte

Đầu vào trên thẻ đục lỗ, một dòng trên mỗi lưới (được phân tách bằng dấu cách), đầu ra được in vào nhật ký.

Thách thức này hơi phức tạp bởi một số hạn chế của mảng trong SAS:

• Không có cách nào để trả về các chỉ mục hàng và cột của một phần tử phù hợp từ mảng bước dữ liệu đa chiều - bạn phải coi mảng là 1-d và sau đó tự xử lý chúng.
• Nếu bạn đi ra khỏi giới hạn, SAS sẽ đưa ra lỗi và tạm dừng xử lý thay vì trả về null / zero.

Cập nhật:

• infile cards;Tuyên bố bị xóa (-13)
• Ký tự đại diện được sử dụng a:cho định nghĩa mảng thay vì a1-a16(-4)

Chơi gôn

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>
    ; 

Ung dung:

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;*/

Haskell , 163 byte

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#)

Hãy thử trực tuyến!

Các fchức năng có đầu vào như một danh sách của 4 danh sách của 4 số nguyên.

Hơi vô dụng

-- 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 byte

Đưa đầu vào như một mảng phẳng.

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

Hãy thử trực tuyến!

Đã bình luận

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 byte ^SBCS

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

Hãy thử trực tuyến!

Java 10, 272 248 byte

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;}

Các ô được kiểm tra giống như trong câu trả lời của tôi cho thử thách Tất cả các đêm .
-24 byte nhờ @ OlivierGrégoire .

Hãy thử trực tuyến.

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Tôi có kế hoạch golf này thêm vào ngày mai, và có lẽ viết một giải pháp J-ish hơn tương tự như sau một , nhưng tôi figured tôi muốn thử phương pháp làm phẳng kể từ khi tôi đã không làm điều đó trước.

Màu đỏ , 277 byte

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]

Hãy thử trực tuyến!

Đó thực sự là một giải pháp lâu dài và tôi không hài lòng với nó, nhưng tôi đã dành quá nhiều thời gian để sửa nó để hoạt động trong TIO (rõ ràng có nhiều khác biệt giữa các phiên bản ổn định của Win và Linux của Red), vì vậy tôi vẫn đăng nó ...

Dễ đọc hơn:

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
]

Thạch ,  31 30  29 byte

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

Vì phương pháp này quá chậm để chạy trong vòng 60 giây với chuột bắt đầu nên việc 16này bắt đầu với cô ấy 9và hạn chế khả năng của cô ấy đến mức cô ấy chỉ có thể ăn 9s hoặc ít hơn Hãy thử trực tuyến! (vì vậy ở đây cô ấy ăn 9, 2, 7, 4, 8, 6, 3để lại 97).

Làm sao?

³œ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

Không phải công việc tốt nhất của tôi. Có một số cải tiến nhất định phải được thực hiện, một số có lẽ là cơ bản cho thuật toán được sử dụng - Tôi chắc chắn rằng nó có thể được cải thiện bằng cách chỉ sử dụng một int[], nhưng tôi không thể tìm ra cách liệt kê hiệu quả hàng xóm theo cách đó. Tôi rất muốn thấy một giải pháp PowerShell chỉ sử dụng một mảng một chiều!

Lõi PowerShell , 348 byte

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}

Hãy thử trực tuyến!

Phiên bản dễ đọc hơn:

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 byte

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);}

Hãy thử trực tuyến!

Lưu ý: Trình này sửa đổi mảng đầu vào.

s()là hàm để gọi với một đối số của một biến đổi int[16](có cùng bộ nhớ trong như một int[4][4], đó là những gì g()diễn giải nó như là).

s()tìm vị trí của 16mảng trong đó, sau đó chuyển thông tin này đến g, đây là hàm đệ quy lấy một vị trí, đặt số tại vị trí đó thành 0 và sau đó:

• Nếu có một số dương liền kề với nó, hãy lặp lại với vị trí của số liền kề lớn nhất

• Khác, trả về tổng của các số trong mảng.

Ngôn ngữ Wolfram (Mathicala) , 149 byte

(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])&

Hãy thử trực tuyến!

Thêm ++ , 281 byte

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

Hãy thử trực tuyến!

Oof, đây là một trong những phức tạp.

Xác nhận tất cả các trường hợp kiểm tra

Làm thế nào nó hoạt động

Đối với lời giải thích này, chúng tôi sẽ sử dụng đầu vào

$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$

  Điều này thực hiện hai chức năng trợ giúp:

  $k(x)$

  $l(M, y)$

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

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

$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}$

Cuối cùng, đầu ra t , tức là các giá trị còn lại, không được thu thập.

C # (.NET Core) , 258 byte

Không có LINQ. Việc sử dụng System.Collections.Generic dành cho định dạng sau - hàm không yêu cầu.

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;}

Hãy thử trực tuyến!

Perl 6 , 151 136 126 125 119 byte

{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}

Giải pháp siêu tồi tàn. Đưa đầu vào là mảng phẳng.

Hãy thử trực tuyến!

Perl 5 -MList::Util=sum -p , 137 byte

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

Hãy thử trực tuyến!

K (ngn / k) , 49 byte

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

Hãy thử trực tuyến!

đầu vào ( x) là mảng 1d

(+!4 4)!x một từ điển ánh xạ các cặp hợp âm theo các giá trị của x

h:: gán cho một biến toàn cục h

*> Khóa tương ứng với giá trị tối đa

{ }\ lặp lại cho đến khi hội tụ, thu thập các giá trị trung gian trong một danh sách

h[,x]:0 không ra khỏi vị trí hiện tại

+x+0,'1-!3 3 vị trí hàng xóm

( )#hlọc chúng từ hmột từ điển nhỏ hơn

*>hàng xóm nào có giá trị tối đa? nó trở thành vị trí hiện tại cho lần lặp mới

+/hcuối cùng, trả về tổng hgiá trị còn lại của

Ngôn ngữ Wolfram (Mathicala) , 124 115 byte

(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)&

Hãy thử trực tuyến!

Cái này lấy một mảng 2D, đặt nó ở mỗi bên, sau đó làm phẳng nó ngay lập tức để chúng ta không phải tốn chỉ số byte. Chi phí duy nhất cho việc này là Join@@làm phẳng. Sau đó, nó tiến hành như dưới đây.

Phiên bản 124 byte cho mảng 2D: Hãy thử trực tuyến!

Chủ yếu là công việc của riêng tôi, với một chút xuất phát từ câu trả lời 149 byte của J42161217 .

Ung dung:

(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.
)&