Simulador de fritadeira

31

Sua tarefa é modelar os efeitos da massa em pedaços de comida. Por favor, adicione três camadas de crosta.

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

Um pouco de ajuda visual:

Mostrar snippet de código

A entrada é uma matriz booleana que representa a fritadeira: 0 para o óleo, 1 para a comida. Sua função ou programa deve adicionar as três camadas como 2s, 3s e 4s em torno dos 1s, substituindo assim alguns dos 0s. A massa adere horizontal e verticalmente (mas não na diagonal) a alimentos de qualquer formato ou tamanho, incluindo rosquinhas (alimentos com orifícios) e migalhas (alimentos isolados "pixels"), e é restrita aos limites da fritadeira. As camadas anteriores da massa se transformam em crosta e não são afetadas pelas posteriores.

Em outras palavras, primeiro você deve substituir todos os 0s nos bairros de von-Neumann de 1s por 2s, depois substituir todos os 0s nos bairros de von-Neumann de 2s por 3s e, finalmente, substituir todos os 0s nos bairros de von-Neumann. 3s com 4s. Assim, os números 2,3,4 representam uma quantidade maior que a distância de Manhattan até a célula 1 mais próxima.

A fritadeira terá tamanho de pelo menos 3 por 3 e conterá pelo menos um pedaço de comida. A E / S é flexível - use um formato de matriz adequado ao seu idioma. Espaço em branco extra é permitido, código mais curto desejável, brechas proibidas.

Mais testes:

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

Um pouco de ajuda visual:

Mostrar snippet de código

Obrigado @Tschallacka pelas visualizações.

code-golf  matrix 
— ngn
fonte
4
Você poderia fornecer um exemplo passo a passo, por favor? Não está claro para mim quando ou por que usar 2, 3 ou 4. (eu considerava o VTC pouco claro, mas agora tenho um martelo e parece que sou uma minoria)
— Shaggy
1
@ Shaggy Meu entendimento é que os números identificam a "camada". Um exemplo 1D: 000010000→ 000212000→ 003212300→043212340
— georgewatson
4
Obrigado, @georgewatson; parece que você está certo. Isso não está claro nas especificações, no entanto, que menciona que "massa" deve ficar apenas com alimentos e camadas anteriores de massa não são afetadas por outras. A única maneira de determinar isso é decifrá-lo dos casos de teste.
— Shaggy
6
Seu próximo desafio deve ser um simulador de frei.
— Magic Octopus Urn
5
@ngn realmente ? (͡ ° ͜ʖ ͡ °)
— Magic Octopus Urn

Respostas:

10

Estêncil : 1 + 14 = 15 bytes

Argumento da linha de comando: 3

Código: s<×⌈/N:1+⌈/N⋄S

Experimente online!

3 repita a seguinte transformação três vezes:

 s se se os s elfo é não-vazia

 < é menos do que

 × o signum de

 ⌈/N o máximo do von neuman N vizinhança

 : então o novo valor se torna

  1+ um mais

  ⌈/N o máximo do von neuman N vizinhança

 ⋄ outro

  S o valor permanece inalterado ( S elf)

— Adão
fonte
Isso não deveria ter 15 bytes (14 + 1 para o argumento 3)? A primeira vez que vi o Stencil , mas se entendi corretamente, é uma extensão para o Dyalog APL beneficiar matrizes? Além disso, uma pequena observação: o N maiúsculo no início de Neumanndeve estar em negrito em vez do pequeno no final de sua explicação. :)
— Kevin Cruijssen
1
Bem, o mais novo consenso parece indicar que várias configurações de uma única língua deve ser contado como línguas separadas, mas eu vou adicioná-lo
— Adám
1
O @KevinCruijssen Stencil pode ser usado como uma ferramenta Dyalog APL para autômatos celulares fáceis, mas também se destaca por si só como uma linguagem de golfe. De fato, o código de uma pessoa pode precisar de modificação ao passar entre o uso da ferramenta e o idioma do golfe.
— Adám 01/02/19
1
@KevinCruijssen Não, o N final ousado é intencional. Consulte a documentação em que o Stencil usa as primeiras e últimas letras de moore e von neumann como mnemônicos para com e sem self e usa letras minúsculas e maiúsculas como mnemônicos para a contagem de não-vazios e a lista real de elementos.
— Adám 01/02/19
@KevinCruijssen Também devo mencionar que o Stencil é apenas uma interface para o Dyalog APL ⌺(chamado Stencil ). Veja também a documentação . Toda uma linguagem de golfe construída em um único build-in! Na verdade, eu criei outras duas linguagens de golfe com base nos únicos recursos do Dyalog APL: QuadR e QuadS .
— Adám 01/02/19
10

