ตัวจำลองการทอด

31

งานของคุณคือสร้างแบบจำลองผลกระทบของการปะทะกับชิ้นส่วนของอาหาร กรุณาเพิ่มเปลือกสามชั้น

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

เครื่องช่วยมองเห็นเล็กน้อย:

แสดงตัวอย่างโค้ด

อินพุตเป็นเมทริกบูลีนที่แสดงถึงการทอดน้ำมัน: 0 สำหรับน้ำมันและ 1 สำหรับอาหาร ฟังก์ชั่นหรือโปรแกรมของคุณควรเพิ่มสามเลเยอร์เป็น 2s, 3s และ 4s รอบ ๆ 1 ดังนั้นจึงเขียนทับ 0 บางส่วน ปะทะติดในแนวนอนและแนวตั้ง (แต่ไม่ใช่แนวทแยงมุม) กับอาหารที่มีรูปร่างหรือขนาดใด ๆ รวมถึงโดนัท (อาหารที่มีรู) และ crumbles (อาหารที่แยกได้ "พิกเซล") และถูก จำกัด ไว้ที่ขอบเขตของหม้อทอด ชั้นแป้งก่อนหน้านี้จะเปลี่ยนเป็นเปลือกโลกและไม่ได้รับผลกระทบจากชั้นต่อมา

ในคำอื่น ๆ อันดับแรกคุณควรแทนที่ 0s ทั้งหมดที่อยู่ในย่าน von-Neumann ของ 1s ด้วย 2s จากนั้นแทนที่ 0s ทั้งหมดในย่าน von-Neumann ของ 2s ด้วย 3s และในที่สุดก็แทนที่ 0s ทั้งหมดในย่าน von-Neumann ของ 3 วินาทีกับ 4s ดังนั้นตัวเลข 2,3,4 จึงแทนปริมาณหนึ่งที่มากกว่าระยะทางแมนฮัตตันถึง 1 เซลล์ที่ใกล้ที่สุด

หม้อทอดจะมีขนาดอย่างน้อย 3 ต่อ 3 และจะมีอาหารอย่างน้อยหนึ่งชิ้น I / O มีความยืดหยุ่น - ใช้รูปแบบเมทริกซ์ที่เหมาะสมกับภาษาของคุณ อนุญาตให้มีพื้นที่ว่างพิเศษอนุญาตให้ใช้รหัสสั้น ๆ และต้องห้ามช่องโหว่

การทดสอบเพิ่มเติม:

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

เครื่องช่วยมองเห็นเล็กน้อย:

แสดงตัวอย่างโค้ด

ขอบคุณ @Tschallacka สำหรับการสร้างภาพข้อมูล

code-golf  matrix 
— NGN
แหล่งที่มา
4
คุณช่วยยกตัวอย่างแบบแนะนำได้ไหม ไม่ชัดเจนสำหรับฉันเมื่อไหร่หรือทำไมต้องใช้ 2, 3 หรือ 4 (ฉัน VTC ไม่ชัดเจน แต่ฉันมีค้อนตอนนี้และดูเหมือนว่าฉันเป็นคนกลุ่มน้อย)
— Shaggy
1
@Shaggy ความเข้าใจของฉันคือตัวเลขระบุ "เลเยอร์" 1D ตัวอย่างเช่น000010000→การ000212000→การ003212300→การ043212340
— georgewatson
4
ขอบคุณ @georgewatson; ดูเหมือนว่าคุณพูดถูก ไม่ชัดเจนจากข้อมูลจำเพาะซึ่งกล่าวว่า "แป้ง" ควรยึดติดกับอาหารเท่านั้นและชั้นแป้งก่อนหน้านี้จะไม่ได้รับผลกระทบ วิธีเดียวที่จะตรวจสอบว่าเป็นการถอดรหัสจากกรณีทดสอบ
— Shaggy
6
ความท้าทายต่อไปของคุณควรเป็นแบบจำลอง Friar
— Magic Octopus Urn
5
@ngn จริงเหรอ? (͡°͜ʖ͡°)
— Magic Octopus Urn

คำตอบ:

10

ลายฉลุ : 1 + 14 = 15 ไบต์

อาร์กิวเมนต์บรรทัดคำสั่ง: 3

รหัส: s<×⌈/N:1+⌈/N⋄S

ลองออนไลน์!

3 ทำซ้ำการเปลี่ยนแปลงต่อไปนี้สามครั้ง:

 s ถ้าไม่ว่าจะเป็น sเอลฟ์เป็นไม่ว่างเปล่า

 < น้อยกว่า

 × สัญลักษณ์ของ

 ⌈/N จำนวนสูงสุดของ von neuman Nย่าน

 : จากนั้นค่าใหม่จะกลายเป็น

  1+ หนึ่งบวก

  ⌈/N จำนวนสูงสุดของ von neuman Nย่าน

 ⋄ อื่น

  S ค่ายังคงไม่เปลี่ยนแปลง ( S elf)

— อาดัม
แหล่งที่มา
ไม่ควรเป็น 15 ไบต์ (14 + 1 สำหรับอาร์กิวเมนต์3) ครั้งแรกที่เห็นลายฉลุแต่ถ้าฉันเข้าใจถูกต้องมันเป็นส่วนเสริมสำหรับDyalog APLเพื่อให้ได้ประโยชน์จากเมทริกซ์? นอกจากนี้คำพูดเล็ก ๆ : ทุน N ตอนเริ่มต้นNeumannควรเป็นตัวหนาแทนที่จะเป็นตัวเล็กในตอนท้ายในคำอธิบายของคุณ :)
— Kevin Cruijssen
1
ฉันทามติใหม่ล่าสุดดูเหมือนจะบ่งบอกว่าการกำหนดค่าต่าง ๆ ของภาษาเดียวควรนับเป็นภาษาที่แยกต่างหาก แต่ฉันจะเพิ่ม
— 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
แหล่งที่มา
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
แหล่งที่มา
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
แหล่งที่มา
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

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
แหล่งที่มา
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
แหล่งที่มา
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
แหล่งที่มา
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
แหล่งที่มา
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.