Friteuse Simulator

31

Ihre Aufgabe ist es, die Auswirkungen von Teig auf Lebensmittelstücke zu modellieren. Bitte fügen Sie drei Schichten Kruste hinzu.

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

Eine kleine visuelle Hilfe:

Code-Snippet anzeigen

Die Eingabe ist eine boolesche Matrix, die die Friteuse darstellt: 0 für das Öl, 1 für das Lebensmittel. Ihre Funktion oder Ihr Programm sollte die drei Ebenen als 2s, 3s und 4s um die 1s hinzufügen und so einige der 0s überschreiben. Der Teig haftet horizontal und vertikal (aber nicht diagonal) an Lebensmitteln beliebiger Form oder Größe, einschließlich Donuts (Lebensmittel mit Löchern) und Streuseln (isolierte Lebensmittel- "Pixel"), und ist auf die Grenzen der Friteuse beschränkt. Frühere Teigschichten verkrusten und werden von späteren nicht mehr angegriffen.

Mit anderen Worten, zuerst sollten Sie alle 0en, die sich in den von-Neumann-Vierteln von 1s befinden, durch 2s ersetzen, dann alle 0en in den von-Neumann-Vierteln von 2s durch 3s ersetzen und schließlich alle 0en in den von-Neumann-Vierteln von 3er mit 4er. Somit repräsentieren die Zahlen 2,3,4 eine Größe, die um eins größer ist als der Manhattan-Abstand zur nächsten 1-Zelle.

Die Friteuse hat eine Größe von mindestens 3 mal 3 und enthält mindestens ein Stück Lebensmittel. I / O ist flexibel - verwenden Sie ein für Ihre Sprache geeignetes Matrixformat. Zusätzliches Leerzeichen ist erlaubt, kürzerer Code erwünscht, Lücken verboten.

Weitere Tests:

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

Eine kleine visuelle Hilfe:

Code-Snippet anzeigen

Danke @Tschallacka für die Visualisierungen.

code-golf  matrix 
— ngn
quelle
4
Könnten Sie bitte ein exemplarisches Beispiel nennen? Es ist mir nicht klar, wann oder warum ich 2, 3 oder 4 verwenden soll. (Ich würde VTC als unklar bezeichnen, aber ich habe jetzt einen Hammer und es sieht so aus, als ob ich in einer Minderheit bin.)
— Shaggy
1
@ Shaggy Mein Verständnis ist, dass die Zahlen die "Schicht" identifizieren. Ein 1D-Beispiel: 000010000→ 000212000→ 003212300→043212340
— Georgewatson
4
Danke, @georgewatson; anscheinend hast du recht Dies geht jedoch nicht aus der Spezifikation hervor, in der erwähnt wird, dass "Teig" nur an Lebensmitteln haften soll und frühere Teigschichten von späteren Schichten nicht beeinträchtigt werden. Die einzige Möglichkeit, dies festzustellen, besteht darin, es aus den Testfällen zu entziffern.
— Shaggy
6
Ihre nächste Herausforderung sollte ein Friar-Simulator sein.
— Magic Octopus Urn
5
@ngn wirklich ? (͡ ° ͜ʖ ͡ °)
— Magic Octopus Urn

Antworten:

10

Schablone : 1 + 14 = 15 Bytes

Befehlszeilenargument: 3

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

Probieren Sie es online!

3 Wiederhole die folgende Transformation dreimal:

 s wenn , ob die s elf nicht leer ist

 < ist weniger als

 × das Zeichen von

 ⌈/N das Maximum der von neuman N Nachbarschaft

 : dann wird der neue Wert

  1+ eins plus

  ⌈/N das Maximum der von neuman N Nachbarschaft

 ⋄ sonst

  S der Wert bleibt unverändert ( S elf)

— Adam
quelle
Sollte das nicht 15 Bytes sein (14 + 1 für das Argument 3)? Wenn ich Stencil zum ersten Mal sehe , aber wenn ich es richtig verstehe, ist es eine Erweiterung für Dyalog APL , um Matrizen zu nutzen? Außerdem eine kleine Bemerkung: Das Großbuchstaben N am Anfang Neumannsollte fett sein anstelle des kleinen am Ende Ihrer Erklärung. :)
— Kevin Cruijssen
1
Nun, der neueste Konsens scheint darauf hinzudeuten, dass verschiedene Konfigurationen einer einzelnen Sprache als separate Sprachen gezählt werden sollten, aber ich werde es hinzufügen
— Adám
1
@KevinCruijssen Stencil kann als Dyalog APL-Tool für einfache zellulare Automaten verwendet werden, steht aber auch als eigenständige Golfsprache zur Verfügung. Tatsächlich muss der eigene Code möglicherweise geändert werden, wenn zwischen der Werkzeugnutzung und der Golfsprache gewechselt wird.
— Adám
1
@ KevinCruijssen Nein, das kühne letzte N ist beabsichtigt. Lesen Sie in der Dokumentation nach, dass Stencil die ersten und letzten Buchstaben von moore und von neumann als Mnemonik für mit und ohne Selbst verwendet und Klein- und Großbuchstaben als Mnemonik für die Anzahl der Nicht-Leergüter und die tatsächliche Liste der Elemente verwendet.
— Adám
@ KevinCruijssen Ich sollte auch erwähnen, dass Stencil nur eine Schnittstelle zu Dyalog APLs ⌺eingebautem (genannt Stencil ) ist. Siehe auch die Dokumentation . Eine ganze Golfsprache in einem! Tatsächlich habe ich zwei weitere Golfsprachen entwickelt, die auf einzelnen integrierten Dyalog APLs basieren : QuadR und 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- und indexabhängige Matrizen. Keine gute Kombination für eine bereits ausführliche Sprache.

