Симулятор фритюрниці

31

Ваше завдання - моделювати вплив тіста на шматочки їжі. Будь ласка, додайте три шари кори.

[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], // in
 [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
 [0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0],
 [0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]
                   |
                   V
[[0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,2,1,2],
 [0,0,2,1,2,2,0,0,0,0,0,0,0,2,2,0,2,0],
 [0,0,2,1,1,1,2,0,0,0,0,0,2,1,1,2,0,0],
 [0,0,0,2,1,2,0,0,0,0,0,2,1,1,2,1,2,0],
 [0,0,0,0,2,0,0,0,0,0,0,0,2,1,1,1,2,0],
 [0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,0,0]]
                   |
                   V
[[0,0,3,2,3,3,0,0,0,0,0,0,0,3,3,2,1,2],
 [0,3,2,1,2,2,3,0,0,0,0,0,3,2,2,3,2,3],
 [0,3,2,1,1,1,2,3,0,0,0,3,2,1,1,2,3,0],
 [0,0,3,2,1,2,3,0,0,0,3,2,1,1,2,1,2,3],
 [0,0,0,3,2,3,0,0,0,0,0,3,2,1,1,1,2,3],
 [0,0,0,0,3,0,0,0,0,0,0,0,3,2,2,2,3,0]]
                   |
                   V
[[0,4,3,2,3,3,4,0,0,0,0,0,4,3,3,2,1,2], // out
 [4,3,2,1,2,2,3,4,0,0,0,4,3,2,2,3,2,3],
 [4,3,2,1,1,1,2,3,4,0,4,3,2,1,1,2,3,4],
 [0,4,3,2,1,2,3,4,0,4,3,2,1,1,2,1,2,3],
 [0,0,4,3,2,3,4,0,0,0,4,3,2,1,1,1,2,3],
 [0,0,0,4,3,4,0,0,0,0,0,4,3,2,2,2,3,4]]

Невелика наочна допомога:

Показати фрагмент коду

Вхід - булева матриця, що представляє фритюрницю: 0 для олії, 1 для їжі. Ваша функція або програма повинні додавати три шари у вигляді 2s, 3s і 4s навколо 1s, таким чином перезаписуючи деякі з 0s. Тісто дотримується горизонтально і вертикально (але не по діагоналі) до їжі будь-якої форми або розміру, включаючи пончики (їжа з отворами) і кришиться (ізольовані харчові «пікселі»), і обмежується межами фритюрниці. Більш ранні шари тіста перетворюються на скоринку і пізніші на них не впливають.

Іншими словами, спочатку слід замінити всі 0, які знаходяться у мікрорайонах фон-Неймана 1s, на 2s, потім замінити всі 0s у мікрорайонах von Neumann 2s на 3s, і, нарешті, замінити всі 0s у кварталах фон-Неймана 3s з 4s. Таким чином, числа 2,3,4 являють собою величину на одну більшу, ніж відстань Манхеттена до найближчої 1-комірки.

Фритюрниця буде розміром не менше 3-х-3 і міститиме принаймні один шматочок їжі. Введення / виведення гнучко - використовуйте формат матриці, відповідний для вашої мови. Дозволено додаткове пробіл, бажаний коротший код, забої заборонені.

Більше тестів:

 [[0,0,1], // in
  [0,0,0],
  [0,1,0]]

 [[3,2,1], // out
  [3,2,2],
  [2,1,2]]

 -

 [[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,1], // in
  [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],
  [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,0,0,0,0,0,0],
  [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,1,0,0,1,0,0,0],
  [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0],
  [0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0],
  [0,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0],
  [0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1],
  [0,0,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0],
  [0,0,0,1,0,0,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,1,1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0,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,1,0]]

 [[3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,3,3,4,3,3,3,4,4,4,3,2,1], // out
  [2,3,4,0,0,0,0,0,0,0,0,0,0,0,0,4,3,2,2,3,2,2,2,3,3,4,4,3,2],
  [1,2,3,4,0,0,0,0,0,0,0,0,0,0,4,3,2,1,1,2,1,1,1,2,2,3,4,4,3],
  [1,1,2,3,4,4,4,4,0,0,0,0,0,4,3,2,1,1,1,1,1,1,1,1,1,2,3,4,4],
  [2,2,3,4,4,3,3,3,4,0,0,0,4,3,2,1,1,2,1,1,1,1,1,2,2,1,2,3,4],
  [3,3,4,4,3,2,2,2,3,4,0,0,4,3,2,1,2,2,1,1,2,2,1,2,3,2,3,4,4],
  [4,4,4,3,2,1,1,1,2,3,4,0,4,3,2,1,1,2,1,2,3,3,2,2,2,3,4,3,3],
  [0,4,3,2,1,1,2,1,2,3,4,0,0,4,3,2,2,2,1,2,3,3,2,1,1,2,3,2,2],
  [4,3,2,1,1,2,2,1,2,3,4,0,0,0,4,3,3,3,2,3,4,4,3,2,2,3,2,1,1],
  [3,2,1,2,1,1,1,1,2,3,4,0,0,0,0,4,4,3,3,3,4,3,3,3,3,3,2,1,2],
  [4,3,2,1,2,2,1,2,3,4,0,0,0,0,0,4,3,2,2,2,3,2,2,3,4,4,3,2,3],
  [0,4,3,2,1,1,2,3,2,3,4,0,0,0,4,3,2,1,1,1,2,1,1,2,3,4,4,3,4],
  [0,0,4,3,2,2,3,2,1,2,3,4,0,0,0,4,3,2,2,2,3,2,2,3,4,4,3,2,3],
  [0,0,0,4,3,3,4,3,2,3,4,0,0,0,0,0,4,3,3,3,4,3,3,4,4,3,2,1,2],

Невелика наочна допомога:

Показати фрагмент коду

Дякую @Tschallacka за візуалізацію.

code-golf  matrix 
— ngn
джерело
4
Чи можете ви надати детальний приклад? Мені незрозуміло, коли або навіщо використовувати 2, 3 або 4. (Я б VTC як неясний, але у мене зараз молоток, і схоже, що я в меншості)
— Shaggy
1
@Shaggy Я розумію, що числа ідентифікують "шар". Приклад 1D: 000010000→ 000212000→ 003212300→043212340
— georgewatson
4
Спасибі, @georgewatson; схоже, ти маєш рацію. Однак це не зрозуміло з специфікації, де йдеться про те, що "тісто" повинне дотримуватися лише їжі, а більш ранні шари тіста не впливають на пізніші. Єдиний спосіб визначити це - розшифрувати його з тестових випадків.
— Shaggy
6
Наступним завданням повинен стати симулятор братів.
— Чарівний восьминога Урна
5
@ngn насправді ? (͡ ° ͜ʖ ͡ °)
— Чарівний восьминіг Урн

Відповіді:

10

Трафарет : 1 + 14 = 15 байт

Аргумент командного рядка: 3

Код: s<×⌈/N:1+⌈/N⋄S

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

3 повторити наступне перетворення тричі:

 s якщо ельф s не порожній

 < менше, ніж

 × знак

 ⌈/N максимум сусідства фон Неймана N

 : тоді стає новим значенням

  1+ один плюс

  ⌈/N максимум сусідства фон Неймана N

 ⋄ ще

  S значення залишається незмінним ( S elf)

— Адам
джерело
Чи не повинно це бути 15 байт (14 + 1 для аргументу 3)? Перший раз бачите трафарет , але якщо я правильно розумію, це розширення для Dyalog APL для отримання матриць? Також крихітне зауваження: Столиця N на початку Neumannмає бути жирним, а не малим у кінці у вашому поясненні. :)
— Кевін Круїссен
1
Що ж, найновіший консенсус вказує на те, що різні конфігурації однієї мови слід вважати окремими мовами, але я додам її
— Adám
1
@KevinCruijssen Трафарет можна використовувати як інструмент Dyalog APL для легких стільникових автомати, але він також виступає самостійно як мова для гольфу. Дійсно, код може потребувати змін під час переходу між використанням інструменту та мовою для гольфу.
— Adám
1
@KevinCruijssen Ні, сміливий фінал N навмисний. Дивіться документацію про те, що Stencil використовує першу та останню літери Мура та фон Неймана як мнемоніку для себе і без себе, а використовує малі та великі регістри як мнемоніки для підрахунку непросторостей та фактичного списку елементів.
— Adám
@KevinCruijssen Я також повинен зазначити, що Stencil - це лише інтерфейс до вбудованого Dyalog APL ⌺(який називається Stencil ). Дивіться також його документацію . Ціла мова про гольф, побудована на одній вбудованій! Насправді я створив дві інші мови для гольфу, засновані на одних вбудованих програмах Dyalog APL: QuadR та QuadS .
— Adám
10

Java 8, 271 269 247 210 202 198 193 байт

a->{for(int n=0,i,j,t,I,J;++n<4;)for(i=a.length;i-->0;)for(j=a[0].length;j-->0;)for(t=4;a[i][j]==n&t-->0;)try{a[I=t>2?i-1:t>1?i+1:i][J=t<1?j-1:t<2?j+1:j]+=a[I][J]<1?n+1:0;}catch(Exception e){}}

Матриці, що залежать від Java та індексів. Недобра комбінація для мови, що вже дієслівно, для початку.

Змінює вхідну матрицю замість повернення нової.

Пояснення:

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

a->{                            // Method with integer-matrix parameter and no return-type
  for(int n=0,i,j,t,I,J;++n<4;) //  Loop `n` in range [1, 4)
    for(i=a.length;i-->0;)      //   Inner loop over the rows
      for(j=a[0].length;j-->0;) //    Inner loop over the columns
        for(t=4;a[i][j]==n&     //     If the current cell contains the current `n`:
                t-->0;)         //      Loop `t` downwards in the range (4, 0]
          try{a[                //       Get the cell at a location relative to the current
                I=t>2?          //        If `t` is 3:
                 i-1            //         Take the cell above
                :t>1?           //        Else if `t` is 2:
                 i+1            //         Take the cell below
                :i][J=t<1?      //        Else if `t` is 0:
                 j-1            //         Take the cell left
                :t<2?           //        Else if `t` is 1:
                 j+1:j]         //         Take the cell right
              +=a[I][J]<1?      //       And if this cell contains a 0:
                 n+1:0;         //        Fill it with `n+1`
          }catch(Exception e){} //       catch and ignore ArrayIndexOutOfBoundsExceptions
                                //       (try-catch saves bytes in comparison to if-checks)
— Кевін Круїссен
джерело
3

JavaScript (ES6), 107 105 байт

f=(m,k=1)=>k<4?f(m.map((r,y)=>r.map((v,x)=>v|[-1,0,1,2].every(d=>(m[y+d%2]||0)[x+~-d%2]^k)?v:k+1)),k+1):m

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

Показати фрагмент коду

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

f = (m, k = 1) =>                  // given the input matrix m[] and starting with k = 1
  k < 4 ?                          // if this is not the 4th iteration:
    f(                             //   do a recursive call:
      m.map((r, y) =>              //     for each row r[] at position y in m[]:
        r.map((v, x) =>            //       for each cell v at position x in r[]:
          v |                      //         if v is non-zero
          [-1, 0, 1, 2].every(d => //         or each neighbor cell at (x+dx, y+dy), with:
            (m[y + d % 2] || 0)    //           dy = d % 2 --> [-1, 0, 1, 0]
            [x + ~-d % 2]          //           dx = (d - 1) % 2 --> [0, -1, 0, 1]
            ^ k                    //           is different from k  
          ) ?                      //         then:
            v                      //           let the cell unchanged
          :                        //         else:
            k + 1                  //           set the cell to k + 1
        )                          //       end of inner map()
      ),                           //     end of outer map()
      k + 1                        //     increment k for the next iteration
    )                              //   end of recursive call
  :                                // else:
    m                              //   stop recursion and return m[]
— Арнольд
джерело
3

Пітон 3 , 176 байт

f=lambda a,i=-2,e=enumerate:a*i or f([[E or int((6*max(len(a)>i>-1<j<len(a[i])and a[i][j]for i,j in((r+1,c),(r-1,c),(r,c+1),(r,c-1))))**.5)for c,E in e(R)]for r,R in e(a)],i+1)

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

-18 байт завдяки містеру Xcoder
-20 байт завдяки ов

— HyperNeutrino
джерело
9
" Коли я прокинусь завтра вранці і ще раз перегляну цей код, я, мабуть, почуватимусь дуже німим ". Вам краще бути, оскільки я перевершив вас на Яві. ; P
— Кевін Круїссен
1
@KevinCruijssen що D: не прийнятно. не повинні бити Java: P
— HyperNeutrino
1
Переможемо Java: c - 196 байт .
— Містер Xcoder
@ Mr.Xcoder так, дякую: c: D
— HyperNeutrino
@ovs ох приємно, ти!
— HyperNeutrino
3

Fortran 95, 309 299 294 287 269 ​​байт

subroutine f(a)
integer::a(:,:),s(2)
integer,allocatable::b(:,:)
s=shape(a)
allocate(b(0:s(1)+1,0:s(2)+1))
do1 k=0,3
do1 i=1,s(1)
do1 j=1,s(2)
b(i,j)=a(i,j)
if(any((/b(i+1,j)==k,b(i-1,j)==k,b(i,j+1)==k,b(i,j-1)==k/)).and.b(i,j)<1.and.k>0)b(i,j)=k+1
1 a(i,j)=b(i,j)
end

Фортран не є мовою для гольфу.

  • Редагувати: збережено 10 байт, використовуючи дивні старомодні петлі.
  • Редагувати 2: збережено 5 байт за допомогоюany()
  • Edit 3: Збережено 7 байт, видаливши непотрібнеif
  • Правка 4: Збережено 18 байт шляхом зменшення деклараціїs
— Джорджватсон
джерело
1

Perl, 63 байти

Включає +3 для 0ap

perl -0ape 's/0(?=$a|.{@{-}}$a)/$a+1/seg,$_=reverse while($a+=$|-=/
/)<4'

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

001
000
010

для прикладу 3x3. Формат виводу той самий, блок цифр без остаточного нового рядка.

Ви можете використовувати невеликий сценарій, як 

perl -i -0pe 's/\n*$//' <file>

зручно видаляти останні файли з файлу, якщо це важко зробити в улюбленому редакторі

— Тон Євангелія
джерело
1

Сітківка , 93 87 84 байт

1
4
3{m`(?<=^(.)*)0(?=4|.*¶(?>(?<-1>.)*)4|(?<=40|^(?(1)_)(?<-1>.)*4.*¶.*))
5
T`1-5`d

Спробуйте в Інтернеті! На основі моєї відповіді на " Вбивство вогнем" . Редагувати: Збережено 6 9 байт завдяки @MartinEnder. Пояснення:

1
4

Перетворіть усі 1 на 4.

3{

Повторіть решту програми (максимум) 3 рази.

m`(?<=^(.)*)0(?=4|.*¶(?>(?<-1>.)*)4|(?<=40|^(?(1)_)(?<-1>.)*4.*¶.*))
5

Змініть всі 0s, суміжні до 4s, на 5s.

T`1-5`d

Зменшення всіх цифр.

Сітківка 0,8.2 , 100 94 байт

1
3
{m`(?<=^(.)*)0(?=3|.*¶(?>(?<-1>.)*)3|(?<=30|^(?(1)_)(?<-1>.)*3.*¶.*))
4
T`1-4`d`^[^1]+$

Спробуйте в Інтернеті! Пояснення:

1
3

Перетворіть усі 1 на 3.

{

Повторюйте, поки вихід не зміниться.

m`(?<=^(.)*)0(?=3|.*¶(?>(?<-1>.)*)3|(?<=30|^(?(1)_)(?<-1>.)*3.*¶.*))
4

Змініть всі 0s, суміжні до 3s, на 4s.

T`1-4`d`^[^1]+$

Якщо немає 1, зменшіть усі цифри.

— Ніл
джерело
Ви можете зберегти деякі байти, скориставшись символом типу !(який не може відображатися у вводі) замість (?!).
— Мартін Ендер
@MartinEnder Дякую, що працює і для Kill it With Fire (і я знайшов окремий 2-байтовий гольф, поки я там був!)
— Ніл
1

Рубі , 183 158 146 байт

->a{3.times{|n|a.size.times{|i|r=a[i];r.size.times{|j|(r[j]<1&&[i>0?a[i-1][j]:0,a[i+1]&.at(j),j>0?r[j-1]:0,r[j+1]].include?(n+1))?r[j]=n+2:0}}};a}

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

Використовується очевидний алгоритм з трьох циклів. Той факт, що Ruby дозволяє негативне індексування до масивів, означає, що немає ніякого способу (що я бачу), щоб зробити перевірку меж. Досягнення за межі масиву повертається nil, тому необхідні лише негативні обмежені перевірки. Для перевірки a[i+1][j]просто потрібно використовувати оператор безпечного доступу.

Я також поголив кілька байт, використовуючи змінну для a[0].

-12 більше байтів: Використовуйте .timesзамість (0...x).map(у трьох місцях).

->a{
  3.times{|n|                    # For n from 0 to 2
    a.size.times{|i|             # For each row
      r=a[i];
      r.size.times{|j|           # For each column
        (r[j]<1 && [             # If the current cell is 0, and any of
            i>0 ? a[i-1][j] : 0, #     the cell to the north,
            a[i+1]&.at(j),       #     the cell to the south,
            j>0 ? r[j-1] : 0,    #     the cell to the west,
            r[j+1]               #     or the cell to the east
          ].include?(n+1)        #   are set to the previous value,
        ) ? r[j]=n+2 : 0         # Set this cell to the next value (or 0)
      }
    }
  };
  a                              # Return the modified array
}
— benj2240
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.