ลองนึกภาพนักวางเพลิงที่เดินไปรอบ ๆ เมืองและเลือกเหยื่อตามรูปแบบที่เฉพาะเจาะจง (หรือมิฉะนั้นให้ลองนึกภาพผึ้งที่บินไปรอบ ๆ สวนและเก็บดอกไม้เพื่อผสมเกสรตามรูปแบบที่เฉพาะเจาะจงมาก ) สมมติว่าเมืองเป็นN ร Nเมทริกซ์ที่Nเป็นจำนวนเต็มสูงกว่าหรือเท่ากับ2 นักวางเพลิงเริ่มต้นจากมุมบนซ้ายและกำหนดจุดMบ้านต่อหน้าพวกเขา (โดยที่Mคือจำนวนบ้านที่พวกเขากำลังอยู่ในขณะนี้) ในขณะที่เปลี่ยนทิศทางที่มันเคลื่อนเข้าหลังไฟแต่ละครั้งตามลำดับ ตะวันออก⟶ใต้⟶ตะวันตก⟶เหนือ⟶ตะวันออก⟶ใต้ ... และอื่น ๆ เพลงกล่อมเด็กของผู้วางเพลิงคือมูลค่าของMที่ทำให้พวกเขาออกจากเมือง (เช่นบ้านหลังสุดท้ายที่พวกเขาไปเยี่ยมก่อนหยุดสิ่งที่น่ารังเกียจ) นี่เป็นวิธีที่ง่ายต่อการเข้าใจด้วยตัวอย่าง ใช้เมทริกซ์ต่อไปนี้เป็นตัวอย่าง:

3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 1 1

• เราเริ่มต้นที่มุมบนซ้ายดังนั้นM = 3 ( Xทำเครื่องหมายตำแหน่งปัจจุบันและก่อนหน้าของผู้วางเพลิง):

  X 2 3 2 7
  3 1 4 1 6
  2 5 3 1 1
  4 4 3 2 4
  1 1 1 1 1 1
  

• ตามคำสั่งที่รู้จักกันมันไปทางทิศตะวันออกM (3)จุดและที่ดินบน2ดังนั้นMเปลี่ยนแปลงตาม:

  X 2 3 X 7
  3 1 4 1 6
  2 5 3 1 1
  4 4 3 2 4
  1 1 1 1 1 1
  

• จากนั้นมันจะไปทางใต้2จุดและMตอนนี้เป็น1 :

  X 2 3 X 7
  3 1 4 1 6
  2 5 3 X 1
  4 4 3 2 4
  1 1 1 1 1 1
  

• ตอนนี้มันเคลื่อนที่1จุดไปยังทิศตะวันตกและMกลายเป็น3 :

  X 2 3 X 7
  3 1 4 1 6
  2 5 XX 1
  4 4 3 2 4
  1 1 1 1 1 1
  

• หลังจากที่มันเคลื่อนไปทางเหนือ3จุดมันจะออกจากเมือง! ดังนั้น3คือเพลงกล่อมเด็กของนักวางเพลิง:

      X
  X 2 3 X 7
  3 1 4 1 6
  2 5 XX 1
  4 4 3 2 4
  1 1 1 1 1 1
  

รับเมทริกซ์N × N (คุณสามารถเลือกใช้Nเป็นอินพุตได้เช่นกัน) ค้นหาเพลงกล่อมเด็กของนักวางเพลิง ฉันได้เขียนโปรแกรมที่คุณสามารถสร้างกรณีทดสอบมากขึ้นและเห็นภาพเส้นทางของการวางเพลิง: ลองออนไลน์!

• คุณอาจจะคิดว่าวางเพลิงไม่ได้กล่อม (นั่นคือมันเป็นจริงจะได้รับจากเมทริกซ์)
• เมทริกซ์จะมีจำนวนเต็มบวกน้อยกว่าหรือเท่ากับ9 (หลัก) เพื่อความเรียบง่าย โซลูชั่นที่จัดการกับจำนวนเต็มบวกใด ๆ ยินดีต้อนรับอย่างสมบูรณ์
• โปรดทราบว่านักวางเพลิงสามารถลงจอดในจุดที่พวกเขาเผาไปแล้วในกรณีที่ความรู้สึกที่พวกเขาเคลื่อนไหวแตกต่างจากครั้งแรก ในสถานการณ์ดังกล่าวเพียงแค่รับค่าขององค์ประกอบนั้นและย้ายอีกครั้งตามปกติ
• คุณสามารถแข่งขันในภาษาการเขียนโปรแกรมใด ๆและสามารถรับอินพุตและให้เอาต์พุตผ่านวิธีการมาตรฐานใด ๆในขณะที่รับทราบว่าช่องโหว่เหล่านี้ถูกห้ามโดยค่าเริ่มต้น นี่คือรหัสกอล์ฟดังนั้นการส่งสั้นที่สุด (เป็นไบต์) สำหรับทุกภาษาที่ชนะ

