มีกองชีสจำนวนสิบหกกองวางอยู่บนพื้นที่ 4x4 พวกเขากำลังมีป้ายกำกับจากที่จะ16กองเล็กที่สุดคือและอีกคนหนึ่งที่ใหญ่ที่สุดคือ16$1$$16$$1$$16$

Hungry Mouse หิวมากจนมันพุ่งตรงไปยังกองที่ใหญ่ที่สุด (เช่น ) และกินทันที$16$

หลังจากนั้นมันก็จะไปกองใกล้เคียงที่ใหญ่ที่สุดและกินมันเร็วเช่นกัน (ใช่ ... มันหิวจริงๆ ) และต่อ ๆ ไปจนกว่าจะไม่มีกองใกล้เคียงอีกต่อไป

กองอาจมีมากถึง 8 เพื่อนบ้าน (แนวนอนแนวตั้งและแนวทแยงมุม) ไม่มีการพันรอบตัว

ตัวอย่าง

เราเริ่มต้นด้วยกองชีสต่อไปนี้:

หิวเมาส์แรกกินและจากนั้นกองเพื่อนบ้านที่ใหญ่ที่สุดซึ่งเป็น11$16$$11$

การเคลื่อนไหวครั้งต่อไปคือ , , , , , , , ,และตามลำดับที่แน่นอนนี้$13$$12$$10$$8$$15$$14$$9$$6$$7$$3$

ไม่มีเนยแข็งรอบ ๆ Hungry Mouse อีกต่อไปดังนั้นมันจึงหยุดอยู่ที่นั่น

ความท้าทาย

ด้วยการกำหนดค่าเริ่มต้นของชีสรหัสของคุณจะต้องพิมพ์หรือคืนผลรวมของกองที่เหลือเมื่อ Hungry Mouse หยุดกินมัน

สำหรับตัวอย่างข้างต้นคำตอบที่คาดไว้คือ12$12$

กฎระเบียบ

• เนื่องจากขนาดของอินพุตเมทริกซ์ได้รับการแก้ไขคุณอาจใช้มันเป็นอาร์เรย์สองมิติหรืออาร์เรย์หนึ่งมิติ
• แต่ละค่าตั้งแต่ถึงจะรับประกันว่าจะปรากฏหนึ่งครั้ง$1$$16$
• นี่คือรหัสกอล์ฟ

กรณีทดสอบ

