Fritöz simülatörü

31

Göreviniz meyilli yiyecek parçaları üzerindeki etkilerini modellemektir. Lütfen üç kat kabuk ekleyin.

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

Küçük bir görsel yardım:

Kod pasajını göster

Giriş, fritözü temsil eden bir boolean matristir: yağ için 0, yemek için 1. İşleviniz veya programınız üç katmanı 1'ler etrafına 2s, 3s ve 4 s olarak eklemeli, böylece 0'lardan bazılarının üzerine yazmalıdır. Hamur, çörekler (delikli yiyecekler) ve ufalananlar (izole edilmiş yiyecek "pikseller") dahil olmak üzere herhangi bir şekil veya büyüklükteki yiyeceğe yatay ve dikey olarak (fakat çapraz olarak değil) yapışır ve fritözün sınırlarıyla sınırlandırılır. Daha önceki meyilli tabakaları kabuk haline gelir ve sonraki tabakalardan etkilenmez.

Başka bir deyişle, önce 1'lerin von-Neumann mahallelerinde bulunan 0'ların hepsini 2s ile değiştirmelisiniz, sonra 2'lerin von-Neumann mahallelerinde 0'ların hepsini 3'lerle değiştirmelisiniz, ve sonunda tüm 0'ları von-Neumann'ların mahallelerinde değiştirmelisiniz. 4s ile 3s. Bu nedenle, 2,3,4 sayıları, en yakın 1 hücreye Manhattan mesafesinden daha büyük bir miktarı temsil eder.

Fritöz en az 3'e 3 büyüklükte olacak ve en az bir parça yiyecek içerecektir. G / Ç esnektir - dilinize uygun bir matris formatı kullanın. Ekstra boşluk bırakılır, daha kısa kod istenir, boşluklar yasaktır.

Daha fazla 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],

Küçük bir görsel yardım:

Kod pasajını göster

Görselleştirmeler için @Tschallacka teşekkürler.

code-golf  matrix 
— ngn
kaynak
4
Örnek bir örnek verebilir misiniz lütfen? 2, 3 veya 4'ü ne zaman veya niçin kullanacağım belli değil (VTC açık değil ama şimdi bir çekiçim var ve azınlıktayım gibi görünüyor)
— Shaggy
1
@Shaggy Benim anlayışım, sayıların "katmanı" tanımlamasıdır. Bir 1D örneği: 000010000→ 000212000→ 003212300→043212340
— georgewatson
4
Teşekkürler, @georgewatson; haklı gibi görünüyorsun. İşte bu "vurucu" gereken sadece gıda sopa ve hamur önceki katmanları vardır bahseder olsa da, hangi spec gelen açık değil değil sonradan olanları etkilenen. Bunu belirlemenin tek yolu, onu test durumlarından deşifre etmektir.
— Shaggy,
6
Bir sonraki meydan okumanız bir Friar simülatörü olmalıdır.
— Magic Octopus Urn
5
@ gerçekten mi? (͡ ° ͜ʖ ͡ °)
— Magic Octopus Urn

Yanıtlar:

10

Şablon : 1 + 14 = 15 bayt

Komut satırı argümanı: 3

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

Çevrimiçi deneyin!

3 aşağıdaki dönüşüm üç kez tekrarlayın:

 ss elf boş  değilse

 < daha az

 × işareti

 ⌈/N von neuman N mahallesinin en fazla

 : sonra yeni değer olur

  1+ bir artı

  ⌈/N von neuman N mahallesinin en fazla

 ⋄ Başka

  S değer değiştirilmemiş olarak kalır ( S elf)

— Adem
kaynak
Bu 15 bayt (argüman için 14 + 1 3) olmamalıdır ? Stencil'i ilk kez görüyorum , fakat doğru anlarsam Dyalog APL'nin matrislere faydası olabilir mi? Ayrıca, küçük not: Başındaki N harfinin açıklamasındaki Neumannen küçük harf yerine koyu yazılmalıdır. :)
— Kevin Cruijssen
1
Peki, yeni fikir birliği, tek bir dilin çeşitli konfigürasyonlarının ayrı diller olarak sayılması gerektiğini gösteriyor gibi görünüyor, ama ekleyeceğim
— Adám
1
@KevinCruijssen Stencil , kolay hücresel otomatlar için bir Dyalog APL aracı olarak kullanılabilir, ancak aynı zamanda bir golf dili olarak da kendini gösterir. Aslında, birinin kodu, araç kullanımı ile golf dili arasında hareket ederken değişiklik yapılması gerekebilir.
— Ad'm
1
@KevinCruijssen Hayır, cesur son N kasıtlı. Stencil’in moore ve von neumann’ın ilk ve son harflerini kendi kendine olan ve olmayan mnemonik olarak kullandığı ve boş olmayanların sayımı ve asıl öğe listesi için mnemonik olarak küçük ve büyük harf kullandığı belgelerine bakın .
— Ad'm
@KevinCruijssen Ayrıca Stencil'in Dyalog APL'nin ⌺( Stencil adı verilen ) yerleşik bir arayüz olduğunu da belirtmeliyim . Ayrıca belgelerine de bakınız . Tek bir yerleşik yapı üzerine kurulu bütün bir golf dili! Aslında, diğer Dyalog APL yerleşiklerine dayalı iki golf dili daha yaptım: QuadR ve QuadS .
— Ad'm
10

