Уявіть, що підпал ходить по місту і збирає жертв за дуже специфічним малюнком (Або, як варіант, уявіть, як бджола літає по саду і збирає свої квіти, щоб поленізувати за дуже конкретною схемою ). Скажімо, місто - це матриця N × N , де N - ціле число, що перевищує або дорівнює 2 . Підпал починається з лівого верхнього кута і послідовно встановлює перед ними M плями будинку (де M - номер будинку, в якому вони зараз перебувають), змінюючи напрямок, в якому рухається після кожної пожежі, в порядку Схід ⟶ Південь ⟶ Захід ⟶ Північ ⟶ Схід ⟶ Південь… і так далі. колисковапідпалу - це значення М, яке змушує їх виїхати з міста (тобто останнього будинку, який вони відвідують перед тим, як зупинити гидоту). Це легше зрозуміти на прикладі. Візьмемо для прикладу таку матрицю:

3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 1

• Починаємо з лівого верхнього кута, тому M = 3 ( Xпозначає поточну та попередню позиції підпалу):

  X 2 3 2 7
  3 1 4 1 6
  2 5 3 1 1
  4 4 3 2 4
  1 1 1 1 1
  

• Відповідно до відомого порядку, спочатку йде на схід М (3) плями і приземляється на 2, тому M відповідно змінюється:

  X 2 3 X 7
  3 1 4 1 6
  2 5 3 1 1
  4 4 3 2 4
  1 1 1 1 1
  

• Потім він іде на південь, 2 плями, і М зараз 1 :

  X 2 3 X 7
  3 1 4 1 6
  2 5 3 X 1
  4 4 3 2 4
  1 1 1 1 1
  

• Тепер він рухається на 1 місце на Захід і М стає 3 :

  X 2 3 X 7
  3 1 4 1 6
  2 5 XX 1
  4 4 3 2 4
  1 1 1 1 1
  

• Після того, як він рухається на 3 плями на північ, він виходить з міста! Тому 3 - це колискова підпал:

      Х
  X 2 3 X 7
  3 1 4 1 6
  2 5 XX 1
  4 4 3 2 4
  1 1 1 1 1
  

