Mô phỏng nồi chiên

31

Nhiệm vụ của bạn là mô hình hóa các tác động của bột bánh trên các miếng thức ăn. Vui lòng thêm ba lớp vỏ.

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

Một chút trợ giúp trực quan:

Hiển thị đoạn mã

Đầu vào là một ma trận boolean đại diện cho nồi chiên: 0 cho dầu, 1 cho thực phẩm. Hàm hoặc chương trình của bạn nên thêm ba lớp là 2, 3 và 4 xung quanh 1, do đó ghi đè lên một số 0. Batter dính theo chiều ngang và chiều dọc (nhưng không theo đường chéo) với thực phẩm có hình dạng hoặc kích thước, bao gồm bánh rán (thực phẩm có lỗ) và vụn ("pixel" thực phẩm bị cô lập), và bị giới hạn trong ranh giới của nồi chiên. Các lớp bột trước đó biến thành lớp vỏ và không bị ảnh hưởng bởi lớp sau.

Nói cách khác, trước tiên, bạn nên thay thế tất cả các số 0 trong vùng lân cận von-Neumann của số 1 bằng số 2, sau đó thay thế tất cả số 0 trong vùng lân cận von-Neumann của số 2 bằng số 3 và cuối cùng thay thế tất cả số 0 trong vùng lân cận von-Neumann của 3s với 4s. Do đó, các số 2,3,4 đại diện cho một đại lượng lớn hơn khoảng cách Manhattan đến 1 ô gần nhất.

Nồi chiên sẽ có kích thước ít nhất là 3 x 3 và nó sẽ chứa ít nhất một miếng thức ăn. I / O rất linh hoạt - sử dụng định dạng ma trận phù hợp với ngôn ngữ của bạn. Khoảng trắng thêm được cho phép, mã ngắn hơn mong muốn, sơ hở bị cấm.

Các xét nghiệm khác:

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

Một chút trợ giúp trực quan:

Hiển thị đoạn mã

Cảm ơn @Tschallacka vì đã trực quan hóa.

code-golf  matrix 
— ngn
nguồn
4
Bạn có thể cung cấp một ví dụ hướng dẫn, xin vui lòng? Tôi không rõ khi nào hoặc tại sao nên sử dụng 2, 3 hoặc 4. (Tôi sẽ không rõ VTC nhưng bây giờ tôi có một cái búa và có vẻ như tôi là thiểu số)
— Shaggy
1
@Shaggy Hiểu biết của tôi là các con số xác định "lớp". Ví dụ 1D: 000010000→ 000212000→ 003212300→043212340
— georgewatson
4
Cảm ơn, @georgewatson; có vẻ như bạn đúng Tuy nhiên, điều đó không rõ ràng về thông số kỹ thuật, trong đó đề cập rằng "bột bánh" chỉ nên dính vào thức ăn và các lớp bột trước đó không bị ảnh hưởng bởi các lớp sau. Cách duy nhất để xác định điều đó là giải mã nó từ các trường hợp thử nghiệm.
— Xù xì
6
Thử thách tiếp theo của bạn nên là một trình giả lập Friar.
— Bạch tuộc ma thuật Urn
5
@ngn thật sao? (͡ ° ͜ʖ ͡ °)
— Bạch tuộc ma thuật Urn

Câu trả lời:

10

Stt : 1 + 14 = 15 byte

Đối số dòng lệnh: 3

Mã số: s<×⌈/N:1+⌈/N⋄S

Hãy thử trực tuyến!

3 lặp lại ba lần chuyển đổi sau đây:

 s nếu xem s elf không bị để trống

 < ít hơn

 × dấu hiệu của

 ⌈/N tối đa của von Neuman N hàng xóm

 : sau đó giá trị mới trở thành

  1+ một cộng

  ⌈/N tối đa của von Neuman N hàng xóm

 ⋄ khác

  S giá trị không thay đổi ( S elf)

— Adám
nguồn
Đây không phải là 15 byte (14 + 1 cho đối số 3)? Lần đầu tiên nhìn thấy stent , nhưng nếu tôi hiểu chính xác thì đó là một phần mở rộng cho Dyalog APL để mang lại lợi ích cho ma trận? Ngoài ra, nhận xét nhỏ: Thủ đô N khi bắt đầu Neumannnên được in đậm thay vì chữ nhỏ ở cuối giải thích của bạn. :)
— Kevin Cruijssen
1
Chà, sự đồng thuận mới nhất dường như chỉ ra rằng các cấu hình khác nhau của một ngôn ngữ nên được tính là các ngôn ngữ riêng biệt, nhưng tôi sẽ thêm nó
— Adám
1
@KevinCruijssen Macintosh có thể được sử dụng như một công cụ APL của Dyalog cho các máy tự động di động dễ dàng, nhưng nó cũng tự đứng như một ngôn ngữ chơi gôn. Thật vậy, mã của một người có thể cần sửa đổi khi di chuyển giữa việc sử dụng công cụ và ngôn ngữ chơi gôn.
— Adám
1
@KevinCruijssen Không, N cuối cùng táo bạo là có chủ ý. Xem tài liệu mà stent sử dụng các chữ cái đầu tiên và cuối cùng của moore và von neumann như là bản ghi nhớ cho có và không có bản thân, và sử dụng chữ thường và chữ hoa làm ký hiệu cho số lượng không phải là trống rỗng và danh sách các yếu tố thực tế.
— Adám
@KevinCruijssen Tôi cũng nên đề cập rằng Macintosh chỉ là một giao diện với phần mềm tích hợp của Dyalog APL ⌺(được gọi là stent ). Xem thêm tài liệu của nó . Toàn bộ ngôn ngữ chơi gôn được xây dựng trên một tích hợp duy nhất! Trên thực tế, tôi đã thực hiện hai ngôn ngữ chơi gôn khác dựa trên các bản dựng sẵn DyL APL: QuadR và 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){}}

