Głodna Mysz

85

Szesnaście stosów sera układa się na kwadracie 4x4. Są oznaczone od do . Najmniejszy stos to a największy .116116

Głodna mysz jest tak głodna, że ​​zawsze trafia prosto na największy stos (tj. ) i zjada ją od razu.16

Następnie trafia na największy sąsiedni stos i szybko go zjada. (Tak ... Jest naprawdę głodny.) I tak dalej, dopóki nie będzie już stosu sąsiadów.

Stos może mieć do 8 sąsiadów (poziomo, pionowo i po przekątnej). Nie ma żadnego zawijania.

Przykład

Zaczynamy od następujących stosów sera:

37105681213159114141162

Głodna Mysz najpierw zjada , a następnie największy stos sąsiadów, którym jest .1611

37105681213159🐭41412

Następne ruchy to , , , , , , , , i w dokładnie takiej kolejności.131210815149673

🐭5412

Wokół Głodnej Myszy nie ma już sera, więc się tam zatrzymuje.

Wyzwanie

Biorąc pod uwagę początkową konfigurację sera, kod musi wydrukować lub zwrócić sumę pozostałych stosów, gdy głodna mysz przestanie je jeść.

W powyższym przykładzie oczekiwana odpowiedź to .12

Zasady

  • Ponieważ rozmiar macierzy wejściowej jest stały, możesz wziąć ją jako macierz 2D lub jednowymiarową.
  • Każda wartość od do gwarantuje pojawienie się dokładnie raz.116
  • To jest .

Przypadki testowe

[ [ 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
Arnauld
źródło
32
+1 za tę postać myszy
Luis Mendo,
2
... spraw, aby 103:[[9, 10, 11, 12], [1, 2, 7, 13], [6, 16, 4, 14], [3, 8, 5, 15]]
Jonathan Allan
9
Cóż za ładnie napisane wyzwanie! Będę pamiętać o najlepszych nominacjach.
xnor
9
Po błędnym odczytaniu byłem trochę smutny, że to nie był głodny łoś.
akozi
1
To wyzwanie przypomina mi mysz w programie labiryntowym dla komputera TX. Ta gra została napisana w latach 50. XX wieku, a według legendy txo był pierwszym tranzystorowym komputerem na świecie. Tak, wierz lub nie, ktoś pisał gry wideo w czasach twojego dziadka.
Walter Mitty,

Odpowiedzi:

11

Python 2 , 133 130 bajtów

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)

Wypróbuj online!

Pobiera spłaszczoną listę 16 elementów.

Jak to działa

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)
Bubbler
źródło
Ekspresję w sąsiedniej komórce a[i+x]for x in[-6,-5,-4,-1,1,4,5,6]można skrócić a[i+j+j/3*2-6]for j in range(9)(wpis zerowy jest nieszkodliwy). Python 3 z pewnością może działać krócej, zapisując na stałe bajtowanie o długości 8, ale ogólnie Python 2 może być lepszy.
xnor
1
Chociaż pętla wyściółka zerowy jest mądry, to wygląda to krócej wziąć listę 2D: a=[0]*5 for r in input():a=r+[0]+a. Być może istnieje jeszcze krótsze rozwiązanie do krojenia ciągów, które nie wymaga iteracji.
xnor
8

Python 2 , 111 bajtów

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)

Wypróbuj online!

Metody i przypadki testowe zaadaptowane z Bubbler . Pobiera płaską listę na STDIN.

Kod sprawdza, czy dwa płaskie wskaźniki ii jreprezentują dotykające się komórki, sprawdzając, czy zarówno różnica wierszy, jak i/4-j/4i różnica i%4-j%4między kolumnami mieszczą się dokładnie w przedziale od -2 do 2. Pierwsze przejście zamiast tego automatycznie sprawdza się pomyślnie, aby znaleźć największy wpis bez uwzględnienia przylegania.

xnor
źródło
8

MATL , 50 49 47 bajtów

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

Dane wejściowe to macierz, używana ;jako separator wierszy.

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

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
Luis Mendo
źródło
Idk MatLab, ale czy możesz trochę zaoszczędzić, jeśli naciśniesz -136 zamiast +136?
Tytus
@ Titus Hm Nie wiem jak
Luis Mendo
lub odwrotnie: Myślałem zamiast 1) push 136 2) push każdą zjedzoną wartość 3) zsumuj zjedzone wartości 4) odejmij od 136 -> 1) push 136 2) push negatywną zjedzoną wartość 3) zsumuj stos. Ale ponieważ oczywiście jest to tylko jeden bajt; prawdopodobnie nie ma zysku.
Tytus
@ Titus Ach, tak, myślę, że używa tej samej liczby bajtów. Potrzebuję też każdej zjedzonej wartości (nie jej ujemnej) dla ustalonej różnicy; zaprzeczanie musiałoby być zrobione na końcu
Luis Mendo
6