กรณีทดสอบ

-------------
9 2 3
1 7 2
8 7 6

เพลงกล่อมเด็ก: 9
-------------
2 1 2 1
3 1 1 2
1 2 2 1
1 1 1 3

เพลงกล่อมเด็ก: 2
-------------
3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 1 1

เพลงกล่อมเด็ก: 3
-------------
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2
1 2 1 2 1 2

เพลงกล่อมเด็ก: 2
-------------
3 2 1 2 1 1 1
2 3 2 3 2 1 1
2 1 1 1 3 3 1 2
3 1 1 1 1 1 1 1
4 5 2 3 1 1 1
1 2 1 2 1 2 2
1 2 2 3 2 1 2

เพลงกล่อมเด็ก: 3
-------------

เมทริกซ์ในรูปแบบอื่น:

[[9, 2, 3], [1, 7, 2], [8, 7, 6]]
[[2, 1, 2, 1], [3, 1, 1, 2], [1, 2, 2, 1], [1, 1, 1, 1, 3]]
[[3, 2, 3, 2, 7], [3, 1, 4, 1, 6], [2, 5, 3, 1, 1], [4, 4, 3, 2, 4], [ 1, 1, 1, 1, 1]]
[[1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2, 1], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2,]
[[3, 2, 1, 2, 1, 1, 1], [2, 3, 2, 3, 2, 1, 1], [2, 1, 1, 1, 1, 3, 1, 2], [ 3, 1, 1, 1, 1, 1, 1], [4, 5, 2, 3, 1, 1, 1], [1, 2, 1, 2, 1, 2, 2], [1, 2, 2, 3, 2, 1, 2]]

กรณีการทดสอบที่ห้าคือที่น่าสนใจมากที่จะเห็นภาพ

MATL , 32 ไบต์

