Голодна миша


85

Шістнадцять паль сиру кладуть на квадрат 4х4. Вони позначені від до 16 . Найменша купа - 1, а найбільша - 16 .116116

Голодна миша настільки голодна, що завжди прямує до найбільшої купи (тобто 16 ) і їсть її відразу.

Після цього він іде до найбільшої сусідньої купи та швидко їсть і цю. (Так ... Це справді голодно.) І так далі, поки вже немає сусідньої купи.

Купа може мати до 8 сусідів (по горизонталі, вертикалі та по діагоналі). Немає обгортки.

Приклад

Почнемо з таких паль сиру:

37105681213159114141162

Голодна миша спочатку з'їдає 16 , а потім її найбільшу купу сусіда, а це 11 .

37105681213159🐭41412

Наступні її кроки - , , , , , , , , і у такому точному порядку.131210815149673

🐭5412

Навколо Голодного Миша вже немає сиру, тому він зупиняється на цьому.

Змагання

Враховуючи початкову конфігурацію сиру, ваш код повинен надрукувати або повернути суму залишилися паль, як тільки голодна миша перестала їх їсти.

У наведеному прикладі очікувана відповідь - .12

Правила

  • Оскільки розмір вхідної матриці є фіксованим, ви можете приймати її як 2D-масив або одновимірний масив.
  • Кожне значення від до гарантовано з’явиться рівно один раз.116
  • Це .

Тестові справи

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

32
+1 для цього персонажа миші
Луїс Мендо

2
... зробіть це 103:[[9, 10, 11, 12], [1, 2, 7, 13], [6, 16, 4, 14], [3, 8, 5, 15]]
Джонатан Аллан

9
Який приємно написаний виклик! Я буду пам’ятати про найкращі номінації.
xnor

9
Після неправильного читання мені було трохи сумно, що це не голодний лось.
акозі

1
Цей виклик нагадує мені мишку в програмі лабіринт для комп'ютера txo. Ця гра була написана ще в 50-х роках минулого століття, і txo був першим в світі транзисторизованим комп'ютером. Так, вірите чи ні, хтось писав відеоігри ще в день вашого діда.
Вальтер Мітті

Відповіді:


11

Python 2 , 133 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)

Вираз сусідньої комірки a[i+x]for x in[-6,-5,-4,-1,1,4,5,6]можна скоротити до a[i+j+j/3*2-6]for j in range(9)(нульовий запис нешкідливий). Python 3, безумовно, може скоротитись шляхом жорсткого кодування бітестрингу довжиною 8, але Python 2 все ще може бути кращим в цілому.
xnor

1
Хоча ваш нульовий цикл заповнення розумна, вона виглядає , як він коротше взяти 2D список: a=[0]*5 for r in input():a=r+[0]+a. Можливо, є ще коротше рішення для нарізки рядків, яке не потребує повторення.
xnor

8

Пітон 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. Перший пропуск замість цього перевіряє автоматично успішно, так що найбільша запис виявляється з огляду на суміжність.


8

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

Idk MatLab, але чи можна трохи заощадити, якщо натиснути -136 замість +136?
Тит

@Titus Хм. Я не бачу, як
Луїс Мендо

або навпаки: я подумав замість 1) натиснути 136 2) натиснути кожне з'їдене значення 3) підсумувати з'їдені значення 4) відняти від 136 -> 1) натиснути 136 2) натиснути мінус з'їденого значення 3) підбити підсумок. Але як очевидно, це лише один байт; це, мабуть, не виграє
Тит

@Titus Ага, так, я думаю, що використовується однакова кількість байтів. Крім того, мені потрібно кожне з'їдене значення (не його негативне значення) для заданої різниці; заперечення доведеться зробити наприкінці
Луїс Мендо

6

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, надайте елементи матриці як аргументи або спробуйте в Інтернеті .


5

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

Спробуйте в Інтернеті


3
+1 за flatMap(): p
Арнольд

: DI думаю, що це перший раз, коли я використовував це для гольфу! З інтересу (і щоб дати мені ціль, коли я повернусь до цього), яка була ваша оцінка, коли ви її спробували?
Кудлатий

Не отримав ні хвилини, щоб повернутися до цього сьогодні. Сподіваюсь, це означає, що завтра я зможу почати спочатку з абсолютно свіжими очима.
Кудлатий

