Symulator frytkownicy

31

Twoim zadaniem jest modelowanie wpływu ciasta na kawałki jedzenia. Dodaj trzy warstwy skórki.

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

Mała pomoc wizualna:

Pokaż fragment kodu

Dane wejściowe to macierz boolowska reprezentująca frytkownicę: 0 dla oleju, 1 dla żywności. Twoja funkcja lub program powinien dodać trzy warstwy jako 2, 3 i 4 wokół 1, zastępując w ten sposób niektóre z 0. Ciasto przykleja się poziomo i pionowo (ale nie po przekątnej) do potraw o dowolnym kształcie i rozmiarze, w tym pączków (potrawy z dziurami) i kruszonek (pojedyncze „piksele” potraw) i ogranicza się do granic frytkownicy. Wcześniejsze warstwy ciasta zmieniają się w skórkę i nie mają na nie wpływu późniejsze.

Innymi słowy, najpierw powinieneś zamienić wszystkie 0, które znajdują się w sąsiedztwie von-Neumanna z 1 na 2, następnie zastąpić wszystkie 0 w dzielnicach von-Neumann z 2 na 3, a na koniec zastąpić wszystkie 0 w dzielnicach von-Neumann 3s z 4s. Tak więc liczby 2,3,4 oznaczają liczbę o jeden większą niż odległość Manhattanu do najbliższej komórki 1-komórkowej.

Frytownica będzie miała rozmiar co najmniej 3 na 3 i będzie zawierać co najmniej jeden kawałek jedzenia. I / O jest elastyczny - użyj formatu matrycy odpowiedniego dla twojego języka. Dozwolone są dodatkowe spacje, pożądany jest krótszy kod, zabronione luki.

Więcej testów:

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

Mała pomoc wizualna:

Pokaż fragment kodu

Dzięki @Tschallacka za wizualizacje.

code-golf  matrix 
— ngn
źródło
4
Czy mógłbyś podać przykład instruktażowy? Nie jest dla mnie jasne, kiedy i dlaczego używać 2, 3 lub 4. (VTC byłbym niejasny, ale teraz mam młotek i wygląda na to, że jestem w mniejszości)
— Kudłaty
1
@Shaggy Rozumiem, że liczby identyfikują „warstwę”. Przykład 1D: 000010000→ 000212000→ 003212300→043212340
— georgewatson
4
Dzięki, @georgewatson; wygląda na to, że masz rację. Nie jest to jednak jasne w specyfikacji, która wspomina, że ​​„ciasto” powinno się przyklejać tylko do jedzenia, a późniejsze warstwy nie mają wpływu na wcześniejsze. Jedynym sposobem ustalenia tego jest odszyfrowanie go z przypadków testowych.
— Kudłaty
6
Twoim kolejnym wyzwaniem powinien być symulator Friar.
— Magic Octopus Urn
5
@ngn naprawdę ? (͡ ° ͜ʖ ͡ °)
— Magic Octopus Urn

Odpowiedzi:

10

Szablon : 1 + 14 = 15 bajtów

Argument wiersza poleceń: 3

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

Wypróbuj online!

3 powtórz trzy razy następującą transformację:

 s Jeśli czy s elf niepusty

 < jest mniej niż

 × podpis

 ⌈/N maksimum sąsiedztwa von neuman N.

 : wtedy nowa wartość staje się

  1+ jeden plus

  ⌈/N maksimum sąsiedztwa von neuman N.

 ⋄ jeszcze

  S rozporki wartość niemodyfikowanego ( S elf)