PHP, 177 174 171 bajtów

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;

Uruchom -nr, podaj elementy macierzy jako argumenty lub wypróbuj online .

Tytus
źródło
5

JavaScript, 122 bajty

Zrobiłem kilka błędnych zwrotów na tym i teraz zabrakło mi czasu na dalszą grę w golfa, ale przynajmniej działa. Wrócę jutro (lub, znając mnie, wieczorem w pociągu do domu!), Jeśli uda mi się znaleźć minutę.

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

Wypróbuj online

Kudłaty
źródło
3
+1 dla flatMap(): p
Arnauld
: Myslę, że pierwszy raz użyłem go do gry w golfa! Z braku zainteresowania (i aby dać mi cel, kiedy wrócę do tego), jaki był twój wynik, gdy próbowałeś?
Shaggy
Nie miałem dzisiaj minuty, aby wrócić do tego. Mam nadzieję, że to oznacza, że ​​jutro będę mógł zacząć od nowa ze świeżymi oczami.
Shaggy
Opublikowałem swoje rozwiązanie.
Arnauld
5

R , 128 124 123 112 110 bajtów

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

Wypróbuj online!

Tworzy matrycę 4x4 (która pomogła mi w wizualizacji rzeczy), uzupełnia ją zerami, a następnie zaczyna od 16 i wyszukuje otaczające „stosy” następnej największej itd.

Po zakończeniu generuje ostrzeżenie, ale nie ma znaczenia i nie zmienia wyniku.

EDYCJA: -4 bajty poprzez kompresję inicjalizacji macierzy do 1 linii.

EDYCJA: -1 dzięki Robertowi Hackenowi

EDYCJA: -13 bajtów łączących sugestie Giuseppe i Robin Ryder.

Sumner18
źródło
Możesz zapisać zmianę jednego bajtu r==16dla r>15.
Robert Hacken
1
117 bajtów - zmień go na funkcję pobierającą macierz i zrób aliasing za pomocą which.
Giuseppe,
2
112 bajtów poprawiających się według sugestii @Giuseppe: możesz zapisać mlogikę zamiast liczby całkowitej, a zatem wystarczy zadzwonić whichtylko raz zamiast dwa razy.
Robin Ryder
110 bajtów przy użyciu golfa @RobinRyder i bałaganie ze skompresowaniem macierzy sąsiedztwa sąsiedztwa.
Giuseppe
1
@ Sumner18 X%o%Yto alias dla outer(X,Y,'*'). outerjest jedną z najbardziej przydatnych funkcji, ponieważ może działać jako funkcja „broadcast” Octave / MATLAB / MATL z aribtrarnymi (wektoryzowanymi) operatorami. Zobacz tutaj ; Przydaje się także w rzadkich przypadkach, do kroneckerktórych prowadzi link na tej stronie.
Giuseppe
4

Węgiel drzewny , 47 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

EA⭆ι§αλ

Konwertuj liczby wejściowe na znaki alfabetyczne (A = 0 .. Q = 16) i wydrukuj je jako siatkę 4x4.

≔Qθ

Zacznij od zjedzenia Q, tj. 16.

W›θA«

Powtarzaj, dopóki jest coś do jedzenia.

≔⌕KAθθ

Znajdź, gdzie jest stos. Jest to widok liniowy w kolejności rzędów głównych.

J﹪θ⁴÷θ⁴

Konwertuj na współrzędne i przeskocz do tego miejsca.

≔⌈KMθ

Znajdź największy sąsiadujący stos.

Zjedz aktualny stos.

≔ΣEKA⌕αιθ

Konwertuj stosy z powrotem na liczby całkowite i weź sumę.

⎚Iθ

Wyczyść płótno i wydrukuj wynik.

Neil
źródło
3

PowerShell, 143 141 136 130 122 121 bajtów

$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

Skrypt testu mniej golfowego:

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

Wynik:

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

Wyjaśnienie:

Najpierw dodaj górną i dolną granicę 0 i utwórz tablicę jednowymiarową:

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

     ↓

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

Powershell zwraca, $nulljeśli spróbujesz uzyskać wartość za końcem tablicy.

Po drugie , pętla biggest neighbor pilerozpoczęła się od 16 do wartości niezerowych. I unieważnij (Głodna Mysz je).

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

Po trzecie , suma pozostałych stosów.

mazzy
źródło
3

SAS, 236 219 bajtów

Wprowadzanie na kartach dziurkowanych, po jednej linii na siatkę (oddzielone spacjami), wydruk na dzienniku.