Java 8, 271 269 247 210 202 198 193 bytes

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

Matrizes Java e dependentes de índice. Não é uma boa combinação para uma linguagem já detalhada para começar.

Modifica a matriz de entrada em vez de retornar uma nova.

Explicação:

Experimente online.

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)
— Kevin Cruijssen
fonte
3

JavaScript (ES6), 107 105 bytes

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

Casos de teste

Mostrar snippet de código

Comentado

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
fonte
3

Python 3 , 176 bytes

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)

Experimente online!

-18 bytes graças ao Sr. Xcoder
-20 bytes graças ao ovs

— HyperNeutrino
fonte
9
“ Quando eu acordar amanhã de manhã e olhar para esse código novamente, provavelmente me sentirei muito burro. ” É melhor que você, já que eu te enganei em Java. ; P
— Kevin Cruijssen
1
@KevinCruijssen what D: não aceitável. não deve ser derrotado por Java: P
— HyperNeutrino 01/02
1
Vamos vencer o Java: c - 196 bytes .
— Sr. Xcoder
@ Mr.Xcoder yay agradecimentos: c: D
— HyperNeutrino
@ ohs oh legal, ty!
— HyperNeutrino 01/02
3

Python 2 , 146 143 bytes

e=enumerate;l=input()
for y,f in e(l):
 for g,h in e(f):x=1+min(abs(y-a)+abs(g-c)for a,b in e(l)for c,d in e(b)if d==1);l[y][g]=x*(x<5)
print l

Experimente online!

— ovs
fonte
3

Fortran 95, 309 299 294 287 269 bytes

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

Fortran não é uma língua de golfe.

  • Editar: salvou 10 bytes usando loops estranhos e antiquados.
  • Editar 2: salvou 5 bytes comany()
  • Editar 3: salvou 7 bytes removendo um arquivo desnecessárioif
  • Editar 4: salvou 18 bytes diminuindo a declaração des
— georgewatson
fonte
1

Limpo , 157 bytes

import StdEnv,StdLib
t=transpose
z=zipWith
?n=n+sign n
f[0,h:l]=[?h:f[h:l]]
f[h,0:l]=[h,?h:f l]
f[h:l]=[h:f l]
f l=l
$l=z(z max)(t(map f(t l)))(map f l)


$o$o$

Experimente online!

Como uma função literal.

— Furioso
fonte
1

Perl, 63 bytes

Inclui +3 para 0ap

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

Forneça a matriz de entrada como um bloco de dígitos sem nova linha final.

001
000
010

para o exemplo 3x3. O formato de saída é o mesmo, um bloco de dígitos sem nova linha final.

Você pode usar um pequeno script como 

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

para remover convenientemente as novas linhas finais de um arquivo, se isso for difícil de fazer no seu editor favorito

— Ton Hospel
fonte
1

Retina , 93 87 84 bytes

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

Experimente online! Com base na minha resposta para Kill it With Fire . Edit: Salvo 6 9 bytes graças a @MartinEnder. Explicação:

1
4

Transforme todos os 1s em 4s.

3{

Repita o restante do programa (no máximo) 3 vezes.

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

Mude todos os 0s adjacentes a 4s em 5s.

T`1-5`d

Decrementar todos os dígitos.

Retina 0.8.2 , 100 94 bytes

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

Experimente online! Explicação:

1
3

Transforme todos os 1s em 3s.

{

Repita até que a saída não mude.

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

Mude todos os 0s adjacentes a 3s em 4s.

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

Se não houver 1s, diminua todos os dígitos.

— Neil
fonte
Você pode salvar alguns bytes usando um caractere como !(que não pode aparecer na entrada) em vez de (?!).
— Martin Ender
Graças @MartinEnder, que funciona para matá-lo com fogo também (e eu achei um campo de golfe de 2 bytes em separado enquanto eu estava lá!)
— Neil
1

Ruby , 183 158 146 bytes

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

Experimente online!

Usa o óbvio algoritmo de três laços. O fato de Ruby permitir indexação negativa em matrizes significa que não há como (que eu possa ver) fazer as verificações de limites. Chegar além do limite de uma matriz retorna nil, portanto, apenas as verificações de limite negativo são necessárias. A verificação dea[i+1][j] apenas precisa usar o operador de acesso seguro.

Eu também raspei alguns bytes usando uma variável para a[0] .

-12 mais bytes: use em .timesvez de (0...x).map(em três lugares).

->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
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.