Simulator penggorengan

31

Tugas Anda adalah membuat model efek adonan pada potongan makanan. Silakan tambahkan tiga lapisan kerak.

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

Sedikit bantuan visual:

Tampilkan cuplikan kode

Masukan adalah matriks boolean yang mewakili alat penggoreng: 0 untuk minyak, 1 untuk makanan. Fungsi atau program Anda harus menambahkan tiga layer sebagai 2s, 3s, dan 4s di sekitar 1s, sehingga menimpa beberapa dari 0s. Adonan menempel secara horizontal dan vertikal (tetapi tidak diagonal) untuk makanan dalam bentuk atau ukuran apa pun, termasuk donat (makanan berlubang) dan remuk (makanan terisolasi "piksel"), dan terbatas pada batas penggorengan. Lapisan adonan yang sebelumnya berubah menjadi kerak dan tidak terpengaruh oleh lapisan selanjutnya.

Dengan kata lain, pertama Anda harus mengganti semua 0s yang ada di lingkungan von-Neumann dari 1s dengan 2s, lalu ganti semua 0s di lingkungan von-Neumann dari 2s dengan 3s, dan akhirnya ganti semua 0s di lingkungan von-Neumann dari 3s dengan 4s. Dengan demikian, angka 2,3,4 mewakili kuantitas yang lebih besar dari jarak Manhattan ke 1-sel terdekat.

Alat penggoreng akan berukuran setidaknya 3-oleh-3 dan itu akan mengandung setidaknya satu potong makanan. I / O fleksibel - gunakan format matriks yang cocok untuk bahasa Anda. Ruang kosong ekstra diizinkan, kode pendek diinginkan, celah terlarang.

Tes lebih lanjut:

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

Sedikit bantuan visual:

Tampilkan cuplikan kode

Terima kasih @Tschallacka untuk visualisasi.

code-golf  matrix 
— ngn
sumber
4
Bisakah Anda memberikan contoh panduan? Tidak jelas bagi saya kapan atau mengapa harus menggunakan 2, 3 atau 4. (Saya akan VTC tidak jelas tetapi saya memiliki palu sekarang dan sepertinya saya adalah minoritas)
— Shaggy
1
@ Shaggy Pemahaman saya adalah bahwa angka mengidentifikasi "lapisan". Contoh 1D: 000010000→ 000212000→ 003212300→043212340
— georgewatson
4
Terima kasih, @georgewatson; sepertinya kamu benar. Namun, itu tidak jelas dari spek, yang menyebutkan bahwa "adonan" hanya boleh menempel pada makanan dan lapisan adonan sebelumnya tidak terpengaruh oleh yang kemudian. Satu-satunya cara untuk menentukan itu adalah menguraikannya dari kasus uji.
— Shaggy
6
Tantangan Anda berikutnya adalah simulator Friar.
— Magic Gurita Guci
5
@ngn benar-benar ? (͡ ° ͜ʖ ͡ °)
— Magic Octopus Mm

Jawaban:

10

Stensil : 1 + 14 = 15 byte

Argumen baris perintah: 3

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

Cobalah online!

3 ulangi transformasi tiga kali berikut:

 s jika apakah s elf tidak kosong

 < kurang dari

 × signum dari

 ⌈/N maksimum dari von neuman N lingkungan

 : maka nilai baru menjadi

  1+ satu ditambah

  ⌈/N maksimum dari von neuman N lingkungan

 ⋄ lain

  S nilai tetap tidak dimodifikasi ( S elf)

— Adm
sumber
Bukankah ini seharusnya 15 byte (14 +1 untuk argumen 3)? Pertama kali melihat Stensil , tetapi jika saya mengerti benar itu adalah ekstensi untuk Dyalog APL untuk mendapatkan manfaat matriks? Juga, komentar kecil: Modal N pada awal Neumannharus tebal, bukan modal kecil di akhir penjelasan Anda. :)
— Kevin Cruijssen
1
Nah, konsensus terbaru tampaknya menunjukkan bahwa berbagai konfigurasi satu bahasa harus dihitung sebagai bahasa yang terpisah, tetapi saya akan menambahkannya
— Adám
1
@KevinCruijssen Stencil dapat digunakan sebagai alat Dyalog APL untuk automaton seluler yang mudah, tetapi juga berdiri sendiri sebagai bahasa golf. Memang, kode seseorang mungkin perlu modifikasi ketika berpindah antara penggunaan alat dan bahasa golf.
— Adám
1
@KevinCruijssen Tidak, final N yang berani disengaja. Lihat dokumentasi bahwa Stensil menggunakan huruf pertama dan terakhir dari moore dan von neumann sebagai mnemonik untuk dengan dan tanpa diri, dan menggunakan huruf kecil dan besar sebagai mnemonik untuk penghitungan non-kosong dan daftar elemen yang sebenarnya.
— Adám
@KevinCruijssen Saya juga harus menyebutkan bahwa Stencil hanyalah sebuah antarmuka untuk Dyalog ⌺built-in APL (disebut Stencil ). Lihat juga dokumentasinya . Seluruh bahasa bermain golf dibangun di atas satu built-in! Sebenarnya, saya telah membuat dua bahasa golf lainnya berdasarkan pada Dyalog APL built-in: QuadR dan 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){}}