Java 8, 271 269 247 210 202 198 193 bayt

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 ve dizine bağlı matrisler .. Zaten ayrıntılı bir dilin başlaması için iyi bir kombinasyon değil.

Yeni bir tane döndürmek yerine giriş matrisini değiştirir.

Açıklama:

Çevrimiçi deneyin.

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

JavaScript (ES6), 107 105 bayt

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 durumları

Kod pasajını göster

Yorumlananlar

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

Python 3 , 176 bayt

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)

Çevrimiçi deneyin!

Bay Xcoder sayesinde -18 bayt Ovs
sayesinde -20 bayt

— HyperNeutrino
kaynak
9
“ Yarın sabah uyandığımda ve bu koda tekrar baktığımda, muhtemelen kendimi çok aptal hissedeceğim ”. ; P
— Kevin Cruijssen
1
@KevinCruijssen ne D: kabul edilemez. Java tarafından
— yenilmemelidir
1
Java'yı yenelim: c - 196 bayt .
— Bay Xcoder
@ Mr.Xcoder yay teşekkürler: c: D
— HyperNeutrino
@ovs oh güzel, ty!
— HyperNeutrino
3

Python 2 , 146 143 bayt

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

Çevrimiçi deneyin!

— ovs
kaynak
3

Fortran 95, 309 299 294 287 269 ​​bayt

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 bir golf dili değil.

  • Düzenleme: garip eski moda do döngüler kullanarak 10 bayt kaydedildi.
  • Düzenleme 2: ile 5 bayt kaydedildiany()
  • Düzenleme 3: Gereksiz bir kaldırarak 7 bayt kaydedildiif
  • Düzenleme 4: Bildirimini küçülterek 18 bayt kurtardıs
— GeorgeWatson
kaynak
1

Temiz , 157 bayt

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$

Çevrimiçi deneyin!

Bir işlev olarak değişmez.

— Οurous
kaynak
1

Perl, 63 bayt

İçin +3 içerir 0ap

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

Giriş matrisini son satırsonu olmayan bir rakam bloğu olarak verin .

001
000
010

3x3 örneği için. Çıkış formatı aynıdır, son satırsonu olmayan bir rakam bloğu.

Gibi küçük bir komut dosyası kullanabilirsiniz 

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

favori editörünüzde yapmak zorsa, son satırları bir dosyadan kolayca kaldırmak için

— Ton Hospel
kaynak
1

Retina , 93 87 84 bayt

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

Çevrimiçi deneyin! Ateşle Öldürmek için verdiğim cevaba dayanarak . Düzenleme: @ Martininder sayesinde 6 9 bayt kaydedildi. Açıklama:

1
4

Tüm 1'leri 4s'e çevirin.

3{

Programın kalanını (en fazla) 3 kez tekrarlayın.

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

Komşu 0'ları 4 s olarak 5 s'ye değiştirin.

T`1-5`d

Tüm rakamları azalt.

Retina 0.8.2 , 100 94 bayt

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

Çevrimiçi deneyin! Açıklama:

1
3

Tüm 1'leri 3s'ye çevirin.

{

Çıkış değişene kadar tekrarlayın.

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

Komşu 0'ları 3s'e 4 s olarak değiştirin.

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

1s yoksa, tüm rakamları azaltın.

— Neil
kaynak
Bazı baytları !bunun yerine (girişte görünmeyen) gibi bir karakter kullanarak kaydedebilirsiniz (?!).
— Martin Ender
@MartinEnder Teşekkürler, bu Ateşle Ateşle de işe yarıyor (ve ben oradayken ayrı 2 baytlık bir golf buldum!)
— Neil
1

Ruby , 183 158 146 bayt

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

Çevrimiçi deneyin!

Belirgin üç döngü algoritmasını kullanır. Ruby'nin dizilere negatif indekslemeye izin vermesi, sınır kontrollerini yapmanın hiçbir yolunun (görebildiğim) olmadığı anlamına gelir. Bir dizinin sınırının ötesine ulaşıldığında nil, yalnızca negatif sınır kontrolleri gerekir. Kontrol a[i+1][j]sadece güvenli erişim operatörünü kullanmaya ihtiyaç duyar.

Ayrıca bir değişken kullanarak birkaç byte'ı traş ettim a[0].

-12 tane daha bayt: .timesBunun yerine kullanın (0...x).map(üç yerde).

->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
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.