Simulador de freidora

31

Su tarea es modelar los efectos de la masa en los trozos de comida. Por favor agregue tres capas de corteza.

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

Un poco de ayuda visual:

Mostrar fragmento de código

La entrada es una matriz booleana que representa la freidora: 0 para el aceite, 1 para la comida. Su función o programa debe agregar las tres capas como 2s, 3s y 4s alrededor de los 1s, sobrescribiendo así algunos de los 0s. La masa se pega horizontal y verticalmente (pero no diagonalmente) a los alimentos de cualquier forma o tamaño, incluidas las rosquillas (alimentos con agujeros) y se desmorona ("píxeles" aislados de alimentos), y está restringida a los límites de la freidora. Las capas anteriores de masa se convierten en costra y no se ven afectadas por las posteriores.

En otras palabras, primero debe reemplazar todos los 0 que están en los vecindarios von-Neumann de 1s con 2s, luego reemplazar todos los 0s en los vecindarios von-Neumann de 2s con 3s, y finalmente reemplazar todos los 0s en los vecindarios von-Neumann de 3s con 4s. Por lo tanto, los números 2,3,4 representan una cantidad uno mayor que la distancia de Manhattan a la celda 1 más cercana.

La freidora tendrá un tamaño de al menos 3 por 3 y contendrá al menos una pieza de comida. I / O es flexible: utilice un formato de matriz adecuado para su idioma. Se permite espacio en blanco adicional, se desea un código más corto, se prohiben las lagunas.

Más pruebas:

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

Un poco de ayuda visual:

Mostrar fragmento de código

Gracias @Tschallacka por las visualizaciones.

code-golf  matrix 
— ngn
fuente
44
¿Podría proporcionar un ejemplo de tutorial, por favor? No está claro para mí cuándo o por qué usar 2, 3 o 4. (VTC no está claro, pero ahora tengo un martillo y parece que soy una minoría)
— Shaggy
1
@ Shaggy Entiendo que los números identifican la "capa". Un ejemplo 1D: 000010000→ 000212000→ 003212300→043212340
— georgewatson 01 de
44
Gracias, @georgewatson; Parece que tienes razón. Sin embargo, eso no está claro en la especificación, que menciona que "la masa" solo debe adherirse a los alimentos y las capas anteriores de la masa no se ven afectadas por las posteriores. La única forma de determinar eso es descifrarlo de los casos de prueba.
— Shaggy
66
Su próximo desafío debería ser un simulador de frailes.
— Urna de pulpo mágico
55
@ngn realmente ? (͡ ° ͜ʖ ͡ °)
— Urna de pulpo mágico

Respuestas:

10

Plantilla : 1 + 14 = 15 bytes

Argumento de línea de comando: 3

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

Pruébalo en línea!

3 repita la siguiente transformación tres veces:

 s si el s elfo no está vacío

 < es menos que

 × el signo de

 ⌈/N el máximo del barrio von neuman N

 : entonces el nuevo valor se convierte

  1+ uno más

  ⌈/N el máximo del barrio von neuman N

 ⋄ más

  S el valor permanece sin modificar ( S elf)

— Adán
fuente
¿No deberían ser 15 bytes (14 + 1 para el argumento 3)? La primera vez que veo Stencil , pero si entiendo correctamente, ¿es una extensión para Dyalog APL para beneficiar a las matrices? Además, una pequeña observación: la N mayúscula al comienzo de Neumanndebe estar en negrita en lugar de la pequeña al final en su explicación. :)
— Kevin Cruijssen
1
Bueno, el consenso más reciente parece indicar que varias configuraciones de un solo idioma deben contarse como idiomas separados, pero lo
— agregaré
1
@KevinCruijssen Stencil se puede utilizar como una herramienta Dyalog APL para autómatas celulares sencillos, pero también se destaca como lenguaje de golf. De hecho, el código de uno puede necesitar modificación cuando se mueve entre el uso de herramientas y el lenguaje de golf.
— Adám
1
@KevinCruijssen No, la N final en negrita es intencional. Consulte la documentación de que Stencil utiliza la primera y la última letra de Moore y von Neumann como mnemónicos para sí y sin sí mismo, y utiliza minúsculas y mayúsculas como mnemónicos para el recuento de elementos no vacíos y la lista real de elementos.
— Adám
@KevinCruijssen También debo mencionar que Stencil es solo una interfaz para el Dyalog APL ⌺incorporado (llamado Stencil ). Ver también su documentación . ¡Todo un lenguaje de golf construido sobre una sola incorporación! En realidad, he creado otros dos idiomas de golf basándome en los módulos integrados Dyalog APL: QuadR y QuadS .
— Adám
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){}}