Ma trận phụ thuộc vào Java và chỉ mục .. Không phải là sự kết hợp tốt cho một ngôn ngữ đã dài dòng bắt đầu bằng ..

Sửa đổi ma trận đầu vào thay vì trả về một ma trận mới.

Giải trình:

Hãy thử trực tuyến.

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
nguồn
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

Các trường hợp thử nghiệm

Hiển thị đoạn mã

Đã bình luận

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
nguồn
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)

Hãy thử trực tuyến!

-18 byte nhờ ông Xcoder
-20 byte nhờ vào các lò nướng

— HyperNeutrino
nguồn
9
" Khi tôi thức dậy vào sáng mai và nhìn lại mã này, có lẽ tôi sẽ cảm thấy rất ngớ ngẩn. " Tốt hơn là bạn nên vượt qua bạn trong Java. ; P
— Kevin Cruijssen
1
@KevinCruijssen những gì D: không được chấp nhận. không được đánh bại bởi Java: P
— HyperNeutrino
1
Hãy đánh bại Java: c - 196 byte .
— Ông Xcoder
@ Mr.Xcoder yay cảm ơn: c: D
— HyperNeutrino
@ovs ơi, đẹp quá!
— HyperNeutrino
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 không phải là một ngôn ngữ chơi golf.

  • Chỉnh sửa: Đã lưu 10 byte bằng cách sử dụng các vòng lặp lỗi thời.
  • Chỉnh sửa 2: Đã lưu 5 byte vớiany()
  • Chỉnh sửa 3: Đã lưu 7 byte bằng cách loại bỏ không cần thiếtif
  • Chỉnh sửa 4: Đã lưu 18 byte bằng cách thu nhỏ khai báos
— georgewatson
nguồn
1

Sạch sẽ , 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$

Hãy thử trực tuyến!

Là một chức năng theo nghĩa đen.

— Urous
nguồn
1

Perl, 63 byte

Bao gồm +3 cho 0ap

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

Đưa ra ma trận đầu vào dưới dạng một khối các chữ số không có dòng mới cuối cùng, vd

001
000
010

cho ví dụ 3x3. Định dạng đầu ra là như nhau, một khối các chữ số không có dòng mới cuối cùng.

Bạn có thể sử dụng một tập lệnh nhỏ như 

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

để thuận tiện xóa các dòng mới cuối cùng khỏi một tệp nếu điều đó khó thực hiện trong trình chỉnh sửa yêu thích của bạn

— Tôn bác sĩ
nguồn
1

Võng mạc , 93 87 84 byte

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

Hãy thử trực tuyến! Dựa trên câu trả lời của tôi để Kill it With Fire . Chỉnh sửa: Đã lưu 6 9 byte nhờ @MartinEnder. Giải trình:

1
4

Biến tất cả các số 1 thành 4s.

3{

Lặp lại phần còn lại của chương trình (nhiều nhất) 3 lần.

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

Thay đổi tất cả 0 liền kề với 4s thành 5s.

T`1-5`d

Giảm tất cả các chữ số.

Võng mạc 0.8.2 , 100 94 byte

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

Hãy thử trực tuyến! Giải trình:

1
3

Biến tất cả các số 1 thành 3 giây.

{

Lặp lại cho đến khi đầu ra không thay đổi.

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

Thay đổi tất cả 0 liền kề 3 giây thành 4 giây.

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

Nếu không có 1s, hãy giảm tất cả các chữ số.

— Neil
nguồn
Bạn có thể lưu một số byte bằng cách sử dụng một ký tự như !(không thể xuất hiện trong đầu vào) thay vì (?!).
— Martin Ender
@MartinEnder Cảm ơn, điều đó cũng hiệu quả với Kill it With Fire (và tôi đã tìm thấy một gôn 2 byte riêng biệt khi tôi ở đó!)
— 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}

Hãy thử trực tuyến!

Sử dụng thuật toán ba vòng rõ ràng. Việc Ruby cho phép lập chỉ mục tiêu cực thành các mảng có nghĩa là không có cách nào (mà tôi có thể thấy) xung quanh việc kiểm tra giới hạn. Vượt ra ngoài ranh giới của một mảng trả về nil, do đó chỉ cần kiểm tra ràng buộc âm. Việc kiểm tra a[i+1][j]chỉ cần sử dụng toán tử truy cập an toàn.

Tôi cũng đã loại bỏ một vài byte bằng cách sử dụng một biến cho a[0] .

-12 byte nữa: Sử dụng .timesthay vì (0...x).map(ở ba vị trí).

->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
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.