З огляду на матрицю N × N (ви можете необов'язково взяти і N як вхідний), знайдіть колискову підпалу. Я написав програму, за допомогою якої можна генерувати більше тестових випадків та візуалізувати шлях підпалу: Спробуйте в Інтернеті!

• Можна припустити , що палій робить є колискову (тобто, на самому ділі може вийти з матриці).
• Матриця буде містити лише додатні цілі числа, менші або рівні 9 (цифр), для простоти. Рішення, що обробляють будь-яке додатне ціле число, вітаються повністю.
• Зауважте, що підпал може приземлитися на місці, де вони вже згоріли, якщо сенс, в який вони рухаються, відрізняється від першого разу. У такому сценарії просто візьміть значення цього елемента і перемістіть знову, як зазвичай.
• Ви можете змагатися з будь-якою мовою програмування і можете приймати введення та надавати висновок будь-яким стандартним методом , беручи до уваги, що ці лазівки заборонені за замовчуванням. Це код-гольф , тому найкоротше подання (у байтах) на кожну мову виграє.

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

-------------
9 2 3
1 7 2
8 7 6

Колискова: 9
-------------
2 1 2 1
3 1 1 2
1 2 2 1
1 1 1 3

Колискова: 2
-------------
3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 1

Колискова: 3
-------------
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2

Колискова: 2
-------------
3 2 1 2 1 1 1
2 3 2 3 2 1 1
2 1 1 1 3 1 2
3 1 1 1 1 1 1
4 5 2 3 1 1 1
1 2 1 2 1 2 2
1 2 2 3 2 1 2

Колискова: 3
-------------

Матриці в іншому форматі:

[[9, 2, 3], [1, 7, 2], [8, 7, 6]]
[[2, 1, 2, 1], [3, 1, 1, 2], [1, 2, 2, 1], [1, 1, 1, 3]]
[[3, 2, 3, 2, 7], [3, 1, 4, 1, 6], [2, 5, 3, 1, 1], [4, 4, 3, 2, 4], [ 1, 1, 1, 1, 1]]
[[1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2]]
[[3, 2, 1, 2, 1, 1, 1], [2, 3, 2, 3, 2, 1, 1], [2, 1, 1, 1, 3, 1, 2], [ 3, 1, 1, 1, 1, 1, 1], [4, 5, 2, 3, 1, 1, 1], [1, 2, 1, 2, 1, 2, 2], [1, 2, 2, 3, 2, 1, 2]]

П’ятий тестовий випадок дуже цікавий для візуалізації .

MATL , 32 байти

JQ6*`G5thYay&Zj3$)wyJ2@-^*+8M]b&

Спробуйте в Інтернеті! Або перевірити всі тестові випадки .

Як це працює

Вхідна матриця прокладена рамкою з п'яти нулів, наприклад

3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 1

стає

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 3 2 3 2 7 0 0 0 0 0
0 0 0 0 0 3 1 4 1 6 0 0 0 0 0
0 0 0 0 0 2 5 3 1 1 0 0 0 0 0
0 0 0 0 0 4 4 3 2 4 0 0 0 0 0
0 0 0 0 0 1 1 1 1 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

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

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

Координати фактично зберігаються як складне число, так, наприклад, (6,6)стає 6+6j. Таким чином чотири циклічні напрямки можуть бути реалізовані як сили уявної одиниці. Відповідна потужність ( j, 1, -jабо -1) множаться на записи для читання , щоб отримати складне переміщення , яке використовується для відновлення координат.

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

JavaScript (ES6), 70 68 байт

m=>(g=d=>(n=(m[y]||0)[x])?g(--d&3,x-=d%2*(y+=--d%2*n,L=n)):L)(x=y=0)

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

Прокоментував

m => (                        // given m = input matrix
  g = d =>                    // g = recursive function taking the direction d
    (n = (m[y] || 0)[x]) ?    // let n be the content of the current cell; if it's defined:
      g(                      //   do a recursive call:
        --d & 3,              //     with the next direction (0 = E, 3 = S, 2 = W, 1 = N)
        x -=                  //     update x by subtracting ...
          d % 2 * (           //       ... ((d - 1) % 2) * n
            y += --d % 2 * n, //       and update y by adding ((d - 2) % 2) * n
            L = n             //       save n into L
          )                   //     end of x update
      )                       //   end of recursive call
    :                         // else:
      L                       //   stop recursion and return L
)(x = y = 0)                  // initial call to g() with x = y = d = 0

Враховуючи, що ознака модуля в JS - це дивіденд, напрямок оновлюється таким чином:

 d | d' = --d&3 | dx = -(d%2)  | dy = --d%2 | direction
---+------------+--------------+------------+------------------
 0 |     3      | -(-1%2) = +1 | -2%2 =  0  | (+1,  0) = East
 3 |     2      | -( 2%2) =  0 |  1%2 = +1  | ( 0, +1) = South
 2 |     1      | -( 1%2) = -1 |  0%2 =  0  | (-1,  0) = West
 1 |     0      | -( 0%2) =  0 | -1%2 = -1  | ( 0, -1) = North

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

ＰＳ↶ＷＫＫ«≔ιθ×Ｉι¶↷»⎚θ

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

ＰＳ

Друкуйте рядок введення, але не переміщуйте положення друку.

↶

Поверніть шарнір вліво, щоб напрямок друку тепер був вгору.

ＷＫＫ«

Повторіть, поки у позиції друку є символ.

≔ιθ

Збережіть символ у змінній.

×Ｉι¶

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

↷»

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

Ｆ⟦ωθ⟧¿ιι⎚

На жаль, у нас все ще є вкладення, що захаращує наше полотно, і ще більше, на жаль, якщо ми очищаємо полотно, ми також очищаємо нашу змінну. Отже, це трохи хитрість: список порожнього рядка та змінної перекинуто на петлю. При першому проходженні циклу змінна циклічна порожня, тож чистка змінної циклу та циклу та змінна результатів очищаються. Але петля не закінчена! На другому проході циклу ми все ще отримуємо доступ до нашої змінної, ретельно збереженої в нашому циклі списку. Залишається просто роздрукувати його.

⎚θ

Очистіть полотно та надрукуйте збережену змінну. (Завдяки @ ASCII - лише за виправлення деревного вугілля.)

Python 2 , 85 84 байт

a=input();x=y=e=0;d=1
while-1<y<len(a)>x>=0:v=a[y][x];x+=v*d;y+=e*v;d,e=-e,d
print v

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

Порада про капелюх містеру Xcoder на 1 байт.

Вугілля , 50 49 46 34 33 26 байт

ＮθＥθＳＭθ↑ＷＫＫ«ＭＩι✳⊗Ｌυ⊞υι»⎚⊟υ

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

Посилання на багатослівну версію коду

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

Будь-які способи збити байти бажані та бажані, оскільки я не гарний гольфіст у Вугільному вугіллі!

-12 байт завдяки @Neil! -1 байт завдяки @ ASCII! -7 байт завдяки @ ASCII (змінив помилку, яка зробила Clearскидання змінних)

Червоний , 145 байт

func[b][h:[0 1 0 -1 0]x: y: 1 i: 0
until[y: h/(i: i % 4 + 1) *(t: b/(y)/(x)) + y x: h/(i + 1) * t + x none = b/(y) or(x < 1 or(x > length? b))]t]

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

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

f: func[b][
    h: [0 1 0 -1 0]                                ; step lengths (combined for x and y) 
    x: y: 1                                        ; starting coords (1,1)
    i: 0                                           ; step counter 
    until[
        y: h/(i: i % 4 + 1) * (t: b/(y)/(x)) + y   ; next y; t stores the lullaby
        x: h/(i + 1) * t + x                       ; next x
        none = b/(y) or (x < 1 or (x > length? b)) ; until x or y are not valid indices
    ]
    t                                              ; return the lullaby
]

Perl 6 , 62 байти

{$^w;$^m[0,{$_+$m[$_]*(1,$w,-1,-$w)[$++%4]}...{!$m[$_]}][*-2]}

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

Приймає матрицю як плоский список і ширину.

Чистота , 141 байт

import StdEnv
d=[0,1,1,0,0,-1,-1,0:d]
$m[x,y]n[a,b:l]#r=size m
#u=x+a*n
#v=y+b*n
|0>u||0>v||u>=r||v>=r=n= $m[u,v]m.[u,v]l
?m= $m[0,0]m.[0,0]d

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

Визначає функцію ? :: {#{#Int}} -> Int, беручи безбоксированний масив незаміщених масивів цілих чисел і повертаючи результат.

Java 8, 121 байт

m->{int l=m.length,x=0,y=0,f=0,r=0;for(;x*y>=0&x<l&y<l;x+=f<1?r:f==2?-r:0,y+=f==1?r:f>2?-r:0,f=++f%4)r=m[y][x];return r;}

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

Альтернатива з тим самим 121 байтовим числом байтів:

m->{int l=m.length,x=0,y=0,f=0,r=0;try{for(;;x+=f<1?r:f==2?-r:0,y+=f==1?r:f>2?-r:0,f=++f%4)r=m[y][x];}finally{return r;}}

Використовуйте спробуйте, нарешті, замість того, щоб перевірити, чи x,yкоордината все ще знаходиться в межах.

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

Пояснення:

m->{                   // Method with integer-matrix parameter and integer return-type
  int l=m.length,      //  Dimensions of the matrix
      x=0,y=0,         //  x,y coordinate, starting at [0,0]
      f=0,             //  Direction-flag, starting at 0 (east)
      r=0;             //  Result-integer
  for(;x*y>=0&x<l&y<l  //  Loop as long as the x,y coordinates are still within bounds
      ;                //    After every iteration:
       x+=f<1?         //     If the direction is east:
           r           //      Increase the `x` coordinate by `r`
          :f==2?       //     Else-if the direction is west:
           -r          //      Decrease the `x` coordinate by `r`
          :            //     Else (it's north/south):
           0,          //      Leave the `x` coordinate the same
       y+=f==1?        //     If the direction is south:
           r           //      Increase the `y` coordinate by `r`
          :f>2?        //     Else-if the direction is north:
           -r          //      Decrease the `y` coordinate by `r`
          :            //     Else:
           0,          //      Leave the `y` coordinate the same
       f=++f%4)        //     Go to the next direction (0→1→2→3→0)
    r=m[y][x];         //   Set `r` to the value of the current cell
  return r;}           //  Return the last `r` before we went out of bounds

Perl 5 , 92 байти

sub b{1while eval join'&&',map{/./;map"(\$$_$&=".'$n=$_[$y][$x])'.$',x,'y'}'+<@_','->=0';$n}

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

Як?

Набір вкладених карт і з'єднання виробляють це:

($x+=$n=$_[$y][$x])<@_&&($y+=$n=$_[$y][$x])<@_&&($x-=$n=$_[$y][$x])>=0&&($y-=$n=$_[$y][$x])>=0

який потім оцінюється, щоб визначити, чи закінчується цикл. Оскільки булева оцінка оцінюється зліва направо, значення $nфактично змінюється (до) чотири рази під час оцінки. Оскільки булеві логічні коротке замикання в Perl, значення $nколишньої колиші, коли цикл виходить.

Python 3 , 85 84 байт

xcoder: -1 (я ніколи не пам’ятаю трюк + ~)

def f(x):
 r=c=0
 while-1<r:d=x[r][c];r,c=len(x)-c+~d,r;x=[*zip(*x)][::-1]
 return d

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

Замість того, щоб рухатися в різних напрямках (E, S, W, N), це рішення завжди рухається на схід і обертає сітку проти годинникової стрілки після кожного руху. Після обертання, що був останній стовпець, це перший рядок, тож якщо індекс рядка менший за нуль, це означає, що ми бігли з дошки.

Сітківка , 161 байт

.
 $.%`*_#$&*
(?<=(.+¶)+|^)
A ¶A$#1*
~(K`{`^X\1YZ¶1S$4¶1XYZ¶2$4$2$4$3¶2XYZ¶3S¶3XY\1Z¶S
X
(_$*)(A_$*)
Y
( _$*)
Z
(?=\n\D$*\2\b.$*\3#(_+))
)`S
$$4$$2$$3
L$0`_+
$.0

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