Ändert die Eingabematrix, anstatt eine neue zurückzugeben.

Erläuterung:

Probieren Sie es online aus.

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

Testfälle

Code-Snippet anzeigen

Kommentiert

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
quelle
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)

Probieren Sie es online!

-18 Bytes dank Mr. Xcoder
-20 Bytes dank Ovs

— HyperNeutrino
quelle
9
„ Wenn ich morgen früh aufwache und mir diesen Code noch einmal ansehe, werde ich mich wahrscheinlich sehr dumm fühlen. “ Das solltest du besser, da ich dich in Java übervorteilt habe. ; P
— Kevin Cruijssen
1
@ KevinCruijssen was D: nicht akzeptabel. darf nicht von Java geschlagen werden: P
— HyperNeutrino
1
Lassen Sie uns Java schlagen: c - 196 Bytes .
— Mr. Xcoder
@ Mr.Xcoder yay danke: c: D
— HyperNeutrino
@ovs oh schön, ty!
— HyperNeutrino
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 ist keine Golfsprache.

  • Bearbeiten: 10 Bytes mit seltsamen altmodischen do-Schleifen gespeichert.
  • Edit 2: 5 Bytes mit gespeichertany()
  • Edit 3: 7 Bytes durch Entfernen eines unnötigen gespeichertif
  • Edit 4: 18 Bytes durch Verkleinerung der Deklaration von gespeicherts
— Georgewatson
quelle
1

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

Probieren Sie es online!

Als Funktionsliteral.

— Οurous
quelle
1

Perl, 63 Bytes

Beinhaltet +3 für 0ap

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

Geben Sie die Eingabematrix als Ziffernblock ohne letzten Zeilenumbruch an, z

001
000
010

für das 3x3 Beispiel. Das Ausgabeformat ist das gleiche, ein Ziffernblock ohne letzte Zeilenumbruch.

Sie können ein kleines Skript wie verwenden 

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

Bequemes Entfernen der letzten Zeilenumbrüche aus einer Datei, wenn dies in Ihrem bevorzugten Editor schwierig ist

— Tonne Hospel
quelle
1

Retina , 93 87 84 Bytes

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

Probieren Sie es online! Basierend auf meiner Antwort auf Kill it With Fire . Bearbeiten: 6 9 Bytes dank @MartinEnder gespeichert. Erläuterung:

1
4

Verwandle alle Einsen in Viersen.

3{

Wiederholen Sie den Rest des Programms (höchstens) dreimal.

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

Ändern Sie alle 0s neben 4s in 5s.

T`1-5`d

Alle Ziffern dekrementieren.

Retina 0,8,2 , 100 94 Bytes

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

Probieren Sie es online! Erläuterung:

1
3

Verwandle alle Einsen in Dreien.

{

Wiederholen, bis sich die Ausgabe nicht mehr ändert.

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

Ändern Sie alle 0s neben 3s in 4s.

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

Wenn es keine 1 gibt, dekrementieren Sie alle Ziffern.

— Neil
quelle
Sie können einige Bytes speichern, indem Sie !anstelle von ein Zeichen wie (das nicht in der Eingabe erscheinen kann) verwenden (?!).
— Martin Ender
@MartinEnder Danke, das funktioniert auch für Kill it With Fire (und ich fand einen separaten 2-Byte-Golf, als ich dort war!)
— 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}

Probieren Sie es online!

Verwendet den offensichtlichen Drei-Schleifen-Algorithmus. Die Tatsache, dass Ruby eine negative Indizierung in Arrays zulässt, bedeutet, dass es keine Möglichkeit gibt (wie ich sehen kann), die Grenzen zu überprüfen. Wenn Sie über die Begrenzung eines Arrays hinausgehen nil, werden nur die negativen Begrenzungsprüfungen benötigt. Für die Prüfung muss a[i+1][j]nur der sichere Zugriffsoperator verwendet werden.

Ich habe auch ein paar Bytes mit einer Variablen für rasiert a[0].

-12 weitere Bytes: Verwenden Sie .timesanstelle von (0...x).map(an drei Stellen).

->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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.