To wyzwanie jest nieco skomplikowane ze względu na pewne ograniczenia tablic w SAS:

  • Nie ma sposobu na zwrócenie indeksów wierszy i kolumn pasującego elementu z wielowymiarowej tablicy data-step - musisz potraktować tablicę jako 1-d, a następnie samodzielnie ją opracować.
  • Jeśli przekroczysz granice, SAS zgłasza błąd i zatrzymuje przetwarzanie zamiast zwracać wartość zero / zero.

Aktualizacje:

  • Usunięto infile cards;oświadczenie (-13)
  • Użyto symbolu wieloznacznego a:zamiast definicji tablicy a1-a16(-4)

Gra w golfa:

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

Nie golfowany:

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;*/
użytkownik3490
źródło
1
+1 za użycie kart perforowanych w PPCG :)
GNiklasch
3

Haskell , 163 bajty

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

Wypróbuj online!

fFunkcja przyjmuje wejście jako listę 4 listami 4 liczb całkowitych.

Nieco golfa

-- 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 #)
Max Yekhlakov
źródło
3

JavaScript (ES7), 97 bajtów

Pobiera dane wejściowe jako spłaszczoną tablicę.

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

Wypróbuj online!

Skomentował

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
Arnauld
źródło
Tak, nigdy nie byłbym tak blisko!
Shaggy
3

Java 10, 272 248 bajtów

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

Komórki są sprawdzane tak samo jak w mojej odpowiedzi na wyzwanie Wszystkie pojedyncze ósemki .
-24 bajty dzięki @ OlivierGrégoire .

Wypróbuj online.

Wyjaśnienie:

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
Kevin Cruijssen
źródło
czy mógłbyś nie int r = c = X = Y = 0, R = 4, M = 1, x, y; ?
Serverfrog
@Serverfrog Obawiam się, że nie jest to możliwe przy deklarowaniu zmiennych w Javie. Twoja sugestia dała mi pomysł, aby zapisać bajt, używając int r,c,R=4,M=1,x,y,X,Y;for(r=c=X=Y=0;, więc dziękuję. :)
Kevin Cruijssen
1

J, 82 bajty

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

Wypróbuj online!

Planuję golfa to bardziej jutro, a może napisać więcej J-owski rozwiązanie podobne do tego jednego , ale pomyślałem, że spróbuję spłaszczoną podejście, ponieważ nie zrobił wcześniej.

Jonasz
źródło
Czy naprawdę potrzebujesz wejścia ]w lewo g?
Galen Iwanow
1
Dzięki Galen, masz rację. To najmniejszy problem z tym kodem :) Mam o wiele lepsze rozwiązanie, które zaimplementuję, kiedy będę miał czas.
Jonasz
1

Czerwony , 277 bajtów

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]

Wypróbuj online!

To naprawdę długie rozwiązanie i nie jestem z niego zadowolony, ale tyle czasu poświęciłem na jego naprawę w TIO (najwyraźniej istnieje wiele różnic między stabilnymi wersjami Reda dla Win i Linuksa), więc i tak to opublikuję ...

Bardziej czytelny:

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
]
Galen Iwanow
źródło
1

Galaretka ,  31 30  29 bajtów

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

Ponieważ metoda jest zbyt wolna, aby uruchomić ją w ciągu 60. roku życia, mysz zaczyna od 16niej 9i ogranicza jej zdolność do tego, że jest w stanie jeść tylko 9mniej. Wypróbuj online! (a więc tutaj je 9, 2, 7, 4, 8, 6, 3odejście 97).

W jaki sposób?

³œ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
Jonathan Allan
źródło
Ach tak, zestaw mocy to za mało!
Jonathan Allan,
2
@Arnauld - w końcu mam trochę czasu na grę w golfa: D To powinno działać, ale będzie (zdecydowanie) zbyt wolne, aby uruchomić w TIO z przypadkiem testowym, którego używałeś wcześniej.
Jonathan Allan,
Czy osoba, która głosowała na niższy głos, może przekazać jakieś uwagi? Działa to, ma pełne i jasne wyjaśnienie, a także jest obecnie najkrótszym wpisem.
Jonathan Allan
Poparłem głosowanie, ale biorąc pod uwagę O ((n ^ 2)!) Tej odpowiedzi, szkoda, że ​​wyzwanie nie wymagało wielomianu.
lirtosiast
1

Nie moja najlepsza praca. Należy wprowadzić pewne zdecydowane ulepszenia, niektóre prawdopodobnie fundamentalne w stosunku do zastosowanego algorytmu - jestem pewien, że można go ulepszyć za pomocą tylko int[], ale nie mogłem wymyślić, jak w ten sposób skutecznie wyliczyć sąsiadów. Chciałbym zobaczyć rozwiązanie PowerShell, które wykorzystuje tylko jednowymiarową tablicę!