[ [ 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 ไบต์

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)

Python 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, 177 174 171 ไบต์

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 ไบต์

ฉันเลี้ยวผิดมากกว่าสองครั้งในครั้งนี้และตอนนี้ฉันหมดเวลาไปกับการเล่นกอล์ฟต่อไป แต่อย่างน้อยมันก็ใช้ได้ จะกลับมาอีกในวันพรุ่งนี้ (หรือรู้จักฉันในบ้านรถไฟในเย็นวันนี้!) ถ้าฉันสามารถหานาทีได้

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 และค้นหาว่ามันล้อมรอบ "กอง" เพื่อหาสิ่งที่ใหญ่ที่สุดถัดไปและอื่น ๆ

เมื่อสรุปแล้วมันจะออกคำเตือน แต่ก็ไม่มีผลใด ๆ และจะไม่เปลี่ยนแปลงผลลัพธ์

แก้ไข: -4 ไบต์โดยการบีบอัดการเริ่มต้นของเมทริกซ์เป็น 1 บรรทัด

แก้ไข: -1 ต้องขอบคุณ Robert Hacken

แก้ไข: -13 ไบต์รวมคำแนะนำของ Giuseppe และ Robin Ryder

ถ่าน , 47 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

ＥＡ⭆ι§αλ

แปลงตัวเลขอินพุตเป็นอักขระตัวอักษร (A = 0 .. Q = 16) และพิมพ์เป็นตาราง 4x4

≔Qθ

เริ่มต้นด้วยการกิน Q นั่นคือ 16

Ｗ›θA«

ทำซ้ำในขณะที่มีอะไรกิน

≔⌕ＫＡθθ

ค้นหากองที่อยู่ นี่คือมุมมองเชิงเส้นตามลำดับแถวหลัก

Ｊ﹪θ⁴÷θ⁴

แปลงเป็นพิกัดและข้ามไปยังตำแหน่งนั้น

≔⌈ＫＭθ

ค้นหากองที่อยู่ติดกันที่ใหญ่ที่สุด

A»

กินกองปัจจุบัน

≔ΣＥＫＡ⌕αιθ

แปลงเสาเข็มกลับเป็นจำนวนเต็มและนำผลรวม

⎚Ｉθ

ล้างแคนวาสและเอาท์พุทผลลัพธ์

Powershell, 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

สคริปต์ทดสอบ golfed น้อย:

$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

Powershell ส่งคืน$nullถ้าคุณพยายามรับค่าที่อยู่หลังจุดสิ้นสุดของอาร์เรย์

ประการที่สองการวนซ้ำbiggest neighbor pileเริ่มต้นจาก 16 เป็นไม่มากสุด และลบล้างมัน (Hungry Mouse กินมัน)

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 จะพ่นข้อผิดพลาดและหยุดการประมวลผลแทนที่จะส่งคืนค่าศูนย์ /

ปรับปรุง:

• infile cards;คำสั่งที่ถูกลบ(-13)
• สัญลักษณ์ตัวแทนที่ใช้a:สำหรับการกำหนดอาร์เรย์มากกว่าa1-a16(-4)

แข็งแรงเล่นกอล์ฟ:

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

Ungolfed:

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 ไบต์

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 จำนวนเต็ม

ungolfed เล็กน้อย

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

เซลล์จะถูกตรวจสอบเช่นเดียวกับในคำตอบของฉันสำหรับทุกแปดเดียวท้าทาย
-24 ไบต์ขอบคุณที่@ OlivierGrégoire

ลองออนไลน์

คำอธิบาย:

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-ish ที่คล้ายกันนี้หนึ่งแต่ฉันคิดฉันต้องการลองใช้วิธีบี้ตั้งแต่ผมไม่ได้ทำก่อนที่จะ

สีแดง 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 (เห็นได้ชัดว่ามีความแตกต่างมากมายระหว่าง Red and 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[]แต่ฉันไม่สามารถหาวิธีระบุเพื่อนบ้านได้อย่างมีประสิทธิภาพ ฉันชอบที่จะเห็นโซลูชัน PowerShell ที่ใช้อาร์เรย์มิติเดียวเท่านั้น!

PowerShell Coreขนาด 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](ซึ่งเป็นหน่วยความจำint[4][4]ภายในที่g()เหมือนกัน

s()ค้นหาตำแหน่งของ16ในอาร์เรย์จากนั้นส่งผ่านข้อมูลนี้ไปยังgซึ่งเป็นฟังก์ชันแบบเรียกซ้ำที่ใช้ตำแหน่งตั้งค่าหมายเลขที่ตำแหน่งนั้นเป็น 0 จากนั้น:

• หากมีจำนวนบวกติดกับมันให้เรียกคืนด้วยตำแหน่งของจำนวนที่อยู่ติดกันมากที่สุด

• มิฉะนั้นส่งคืนผลรวมของตัวเลขในอาร์เรย์

ภาษา Wolfram (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

ลองออนไลน์!

นี่เป็นเรื่องที่ซับซ้อน

ตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

สำหรับคำอธิบายนี้เราจะใช้อินพุต

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

$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 Core) , 258 ไบต์

ไม่มี LINQ การใช้ 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;}

ลองออนไลน์!

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

สารละลายซุปเปอร์โทรม รับอินพุตเป็นอาร์เรย์ที่แบน

ลองออนไลน์!

Perl 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 zero out ตำแหน่งปัจจุบัน

+x+0,'1-!3 3 ตำแหน่งเพื่อนบ้าน

( )#hกรองพวกเขาจากhเป็นพจนานุกรมขนาดเล็ก

*>เพื่อนบ้านคนไหนมีค่าสูงสุด? มันจะกลายเป็นตำแหน่งปัจจุบันสำหรับการทำซ้ำใหม่

+/hในที่สุดก็คืนค่าผลรวมของhค่าที่เหลือ

ภาษา Wolfram (Mathematica) , 124 115 ไบต์

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

ลองออนไลน์!

นี่ใช้อาเรย์แบบ 2 มิติวางมันลงบนแต่ละด้านจากนั้นจึงแบนมันทันทีเพื่อให้เราไม่ต้องใช้การทำดัชนีไบต์ ราคาเพียงอย่างเดียวคือJoin@@การแบน หลังจากนั้นจะดำเนินการดังนี้

เวอร์ชัน 124 ไบต์สำหรับอาเรย์ 2 มิติ: ลองออนไลน์!

ส่วนใหญ่การทำงานของตัวเองกับบิตมาจากคำตอบที่ 149 ไบต์ J42161217 ของ

Ungolfed:

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