Simulatore di friggitrice

31

Il tuo compito è quello di modellare gli effetti della pastella su pezzi di cibo. Aggiungi tre strati di 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]]

Un piccolo aiuto visivo:

Mostra snippet di codice

L'input è una matrice booleana che rappresenta la friggitrice: 0 per l'olio, 1 per il cibo. La tua funzione o programma dovrebbe aggiungere i tre livelli come 2, 3 e 4 attorno agli 1, sovrascrivendo così alcuni degli 0. La pastella si attacca orizzontalmente e verticalmente (ma non in diagonale) a alimenti di qualsiasi forma o dimensione, comprese le ciambelle (cibo con buchi) e si sbriciola ("pixel" alimentari isolati), ed è limitata ai confini della friggitrice. Gli strati precedenti di pastella si trasformano in crosta e non sono interessati da quelli successivi.

In altre parole, per prima cosa dovresti sostituire tutti gli 0 che si trovano nei quartieri di von-Neumann di 1s con 2s, quindi sostituire tutti gli 0 nei quartieri di von-Neumann di 2s con 3s e infine sostituire tutti gli 0 nei quartieri di von-Neumann di 3s con 4s. Pertanto, i numeri 2,3,4 rappresentano una quantità maggiore della distanza di Manhattan rispetto alla 1 cella più vicina.

La friggitrice avrà una dimensione di almeno 3 per 3 e conterrà almeno un pezzo di cibo. L'I / O è flessibile: utilizza un formato matrice adatto alla tua lingua. È consentito uno spazio extra, è preferibile un codice più corto, sono vietate le scappatoie.