PowerShell Core , 348 bajtów

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}

Wypróbuj online!


Bardziej czytelna wersja:

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
}
Jeff Freeman
źródło
O tak, dziwną rzeczą, którą zauważyłem, jest to, że próbowałem zrobić to (array|sort)[-1]zamiast Measure -maxdziałać w PSv5, ale uzyskiwałem nieprawidłowe wyniki w rdzeniu. Nie mam pojęcia dlaczego.
Veskah
Tak, to dziwne. Przetestowałem to na, (0..10|sort)[-1]ale zwraca 10 na PSv5, ale 9 na PS Core. Jest tak, ponieważ traktuje to w kolejności leksykograficznej zamiast numerycznej. Szkoda, że.
Jeff Freeman
Klasyczny Microsoft zmieniający ważne rzeczy.
Veskah
Zgadzam się w tym przypadku. Nie jestem pewien, dlaczego PS Core Sort rzuca tablicę int32 na tablicę ciągów. Ale to wpada w rant, więc zrobię dygresję. Dzięki za restrukturyzację!
Jeff Freeman
1

C (gcc), 250 bajtów

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

Wypróbuj online!

Uwaga: To przesłanie modyfikuje tablicę wejściową.

s()to funkcja do wywołania z argumentem zmiennej int[16](która jest taka sama w pamięci jak an int[4][4], co g()interpretuje ją jako).

s()znajduje lokalizację 16tablicy, a następnie przekazuje tę informację do g, która jest funkcją rekurencyjną, która przyjmuje lokalizację, ustawia liczbę w tej lokalizacji na 0, a następnie:

  • Jeśli obok niego znajduje się liczba dodatnia, powtórz z lokalizacją największej liczby sąsiedniej

  • W przeciwnym razie zwróć sumę liczb z tablicy.

pizzapanty184
źródło
s(int*a){for(i=0;a[i]<16;++i);return g(a,i%4,i/4);}
RiaD
jeśli g zwraca sumę zjedzonej, nie musisz obliczać w niej sumy.
Zwróć
czy możesz użyć bitowego lub zamiast tego, jeśli logiczne lub?
RiaD
211 bajtów
pułap pułapu
1

Dodaj ++ , 281 bajtów

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

Wypróbuj online!

O, to jest skomplikowane.

Sprawdź wszystkie przypadki testowe

Jak to działa

Do tego wyjaśnienia użyjemy danych wejściowych

M=[37105681213159114141162]

x1x16M4x4

  • f(x,M)4x4xMx=16Mf(x,M)=(4,3)

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

    To implementuje dwie funkcje pomocnicze:

    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

Wreszcie wyjście t , tzn. Pozostałe niezebrane wartości.

Cairney Coheringaahing
źródło
1

C # (.NET Core) , 258 bajtów

Bez LINQ. Korzystanie z System.Collections.Generic służy do formatowania po - funkcja tego nie wymaga.

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

Wypróbuj online!

Destroigo
źródło
1

Perl 6 , 151 136 126 125 119 bajtów

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

Super odrapane rozwiązanie. Pobiera dane wejściowe jako spłaszczoną tablicę.

Wypróbuj online!

bb94
źródło
1

Perl 5 -MList::Util=sum -p , 137 bajtów

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

Wypróbuj online!

Xcali
źródło
1

K (ngn / k) , 49 bajtów

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

Wypróbuj online!

input ( x) jest tablicą 1d

(+!4 4)!x słownik, który odwzorowuje pary współrzędnych na wartości x

h:: przypisać do zmiennej globalnej h

*> klucz odpowiadający wartości maksymalnej

{ }\ powtarzaj do zbieżności, zbierając wartości pośrednie na liście

h[,x]:0 wyzeruj bieżącą pozycję

+x+0,'1-!3 3 pozycje sąsiadów

( )#hodfiltruj je hjako mniejszy słownik

*>który sąsiad ma maksymalną wartość? staje się bieżącą pozycją dla nowej iteracji

+/hna koniec zwróć sumę hpozostałych wartości

ngn
źródło
1

Wolfram Language (Mathematica) , 124 115 bajtów

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

Wypróbuj online!

To zajmuje tablicę 2D, wstawia ją z każdej strony, a następnie natychmiast spłaszcza, abyśmy nie musieli wydawać bajtów na indeksowanie. Jedynym kosztem tego jest Join@@spłaszczenie. Następnie postępuje jak poniżej.

Wersja 124-bajtowa dla tablicy 2D: Wypróbuj online!

Głównie moja własna praca, nieco wywodząca się ze 149-bajtowej odpowiedzi J42161217 .

Nie golfowany:

(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.
)&
lirtosiast
źródło