JQ6*`G5thYay&Zj3$)wyJ2@-^*+8M]b&

ลองออนไลน์! หรือตรวจสอบกรณีทดสอบทั้งหมด

มันทำงานอย่างไร

เมทริกซ์อินพุทจะถูกเสริมด้วยกรอบห้าศูนย์ดังนั้นตัวอย่าง

3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 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 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 3 2 3 2 7 0 0 0 0 0
0 0 0 0 0 3 1 4 1 6 0 0 0 0 0
0 0 0 0 0 2 5 3 1 1 0 0 0 0 0
0 0 0 0 0 4 4 3 2 4 0 0 0 0 0
0 0 0 0 0 1 1 1 1 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 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

เฟรมของศูนย์จะใช้เพื่อตรวจจับเมื่อผึ้งวางเพลิงออกจากเมทริกซ์ ส่วนขยายที่มีห้าศูนย์เพื่อให้แน่ใจว่าmodularกระจัดของความยาวถึง9ในทิศทางใด ๆ จากส่วนใดของรายการที่ไม่ใช่ศูนย์จะถูกต้องที่ดินในศูนย์โดยไม่ต้องตัดไปรอบ ๆ เพื่อเข้าภัณฑ์บาง

ในพิกัดเมทริกซ์ผึ้งเริ่มต้นที่รายการ(6,6)ของเมทริกซ์ส่วนขยาย มันอ่านรายการนั้นและปรับปรุงพิกัดตามที่ต้องการโดยใช้การกระจัด (แบบแยกส่วน) ของความยาวการอ่านในทิศทางที่สอดคล้องกัน 0นี้ซ้ำในวงจนกว่ามูลค่าการอ่านคือ รายการที่ถูกอ่านก่อนหน้านั้น (เช่นรายการที่ไม่ใช่ศูนย์สุดท้าย) คือเอาต์พุต

พิกัดจะถูกเก็บไว้เป็นจริงจำนวนเชิงซ้อนดังนั้นสำหรับตัวอย่างที่จะกลายเป็น(6,6) 6+6jวิธีนี้ทำให้สามารถรับรู้ทิศทางวงกลมทั้งสี่ได้ในฐานะพลังของหน่วยจินตภาพ อำนาจที่สอดคล้องกัน ( j, 1, -jหรือ-1) คูณด้วยรายการอ่านที่จะได้รับการกระจัดที่ซับซ้อนซึ่งจะใช้สำหรับการปรับปรุงพิกัด

ค่าที่อ่านต่อเนื่องจะถูกเก็บไว้ในสแต็ก เมื่อออกจากลูปสแต็กจะมีค่าการอ่านที่ไม่เป็นศูนย์ทั้งหมดตามลำดับจากนั้นอ่านค่าล่าสุดซึ่งก็คือ0พิกัดที่ซับซ้อนล่าสุด ดังนั้นองค์ประกอบอันดับสามคือเอาท์พุทที่ต้องการ

JavaScript (ES6), 70 68 ไบต์

m=>(g=d=>(n=(m[y]||0)[x])?g(--d&3,x-=d%2*(y+=--d%2*n,L=n)):L)(x=y=0)

ลองออนไลน์!

แสดงความคิดเห็น

m => (                        // given m = input matrix
  g = d =>                    // g = recursive function taking the direction d
    (n = (m[y] || 0)[x]) ?    // let n be the content of the current cell; if it's defined:
      g(                      //   do a recursive call:
        --d & 3,              //     with the next direction (0 = E, 3 = S, 2 = W, 1 = N)
        x -=                  //     update x by subtracting ...
          d % 2 * (           //       ... ((d - 1) % 2) * n
            y += --d % 2 * n, //       and update y by adding ((d - 2) % 2) * n
            L = n             //       save n into L
          )                   //     end of x update
      )                       //   end of recursive call
    :                         // else:
      L                       //   stop recursion and return L
)(x = y = 0)                  // initial call to g() with x = y = d = 0

เนื่องจากสัญญาณของโมดูโลใน JS คือของเงินปันผลทิศทางมีการปรับปรุงด้วยวิธีนี้:

 d | d' = --d&3 | dx = -(d%2)  | dy = --d%2 | direction
---+------------+--------------+------------+------------------
 0 |     3      | -(-1%2) = +1 | -2%2 =  0  | (+1,  0) = East
 3 |     2      | -( 2%2) =  0 |  1%2 = +1  | ( 0, +1) = South
 2 |     1      | -( 1%2) = -1 |  0%2 =  0  | (-1,  0) = West
 1 |     0      | -( 0%2) =  0 | -1%2 = -1  | ( 0, -1) = North

Charcoalขนาด25 18 ไบต์

ＰＳ↶ＷＫＫ«≔ιθ×Ｉι¶↷»⎚θ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

ＰＳ

พิมพ์สตริงป้อนข้อมูล แต่อย่าย้ายตำแหน่งพิมพ์

↶

หมุนเดือยไปทางซ้ายเพื่อให้ทิศทางการพิมพ์เพิ่มขึ้น

ＷＫＫ«

ทำซ้ำในขณะที่มีตัวละครอยู่ใต้ตำแหน่งการพิมพ์

≔ιθ

บันทึกตัวละครในตัวแปร

×Ｉι¶

นำตัวละครไปเป็นตัวเลขแล้วพิมพ์บรรทัดใหม่จำนวนมาก เมื่อทิศทางการพิมพ์สิ้นสุดลงจึงทำให้การพิมพ์เป็นแนวนอน ผลที่สุดคือเราได้ย้ายตำแหน่งการพิมพ์ไปในทิศทางที่ต้องการตามจำนวนที่กำหนดโดยหมายเลขใต้ตำแหน่งการพิมพ์

↷»

หมุนเดือยเพื่อให้บรรทัดใหม่ถัดไปย้ายตำแหน่งการพิมพ์ในทิศทางต่อไปตามเข็มนาฬิกาสำหรับรอบต่อไปของลูป

Ｆ⟦ωθ⟧¿ιι⎚

น่าเสียดายที่เรายังคงมีการป้อนข้อมูลที่ยุ่งเหยิงของเราผ้าใบและน่าเสียดายยิ่งถ้าเราล้างผ้าใบเรายังล้างตัวแปรของเรา ดังนั้นนี่คือเคล็ดลับเล็กน้อย: รายการของสตริงว่างและตัวแปรนั้นวนซ้ำกัน ในการผ่านครั้งแรกของลูปตัวแปรลูปจะว่างเปล่าดังนั้นผ้าใบและตัวแปรลูปและตัวแปรผลลัพธ์จะถูกล้างทั้งหมด แต่การวนซ้ำยังไม่เสร็จ! ในรอบที่สองของลูปเรายังคงสามารถเข้าถึงตัวแปรของเราที่เก็บรักษาไว้อย่างระมัดระวังในรายการลูปของเรา มันก็ยังคงพิมพ์

⎚θ

ล้าง Canvas และพิมพ์ตัวแปรที่บันทึกไว้ (ขอบคุณ @ ASCII- สำหรับการแก้ไขเป็นถ่านเท่านั้น)

Python 2 , 85 84 ไบต์

a=input();x=y=e=0;d=1
while-1<y<len(a)>x>=0:v=a[y][x];x+=v*d;y+=e*v;d,e=-e,d
print v

ลองออนไลน์!

เคล็ดลับหมวกให้กับMr. Xcoderขนาด 1 ไบต์

Charcoal , 50 49 46 34 33 26 ไบต์

ＮθＥθＳＭθ↑ＷＫＫ«ＭＩι✳⊗Ｌυ⊞υι»⎚⊟υ

ลองออนไลน์

ลิงก์คือโค้ดเวอร์ชัน verbose

อินพุตต้องเป็นNบนบรรทัดของตัวเองจากนั้นบรรทัดของอาร์เรย์บนบรรทัดแยกหลังจากนั้น

มีวิธียินดีต้อนรับและต้องการวิธีใดก็ตามเพราะฉันไม่ใช่นักกอล์ฟที่เก่งใน Charcoal!

-12 ไบต์ขอบคุณ @Neil! -1 ไบต์ต้องขอบคุณ @ ASCII เท่านั้น! -7 ไบต์ขอบคุณ @ ASCII เท่านั้น (เปลี่ยนข้อบกพร่องที่ทำให้Clearตัวแปรรีเซ็ต)

สีแดง 145 ไบต์

func[b][h:[0 1 0 -1 0]x: y: 1 i: 0
until[y: h/(i: i % 4 + 1) *(t: b/(y)/(x)) + y x: h/(i + 1) * t + x none = b/(y) or(x < 1 or(x > length? b))]t]

ลองออนไลน์!

อ่านเพิ่มเติมได้:

f: func[b][
    h: [0 1 0 -1 0]                                ; step lengths (combined for x and y) 
    x: y: 1                                        ; starting coords (1,1)
    i: 0                                           ; step counter 
    until[
        y: h/(i: i % 4 + 1) * (t: b/(y)/(x)) + y   ; next y; t stores the lullaby
        x: h/(i + 1) * t + x                       ; next x
        none = b/(y) or (x < 1 or (x > length? b)) ; until x or y are not valid indices
    ]
    t                                              ; return the lullaby
]

Perl 6 , 62 ไบต์

{$^w;$^m[0,{$_+$m[$_]*(1,$w,-1,-$w)[$++%4]}...{!$m[$_]}][*-2]}

ลองออนไลน์!

ใช้เมทริกซ์เป็นรายการแบบเรียบและความกว้าง

ทำความสะอาด , 141 ไบต์

import StdEnv
d=[0,1,1,0,0,-1,-1,0:d]
$m[x,y]n[a,b:l]#r=size m
#u=x+a*n
#v=y+b*n
|0>u||0>v||u>=r||v>=r=n= $m[u,v]m.[u,v]l
?m= $m[0,0]m.[0,0]d

ลองออนไลน์!

กำหนดฟังก์ชั่น? :: {#{#Int}} -> Intการใช้อาร์เรย์ที่ไม่ได้ทำกล่องของอาร์เรย์ที่ไม่มีกล่องของจำนวนเต็มและส่งคืนผลลัพธ์

Java 8, 121 ไบต์

m->{int l=m.length,x=0,y=0,f=0,r=0;for(;x*y>=0&x<l&y<l;x+=f<1?r:f==2?-r:0,y+=f==1?r:f>2?-r:0,f=++f%4)r=m[y][x];return r;}

ลองออนไลน์

ทางเลือกที่มีจำนวนไบต์ 121 ไบต์เดียวกัน:

m->{int l=m.length,x=0,y=0,f=0,r=0;try{for(;;x+=f<1?r:f==2?-r:0,y+=f==1?r:f>2?-r:0,f=++f%4)r=m[y][x];}finally{return r;}}

ใช้ลองในที่สุดแทนที่จะตรวจสอบว่า x,y -coordinate ยังคงอยู่ในขอบเขต

ลองออนไลน์

คำอธิบาย:

m->{                   // Method with integer-matrix parameter and integer return-type
  int l=m.length,      //  Dimensions of the matrix
      x=0,y=0,         //  x,y coordinate, starting at [0,0]
      f=0,             //  Direction-flag, starting at 0 (east)
      r=0;             //  Result-integer
  for(;x*y>=0&x<l&y<l  //  Loop as long as the x,y coordinates are still within bounds
      ;                //    After every iteration:
       x+=f<1?         //     If the direction is east:
           r           //      Increase the `x` coordinate by `r`
          :f==2?       //     Else-if the direction is west:
           -r          //      Decrease the `x` coordinate by `r`
          :            //     Else (it's north/south):
           0,          //      Leave the `x` coordinate the same
       y+=f==1?        //     If the direction is south:
           r           //      Increase the `y` coordinate by `r`
          :f>2?        //     Else-if the direction is north:
           -r          //      Decrease the `y` coordinate by `r`
          :            //     Else:
           0,          //      Leave the `y` coordinate the same
       f=++f%4)        //     Go to the next direction (0→1→2→3→0)
    r=m[y][x];         //   Set `r` to the value of the current cell
  return r;}           //  Return the last `r` before we went out of bounds

Perl 5 , 92 ไบต์

sub b{1while eval join'&&',map{/./;map"(\$$_$&=".'$n=$_[$y][$x])'.$',x,'y'}'+<@_','->=0';$n}

ลองออนไลน์!

อย่างไร?

ชุดของแผนที่ที่ซ้อนกันและการเข้าร่วมสร้างสิ่งนี้:

($x+=$n=$_[$y][$x])<@_&&($y+=$n=$_[$y][$x])<@_&&($x-=$n=$_[$y][$x])>=0&&($y-=$n=$_[$y][$x])>=0

ซึ่งจะถูกประเมินเพื่อพิจารณาว่าลูปสิ้นสุดหรือไม่ เนื่องจาก Boolean ถูกประเมินจากซ้ายไปขวาค่าของ$nการเปลี่ยนแปลงจริง (สูงสุด) สี่ครั้งระหว่างการประเมิน เนื่องจากตรรกะบูลีนลัดวงจรใน Perl ค่าของ$nเป็นกล่อมเมื่อออกจากวง

Python 3 , 85 84 ไบต์

xcoder: -1 (ฉันไม่เคยจำเคล็ดลับ + ~)

def f(x):
 r=c=0
 while-1<r:d=x[r][c];r,c=len(x)-c+~d,r;x=[*zip(*x)][::-1]
 return d

ลองออนไลน์!

แทนที่จะเคลื่อนที่ในทิศทางที่ต่างกัน (E, S, W, N) โซลูชันนี้จะเคลื่อนที่ไปทางทิศตะวันออกเสมอและหมุนตัวนับตารางตามเข็มนาฬิกาทุกครั้งที่เคลื่อนไหว หลังจากหมุนแล้วคอลัมน์สุดท้ายคือแถวแรกดังนั้นหากดัชนีแถวน้อยกว่าศูนย์หมายความว่าเราวิ่งออกจากกระดาน

เรติน่า 161 ไบต์

.
 $.%`*_#$&*
(?<=(.+¶)+|^)
A ¶A$#1*
~(K`{`^X\1YZ¶1S$4¶1XYZ¶2$4$2$4$3¶2XYZ¶3S¶3XY\1Z¶S
X
(_$*)(A_$*)
Y
( _$*)
Z
(?=\n\D$*\2\b.$*\3#(_+))
)`S
$$4$$2$$3
L$0`_+
$.0

ลองออนไลน์!