Я розмістив своє рішення.
Арнольд

5

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

Спробуйте в Інтернеті!

Він створює матрицю 4х4 (яка допомогла мені візуалізувати речі), простежує її з 0, потім починається з 16 і шукає оточуючі "палі" для наступних найбільших тощо.

Після завершення він видає попередження, але це не має жодного наслідку і не змінює результат.

EDIT: -4 байти шляхом стискання ініціалізації матриці в 1 рядок.

EDIT: -1 завдяки Роберту Хакену

EDIT: -13 байт, що поєднує пропозиції Джузеппе та Робіна Райдера.


Ви можете зберегти один байт, змінивши r==16для r>15.
Роберт Хакен

1
117 байт - змініть його на функцію, що приймає матрицю, і зробіть деякий псевдонім з which.
Джузеппе

2
112 байтів покращується за пропозиціями @Giuseppe: ви можете зберігати mяк логічне замість цілого числа, і тому вам потрібно зателефонувати лише whichодин раз, а не двічі.
Робін Райдер

110 байт, використовуючи гольф @RobinRyder і возиться зі стисканням матриці суміжності сусідства.
Джузеппе

1
@ Sumner18 X%o%Y- псевдонім для outer(X,Y,'*'). outerє однією з найзручніших функцій навколо, оскільки вона може функціонувати як функція "трансляції" Octave / MATLAB / MATL з aribtrary (векторизованими) операторами. Дивіться тут ; також корисно в рідкісних випадках, kroneckerщо пов'язане на цій сторінці.
Джузеппе

4

Вугілля деревне , 47 байт

EA⭆ι§αλ≔QθW›θA«≔⌕KAθθJ﹪θ⁴÷θ⁴≔⌈KMθA»≔ΣEKA⌕αιθ⎚Iθ

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

EA⭆ι§αλ

Перетворіть вхідні числа в алфавітні символи (A = 0 .. Q = 16) і роздрукуйте їх у вигляді сітки 4x4.

≔Qθ

Почніть з їжі Q, тобто 16.

W›θA«

Повторіть, поки є що їсти.

≔⌕KAθθ

Знайдіть, де стопка. Це лінійний вигляд у порядку основного рядка.

J﹪θ⁴÷θ⁴

Перетворити на координати та перейти до цього місця.

≔⌈KMθ

Знайдіть найбільшу сусідню купу.

Їжте поточну купу.

≔ΣEKA⌕αιθ

Перетворіть палі назад на цілі числа і візьміть суму.

⎚Iθ

Очистіть полотно та виведіть результат.


3

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

Менш тестовий сценарій для гольфу:

$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 до не-нульового максимуму. І звести нанівець (Голодна миша їсть його).

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

По-третє , сума решти паль.


3

SAS, 236 219 байт

Введення на перфокартах, по одному рядку на сітці (розділеному пробілом), вихід, надрукований у журнал.

Цей виклик дещо ускладнюється деякими обмеженнями масивів у SAS:

  • Немає можливості повернути індекси рядків і стовпців відповідного елемента з багатовимірного масиву кроків даних - ви маєте трактувати масив як 1-d, а потім опрацювати їх для себе.
  • Якщо ви виходите за межі, SAS видає помилку і зупиняє обробку, а не повертає null / zero.

Оновлення:

  • Видалене 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>
    ; 

Безумовно:

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

1
+1 за використання перфокартів у PPCG :)
GNiklasch

3

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 цілих чисел.

Трохи невольф

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

3

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

Так, я ніколи б не наблизився до цього!
Кудлатий


3

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

не могли б ви не int r = c = X = Y = 0, R = 4, M = 1, x, y; ?
Serverfrog

@Serverfrog Боюся, що це неможливо при оголошенні змінних на Java. Ваша пропозиція дала мені ідею зберегти байт, хоча, використовуючи int r,c,R=4,M=1,x,y,X,Y;for(r=c=X=Y=0;, тому дякую. :)
Кевін Кройсейсен

1

J, 82 байти

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

Спробуйте в Інтернеті!

Я планую гольф це більш завтра, і , можливо , написати більше J-Робочі рішення , подібне до цього одному , але я вирішив спробувати сплющений підхід , так як я не зробив цього раніше.