Più test:

 [[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 piccolo aiuto visivo:

Mostra snippet di codice

Grazie @Tschallacka per le visualizzazioni.

code-golf  matrix 
— NGN
fonte
4
Potresti fornire un esempio dettagliato, per favore? Non mi è chiaro quando o perché usare 2, 3 o 4. (Vorrei VTC come poco chiaro ma ora ho un martello e sembra che sia in minoranza)
— Shaggy
1
@Shaggy La mia comprensione è che i numeri identificano il "livello". Un esempio 1D: 000010000→ 000212000→ 003212300→043212340
— georgewatson,
4
Grazie, @georgewatson; sembra che tu abbia ragione. Ciò non è chiaro dalle specifiche, tuttavia, che menzionano che la "pastella" dovrebbe attenersi solo al cibo e i precedenti strati di pastella non sono interessati da quelli successivi. L'unico modo per determinare ciò è decifrarlo dai casi di test.
— Shaggy
6
La tua prossima sfida dovrebbe essere un simulatore di Frati.
— Magic Octopus Urn
5
@ngn davvero ? (͡ ° ͜ʖ ͡ °)
— Magic Octopus Urn

Risposte:

10

Stencil : 1 + 14 = 15 byte

Argomento della riga di comando: 3

Codice: s<×⌈/N:1+⌈/N⋄S

Provalo online!

3 ripetere la seguente trasformazione tre volte:

 s se se le s ELF è non vuota

 < è meno di

 × il signum di

 ⌈/N il massimo della von Neuman N quartiere

 : quindi il nuovo valore diventa

  1+ uno più

  ⌈/N il massimo della von Neuman N quartiere

 ⋄ altro

  S il valore rimane non modificato ( S elf)

— Adamo
fonte
Non dovrebbe essere di 15 byte (14 + 1 per l'argomento 3)? La prima volta che vedo Stencil , ma se capisco correttamente è un'estensione per Dyalog APL a beneficio delle matrici? Inoltre, piccola osservazione: la N maiuscola all'inizio di Neumanndovrebbe essere in grassetto invece di quella piccola alla fine nella tua spiegazione. :)
— Kevin Cruijssen,
1
Bene, il più recente consenso sembra indicare che le varie configurazioni di una singola lingua dovrebbero essere conteggiate come lingue separate, ma lo aggiungerò
— Adám,
1
Lo stencil @KevinCruijssen può essere utilizzato come strumento Dyalog APL per semplici automi cellulari, ma è anche un linguaggio da golf. In effetti, potrebbe essere necessario modificare il proprio codice quando si passa dall'uso dello strumento al linguaggio del golf.
— Adám,
1
@KevinCruijssen No, il grassetto N finale è intenzionale. Vedere la documentazione che Stencil utilizza la prima e l'ultima lettera di Moore e von Neumann come mnemonici per con e senza auto, e gli usi caratteri minuscoli e maiuscoli come mnemonici per il conteggio dei non si svuota e l'elenco effettivo di elementi.
— Adám,
@KevinCruijssen Dovrei anche menzionare che Stencil è solo un'interfaccia per Dyalog APL ⌺integrata (chiamata Stencil ). Vedi anche la sua documentazione . Un intero linguaggio da golf costruito su un unico build-in! In realtà, ho creato altri due linguaggi del golf basandomi sui singoli built-in Dyalog APL: QuadR e QuadS .
— Adám,
10

Java 8, 271 269 247 210 202 198 193 byte

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

Matrici Java e dipendenti dall'indice. Non una buona combinazione per iniziare con un linguaggio già dettagliato.

Modifica la matrice di input invece di restituirne una nuova.

Spiegazione:

Provalo 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 byte

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

Casi test

Mostra snippet di codice

Commentate

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 byte

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)

Provalo online!

-18 byte grazie a Mr. Xcoder
-20 byte grazie a ovs

— HyperNeutrino
fonte
9
" Quando mi sveglio domani mattina e guardo di nuovo questo codice, probabilmente mi sentirò molto stupido. " Faresti meglio a esserlo, dal momento che ti ho superato in Java. ; P
— Kevin Cruijssen,
1
@KevinCruijssen cosa D: non accettabile. non deve essere battuto da Java: P
— HyperNeutrino,
1
Battiamo Java: c - 196 byte .
— Mr. Xcoder,
@ Mr.Xcoder yay grazie: c: D
— HyperNeutrino
@ovs oh nice, ty!
— HyperNeutrino,
3

Python 2 , 146 143 byte

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

Provalo online!

— OVS
fonte
3

Fortran 95, 309 299 294 287 269 ​​byte

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 non è una lingua da golf.

  • Modifica: salvato 10 byte utilizzando strani do do loop vecchio stile.
  • Modifica 2: 5 byte salvati conany()
  • Modifica 3: salvato 7 byte rimuovendo un inutileif
  • Modifica 4: 18 byte salvati riducendo la dichiarazione dis
— georgewatson
fonte
1

Pulito , 157 byte

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$

Provalo online!

Come una funzione letterale.

— Οurous
fonte
1

Perl, 63 byte

Include +3 per 0ap

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

Fornire la matrice di input come un blocco di cifre senza newline finale., Ad es

001
000
010

per l'esempio 3x3. Il formato di output è lo stesso, un blocco di cifre senza newline finale.

Puoi usare un piccolo script come 

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

per rimuovere comodamente le nuove righe finali da un file se è difficile farlo nel tuo editor preferito

— Ton Hospel
fonte
1

Retina , 93 87 84 byte

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

Provalo online! Sulla base della mia risposta a Kill it With Fire . Modifica: salvato 6 9 byte grazie a @MartinEnder. Spiegazione:

1
4

Trasforma tutti gli 1 in 4 secondi.

3{

Ripeti il ​​resto del programma (al massimo) 3 volte.

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

Cambia tutti gli 0 adiacenti a 4s in 5s.

T`1-5`d

Decrementa tutte le cifre.

Retina 0.8.2 , 100 94 byte

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

Provalo online! Spiegazione:

1
3

Trasforma tutti gli 1 in 3 secondi.

{

Ripetere fino a quando l'uscita non cambia.

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

Cambia tutti gli 0 adiacenti a 3s in 4s.

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

Se non ci sono 1, decrementa tutte le cifre.

— Neil
fonte
Puoi salvare alcuni byte usando un carattere come !(che non può apparire nell'input) invece di (?!).
— Martin Ender,
@MartinEnder Grazie, funziona anche con Kill it With Fire (e ho trovato un golf separato a 2 byte mentre ero lì!)
— Neil
1

Rubino , 183 158 146 byte

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

Provalo online!

Utilizza l'evidente algoritmo a tre loop. Il fatto che Ruby consenta l'indicizzazione negativa in array significa che non c'è modo (che posso vedere) di fare i controlli dei limiti. Il superamento del limite di un array restituisce nil, quindi sono necessari solo i controlli di limite negativo. Il controllo a[i+1][j]deve solo utilizzare l'operatore di accesso sicuro.

Ho anche rasato alcuni byte usando una variabile per a[0].

-12 più byte: utilizzare .timesinvece di (0...x).map(in tre punti).

->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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.