Фритюрница симулятор

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 для еды. Ваша функция или программа должны добавить три слоя в виде 2, 3 и 4 вокруг 1, перезаписывая, таким образом, некоторые из 0. Тесто прилипает горизонтально и вертикально (но не по диагонали) к пище любой формы и размера, включая пончики (еда с отверстиями) и крошится (отдельные пиксели пищи), и ограничивается границами фритюрницы. Более ранние слои жидкого теста превращаются в корку и не затрагиваются более поздними.

Другими словами, сначала вы должны заменить все 0, которые находятся в окрестностях фон-Неймана 1s на 2s, затем заменить все 0 в окрестностях фон-Неймана 2s на 3s и, наконец, заменить все 0 в окрестностях фон-Неймана 3 с 4 с. Таким образом, числа 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 
— СПП
источник
4
Не могли бы вы привести пример прохождения, пожалуйста? Мне непонятно, когда и почему использовать 2, 3 или 4. (Я бы VTC неясно, но у меня есть молоток, и, похоже, я в меньшинстве)
— Shaggy
1
@ Shaggy Насколько я понимаю, цифры идентифицируют «слой». 1D пример: 000010000→ 000212000→ 003212300→043212340
— georgewatson
4
Спасибо, @georgewatson; похоже, ты прав. Это не ясно из спецификации, которая упоминает, что «жидкое тесто» должно только прилипать к еде, и более ранние слои жидкого теста не затрагиваются более поздними. Единственный способ определить это - расшифровать его из контрольных примеров.
— Shaggy
6
Следующим вызовом должен стать симулятор Friar.
— Волшебная Урна Осьминога
5
@ на самом деле ? (͡ ° ͜ʖ ͡ °)
— Урна магического осьминога

Ответы:

10

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

Аргумент командной строки: 3

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

Попробуйте онлайн!

3 повторите следующее преобразование трижды:

 s если ли с это эльф непустой

 < меньше чем

 × знак

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

 : тогда новое значение становится

  1+ один плюс

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

 ⋄ еще

  S значение остается неизменным ( S эльф)

— Адам
источник
Разве это не должно быть 15 байтов (14 + 1 для аргумента 3)? Впервые вижу Stencil , но если я правильно понимаю, это расширение для Dyalog APL, чтобы использовать матрицы? Также, крошечное замечание: заглавная буква N в начале Neumannдолжна быть жирной, а не маленькой в ​​конце в вашем объяснении. :)
— Кевин Круйссен
1
Что ж, новейший консенсус, по-видимому, указывает на то, что различные конфигурации одного языка должны учитываться как отдельные языки, но я добавлю его
— Adám
1
@KevinCruijssen Stencil можно использовать в качестве инструмента Dyalog APL для простых клеточных автоматов, но он также сам по себе является языком игры в гольф. Действительно, чей-то код может нуждаться в модификации при переходе между использованием инструмента и языком игры в гольф.
— августа
1
@KevinCruijssen Нет, жирный окончательный N является намеренным. Смотрите документацию , которая Трафарет использует первые и последние буквы Муром и фон Нейман как мнемоники для и без себя, и использует в нижнем регистр и верхний регистр , как мнемоники для подсчета не-стеклотары и фактического списка элементов.
— августа
@KevinCruijssen Я также должен упомянуть, что Stencil - это просто интерфейс ⌺встроенного в Dyalog APL (называемый Stencil ). Смотрите также его документацию . Целый язык игры в гольф, построенный на одной встроенной системе! На самом деле, я сделал два других языка игры в гольф на основе встроенных Dyalog APL: QuadR и QuadS .
— августа
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[]
— Arnauld
источник
3

Python 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
« Когда я проснусь завтра утром и снова посмотрю на этот код, я, вероятно, буду чувствовать себя очень глупо». Вы бы лучше, так как я переиграл вас в Java. ; P
— Кевин Круйссен
1
@KevinCruijssen что D: не приемлемо. не должен быть побежден Java: P
— HyperNeutrino
1
Давайте победим Java: c - 196 байт .
— Мистер Кскодер
@ Mr.Xcoder yay спасибо: c: D
— HyperNeutrino
@ovs о, хорошо, ты!
— HyperNeutrino
3

Фортран 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 байтов сохранены с помощью странных старомодных циклов do.
  • Изменить 2: 5 байтов сохраненоany()
  • Редактировать 3: Сохранено 7 байтов, удалив ненужныеif
  • Редактировать 4: Сохранено 18 байт путем сокращения декларацииs
— georgewatson
источник
1

Perl, 63 байта

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

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

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

001
000
010

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

Вы можете использовать небольшой скрипт, как 

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

Измените все 0, смежные с 4, на 5.

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

Измените все 0, смежные с 3, на 4.

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.