— Adám
źródło
Czy nie powinno to być 15 bajtów (14 + 1 dla argumentu 3)? Pierwszy raz widzę Wzornik , ale jeśli dobrze rozumiem, to rozszerzenie programu Dyalog APL do korzystania z matryc? Również drobna uwaga: Wielka litera na początku Neumannpowinna być pogrubiona zamiast małej na końcu twojego wyjaśnienia. :)
— Kevin Cruijssen
1
Cóż, najnowszy konsensus wydaje się wskazywać, że różne konfiguracje jednego języka powinny być liczone jako osobne języki, ale dodam go
— Adám
1
@KevinCruijssen Stencil can be used as a Dyalog APL tool for easy cellular automatons, but it also stands on its own as a golfing language. Indeed, one's code may need modification when moving between tool usage and the golfing language.
— Adám
1
@KevinCruijssen No, the bold final N is intentional. See the documentation that Stencil uses the first and last letters of moore and von neumann as mnemonics for with and without self, and uses lowercase and uppercase as mnemonics for the count of non-empties and the actual list of elements.
— Adám
@KevinCruijssen I should also mention that Stencil is just an interface to Dyalog APL's ⌺ built-in (called Stencil). See also its documentation. A whole golfing language built on a single build-in! Actually, I have made two other golfing languages basing on single Dyalog APL built-ins: QuadR and 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 and index-dependent matrices.. Not a good combination for an already verbose language to begin with..

Modifies the input-matrix instead of returning a new one.

Explanation:

Try it 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
źródło
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

Test cases

Show code snippet

Commented

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
źródło
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)

Try it online!

-18 bytes thanks to Mr. Xcoder
-20 bytes thanks to ovs

— HyperNeutrino
źródło
9
"When I wake up tomorrow morning and look at this code again I'm probably going to feel very dumb." You'd better be, since I outgolfed you in Java. ;P
— Kevin Cruijssen
1
@KevinCruijssen what D: not acceptable. must not be beaten by Java :P
— HyperNeutrino
1
Let's beat Java :c – 196 bytes.
— Mr. Xcoder
@Mr.Xcoder yay thanks :c :D
— HyperNeutrino
@ovs oh nice, 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

Try it online!

— ovs
źródło
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 is not a golfing language.

  • Edit: Saved 10 bytes by using weird old-fashioned do loops.
  • Edit 2: Saved 5 bytes with any()
  • Edit 3: Saved 7 bytes by removing an unnecessary if
  • Edit 4: Saved 18 bytes by shrinking declaration of s
— georgewatson
źródło
1

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

Try it online!

As a function literal.

— Οurous
źródło
1

Perl, 63 bytes

Includes +3 for 0ap

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

Give the input matrix as a block of digits without final newline., e.g.

001
000
010

for the 3x3 example. The output format is the same, a block of digits without final newline.

You can use a small script like 

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

to conveniently remove the final newlines from a file if that is hard to do in your favorite editor

— Ton Hospel
źródło
1

Retina, 93 87 84 bytes

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

Try it online! Based on my answer to Kill it With Fire. Edit: Saved 6 9 bytes thanks to @MartinEnder. Explanation:

1
4

Turn all the 1s into 4s.

3{

Repeat the rest of the program (at most) 3 times.

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

Change all 0s adjacent to 4s into 5s.

T`1-5`d

Decrement all digits.

Retina 0.8.2, 100 94 bytes

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

Try it online! Explanation:

1
3

Turn all the 1s into 3s.

{

Repeat until the output does not change.

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

Change all 0s adjacent to 3s into 4s.

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

If there are no 1s, decrement all digits.

— Neil
źródło
You can save some bytes by using a character like ! (which can't appear in the input) instead of (?!).
— Martin Ender
@MartinEnder Thanks, that works for Kill it With Fire too (and I found a separate 2-byte golf while I was there!)
— 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}

Try it online!

Uses the obvious three-loop algorithm. The fact that Ruby allows negative indexing into arrays means that there is no way (that I can see) around making the bounds checks. Reaching beyond the boundary of an array returns nil, so only the negative bound checks are necessary. The check for a[i+1][j] just needs to use the safe access operator.

I also shaved off a few bytes by using a variable for a[0].

-12 more bytes: Use .times instead of (0...x).map (in three places).

->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
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.