Matriks Java dan index-dependent .. Bukan kombinasi yang baik untuk bahasa yang sudah verbose untuk memulai ..

Memodifikasi input-matriks alih-alih mengembalikan yang baru.

Penjelasan:

Cobalah 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
sumber
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

Uji kasus

Tampilkan cuplikan kode

Berkomentar

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

Cobalah online!

-18 byte terima kasih kepada Tn. Xcoder
-20 byte terima kasih kepada ovs

— HyperNeutrino
sumber
9
" Ketika saya bangun besok pagi dan melihat kode ini lagi, saya mungkin akan merasa sangat bodoh. " Anda sebaiknya, karena saya mengalahkan Anda di Jawa. ; P
— Kevin Cruijssen
1
@KevinCruijssen apa D: tidak dapat diterima. tidak boleh dikalahkan oleh Java: P
— HyperNeutrino
1
Mari kita kalahkan Java: c - 196 byte .
— Tn. Xcoder
@ Mr.Xcoder yay terima kasih: c: D
— HyperNeutrino
@ oh oh bagus, 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

Cobalah online!

— ovs
sumber
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 bukan bahasa golf.

  • Sunting: Disimpan 10 byte dengan menggunakan loop do kuno yang aneh.
  • Sunting 2: Disimpan 5 byte denganany()
  • Sunting 3: Disimpan 7 byte dengan menghapus yang tidak perluif
  • Sunting 4: Disimpan 18 byte dengan menyusutkan deklarasis
— georgewatson
sumber
1

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

Cobalah online!

Sebagai fungsi literal.

— Suram
sumber
1

Perl, 63 byte

Termasuk +3 untuk 0ap

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

Berikan matriks input sebagai blok digit tanpa baris baru, misalnya

001
000
010

untuk contoh 3x3. Format outputnya sama, satu blok digit tanpa baris akhir final.

Anda dapat menggunakan skrip kecil seperti 

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

untuk dengan mudah menghapus baris baru dari file jika itu sulit dilakukan di editor favorit Anda

— Ton Hospel
sumber
1

Retina , 93 87 84 byte

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

Cobalah online! Berdasarkan jawaban saya untuk Kill it With Fire . Sunting: Disimpan 6 9 byte berkat @MartinEnder. Penjelasan:

1
4

Ubah semua angka 1 menjadi angka 4.

3{

Ulangi sisa program (paling banyak) 3 kali.

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

Ubah semua 0s yang berdekatan dengan 4s menjadi 5s.

T`1-5`d

Perkecil semua digit.

Retina 0.8.2 , 100 94 byte

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

Cobalah online! Penjelasan:

1
3

Ubah semua angka 1 menjadi angka 3.

{

Ulangi sampai output tidak berubah.

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

Ubah semua 0s yang berdekatan dengan 3s menjadi 4s.

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

Jika tidak ada angka 1, kurangi semua digit.

— Neil
sumber
Anda dapat menyimpan beberapa byte dengan menggunakan karakter seperti !(yang tidak dapat muncul di input) sebagai gantinya (?!).
— Martin Ender
@ MartinEnder Terima kasih, yang bekerja untuk Kill it With Fire juga (dan saya menemukan golf 2-byte terpisah ketika saya di sana!)
— Neil
1

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

Cobalah online!

Menggunakan algoritma tiga putaran yang jelas. Fakta bahwa Ruby memungkinkan pengindeksan negatif ke dalam array berarti bahwa tidak ada cara (yang bisa saya lihat) dalam membuat batas memeriksa. Mencapai di luar batas array akan kembalinil , jadi hanya pemeriksaan batas negatif yang diperlukan. Cek untuk a[i+1][j]hanya perlu menggunakan operator akses yang aman.

Saya juga mencukur beberapa byte dengan menggunakan variabel untuk a[0] .

-12 byte lebih banyak: Gunakan .timesalih-alih (0...x).map(di tiga tempat).

->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
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.