Java y matrices dependientes del índice. No es una buena combinación para un lenguaje ya detallado, para empezar.

Modifica la matriz de entrada en lugar de devolver una nueva.

Explicación:

Pruébalo en línea.

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

JavaScript (ES6), 107105 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 prueba

Mostrar fragmento 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
fuente
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)

Pruébalo en línea!

-18 bytes gracias a Mr. Xcoder
-20 bytes gracias a ovs

— Hiperneutrino
fuente
99
" Cuando me levante mañana por la mañana y vuelva a ver este código, probablemente me sentiré muy tonto " . Será mejor que lo hagas, ya que te supere en Java. ; P
— Kevin Cruijssen
1
@KevinCruijssen qué D: no es aceptable. no debe ser derrotado por Java: P
— HyperNeutrino
1
Vamos a vencer a Java: c - 196 bytes .
— Sr. Xcoder
@ Mr.Xcoder yay gracias: c: D
— HyperNeutrino
@ovs oh bien, ty!
— HyperNeutrino
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

Pruébalo en línea!

— ovs
fuente
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 no es un lenguaje de golf.

  • Editar: guardado 10 bytes mediante el uso de do loops anticuados extraños.
  • Edición 2: guardado 5 bytes conany()
  • Edición 3: guardado 7 bytes eliminando un innecesarioif
  • Edición 4: 18 bytes guardados al reducir la declaración des
— georgewatson
fuente
1

Limpio , 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$

Pruébalo en línea!

Como una función literal.

— Οurous
fuente
1

Perl, 63 bytes

Incluye +3 para 0ap

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

Proporcione la matriz de entrada como un bloque de dígitos sin nueva línea final., P. Ej.

001
000
010

para el ejemplo 3x3. El formato de salida es el mismo, un bloque de dígitos sin nueva línea final.

Puedes usar un pequeño script como 

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

para eliminar convenientemente las nuevas líneas finales de un archivo si eso es difícil de hacer en su editor favorito

— Ton Hospel
fuente
1

Retina , 93 87 84 bytes

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

Pruébalo en línea! Basado en mi respuesta a Kill it With Fire . Editar: Guardado 6 9 bytes gracias a @MartinEnder. Explicación:

1
4

Convierte todos los 1s en 4s.

3{

Repita el resto del programa (como máximo) 3 veces.

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

Cambia todos los 0 adyacentes a 4 en 5.

T`1-5`d

Disminuya todos los 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]+$

Pruébalo en línea! Explicación:

1
3

Convierte todos los 1s en 3s.

{

Repita hasta que la salida no cambie.

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

Cambia todos los 0 adyacentes a 3 en 4.

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

Si no hay 1, disminuya todos los dígitos.

— Neil
fuente
Puede guardar algunos bytes utilizando un carácter como !(que no puede aparecer en la entrada) en lugar de (?!).
— Martin Ender
@MartinEnder Gracias, eso también funciona para Kill it With Fire (¡y encontré un campo de golf de 2 bytes separado mientras estaba allí!)
— Neil
1

Rubí , 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}

Pruébalo en línea!

Utiliza el algoritmo obvio de tres bucles. El hecho de que Ruby permita la indexación negativa en matrices significa que no hay forma (que pueda ver) de hacer las verificaciones de límites. Alcanzar más allá del límite de una matriz devuelve nil, por lo que solo son necesarias las comprobaciones negativas. La verificación a[i+1][j]solo necesita usar el operador de acceso seguro.

También reduje algunos bytes usando una variable para a[0].

-12 bytes más: uso en .timeslugar de (0...x).map(en tres 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
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.