Вам дійсно потрібно саме ліве ]в g?
Гален Іванов

1
Дякую Гален, ти маєш рацію. Це найменше проблем із цим кодом :) У мене набагато краще рішення, яке я буду реалізовувати, коли встигну.
Йона

1

Червоний , 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 Red), тому я все-таки публікую його ...

Більше читати:

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
]

1

Желе ,  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

Ага так, потужності не вистачає!
Джонатан Аллан

2
@Arnauld - нарешті отримав трохи часу для гри в гольф: D Це повинно працювати, але буде (занадто повільним) для бігу в TIO з тестовим випадком, який ви використовували раніше.
Джонатан Аллан

Чи не могли б дати вам відгук? Це працює, має повне і чітке пояснення, а також є найкоротшим записом на даний момент.
Джонатан Аллан

Я підтримав, але, зважаючи на O ((n ^ 2)! Цієї відповіді, я хотів би, щоб виклик вимагав багаточленного часу.
lirtosiast

1

Не моя найкраща робота. Потрібно зробити певні вдосконалення, деякі, мабуть, є основними для використовуваного алгоритму - я впевнений, що це можна покращити, використовуючи лише один 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
}


О так, дивна річ, яку я помітив, це те, що намагаються зробити (array|sort)[-1]замість того, щоб Measure -maxпрацювати в PSv5, але отримували неправильні результати по суті. Не знаю чому.
Веська

Так, це дивно. Я тестував його, (0..10|sort)[-1]але він повертає 10 на PSv5, але 9 на PS Core. Це тому, що вона трактує її в лексикографічному порядку замість числового. Сором, що.
Джефф Фріман

Класичний Microsoft змінює важливі речі.
Веська

Я згоден у цьому випадку. Я не впевнений, чому PS Core Sort кидає масив int32 до масиву рядків. Але це відштовхується від гніту, тож я віддамся. Дякую за реструктуризацію!
Джефф Фріман

1

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, а потім:

  • Якщо до нього є сусіднє додатне число, повторіть місце розташування найбільшого суміжного числа

  • В іншому випадку поверніть суму чисел у масиві.


s(int*a){for(i=0;a[i]<16;++i);return g(a,i%4,i/4);}
RiaD

якщо g повертає з'їдену суму, вам не потрібно обчислювати її. Просто поверніть 16 * 17/2-г () наприкінці s
RiaD

Ви можете використовувати побітне чи замість цього, якщо це логічно чи?
RiaD



1

Додайте ++ , 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=[37105681213159114141162]

x1x16M4x4

  • f(x,M)4x4xMx=16Mf(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

016120(1+2++14+15)

0

0

  • f(y,m)16Mx:=(4,3)
  • g(x,y)0
  • h(x,y)160
  • tm

Нарешті, виведіть t , тобто інші, не зібрані значення.


1

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

Спробуйте в Інтернеті!


1

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}

Супер пошарпане рішення. Приймає введення як сплющений масив.

Спробуйте в Інтернеті!



1

K (нг / к) , 49 байт

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

Спробуйте в Інтернеті!

input ( x) - це 1d масив

(+!4 4)!x словник, який відображає пари координат до значень x

h:: призначити глобальну змінну h

*> ключ, що відповідає максимальному значенню

{ }\ повторювати до конвергенції, збираючи проміжні значення у списку

h[,x]:0 нуль поточного положення

+x+0,'1-!3 3 позиції сусідів

( )#hвідфільтруйте їх hяк менший словник

*>який сусід має максимальне значення? вона стає поточною позицією для нової ітерації

+/hнарешті, поверніть суму hзалишилися значень


1

Мова Вольфрама (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)&

Спробуйте в Інтернеті!

Для цього потрібен 2D масив, прокладка його з кожної сторони, а потім негайно його розрівнювання, щоб нам не довелося витрачати байтинг на індексацію. Єдина вартість цього - Join@@сплющити. Після цього він продовжується, як показано нижче.

124-байтна версія для двовимірного масиву: спробуйте в Інтернеті!

Переважно моя власна робота, дещо похідна від 149-байтної відповіді J42161217 .

Безумовно:

(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.
)&
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.