เส้นทางลูกเต๋าบนตาราง

Question

คุณวางแม่พิมพ์มาตรฐานไว้ที่จุดเริ่มต้นของกริด 2 มิติที่ทอดยาวไปทุกทิศทางอย่างไม่มีที่สิ้นสุด คุณวางแม่พิมพ์โดยให้ 1 หันขึ้นด้านบน 2 หันไปในทิศทางลบ y และ 3 หันไปในทิศทาง x บวกดังแสดงในรูปด้านล่าง:

จากนั้นคุณจะดำเนินการหลายท่าด้วยดายโดยหมุน 90 องศาในทิศทางการเคลื่อนที่ ตัวอย่างเช่นถ้าคุณต้องหมุนแม่พิมพ์ในทิศ x ลบก่อน 3 จะขึ้นด้านบน 2 จะหันไปในทิศทางลบ y และ 6 จะหันไปในทิศทาง x บวก

ชุดการเคลื่อนไหว+y, +y, +x, +x, -yแสดงในรูปด้านล่างพร้อมกับตาข่ายของดายเพื่อความกระจ่าง (บางครั้งตาข่ายเรียกว่า 'มือขวาตาย')

จากนั้นเราจะอ่านใบหน้าด้านบนของแม่พิมพ์ทุกครั้งหลังการเคลื่อนไหว ในกรณีนี้มันจะอ่าน2, 6, 4, 1, 2ซึ่งเราเรียกว่าเส้นทางลูกเต๋า โปรดทราบว่าเราไม่ได้รวมใบหน้าด้านบนของแม่พิมพ์ไว้ในตำแหน่งเริ่มต้น แต่จะเป็น 1 เสมอ

หากเส้นทางของการตายเป็นเช่นนั้นก็จะส่งกลับไปที่ตารางมันเริ่มต้นในตอนท้ายของการเคลื่อนไหวของมันที่เราเรียกสิ่งนี้ว่าเส้นทางลูกเต๋าที่กลับไปที่จุดเริ่มต้น

ท้าทาย

กำหนดเส้นทางลูกเต๋าที่ไม่ว่างเปล่าเป็นอินพุต (ในรายการหรือรูปแบบที่สมเหตุสมผลอื่น ๆ ) พิมพ์ค่าที่แท้จริงหากเส้นทางลูกเต๋ากลับไปยังจุดเริ่มต้นและเป็นค่าที่ไม่ถูกต้อง โปรดทราบว่า:

• ค่าที่แท้จริงและค่าเท็จที่คุณส่งออกไม่จำเป็นต้องสอดคล้องกัน แต่คุณไม่สามารถสลับได้ (เช่นส่งออกค่าที่เป็นเท็จสำหรับเส้นทางที่กลับไปยังจุดเริ่มต้นและค่าที่แท้จริงเป็นอย่างอื่น)
• อินพุตจะถูกสร้างขึ้นอย่างดีและแสดงถึงเส้นทางลูกเต๋าที่ถูกต้อง
• ไม่มีการ จำกัด ว่าผู้ตายจะหลงไปจากแหล่งกำเนิดได้ไกลแค่ไหน

กรณีทดสอบ

Path                            -> Output
2,1                             -> true
3,1                             -> true
5,4,1,5                         -> true
2,4,1,2                         -> true
4,2,4,1                         -> true
2,4,6,2,4,6,5,4                 -> true
2,4,5,1,4,5,3,6,5,1             -> true
5,6,2,3,5,4,6,3,1,5,6,2         -> true
2,4,1,3,5,1,3,5,6,3,5,6,4,5,6,2 -> true
2                               -> false
4,5                             -> false
5,1,2                           -> false
5,6,2,1                         -> false
5,4,6,5,4,6                     -> false
5,6,4,1,5,4,2,6,5,4             -> false
5,1,2,1,5,6,5,1,2,6,4           -> false
4,6,3,1,5,6,2,1,3,6,4,1         -> false

การให้คะแนน

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

Answer 1

JavaScript (ES6),  142 ...  122121 ไบต์

['5','1','2']คาดว่าจะมีอาร์เรย์ของตัวอักษรเช่น ผลตอบแทน0หรือ1

a=>a.map(n=>D=D.map((_,i)=>D['504405076067'[d*6+i>>1]^i],p+=[w=a.length,-w,1,-1][d=D.indexOf(n)]),p=0,D=[...'254316'])|!p

ลองออนไลน์!

อย่างไร?

อาร์เรย์D[]เก็บค่าใบหน้าตามลำดับต่อไปนี้:

 index |    0   |    1   |    2   |    3   |    4   |    5
-------+--------+--------+--------+--------+--------+--------
 face  |  front | behind |  left  |  right |   top  | bottom

เราเริ่มต้นด้วยD = ['2','5','4','3','1','6']ซึ่งเป็นการวางแนวเริ่มต้นของแม่พิมพ์ตามที่อธิบายไว้ในความท้าทายโดยใช้การเข้ารหัสนี้

ทิศทางdของการย้ายครั้งต่อไปคือตำแหน่ง 0 ดัชนีของหน้าบนสุดใหม่ในD[]:

 index (d) |   0   |   1   |   2   |   3
-----------+-------+-------+-------+-------
 direction |  up   |  down | right |  left

เมื่อย้ายไปในทิศทางdที่iใบหน้า -th ในตายที่ปรับปรุงเป็นใบหน้าที่ตำแหน่งต่อไปนี้ในตายก่อนหน้านี้:

   i = | 0 | 1 | 2 | 3 | 4 | 5
-------+---+---+---+---+---+---
 d = 0 | 5 | 4 | 2 | 3 | 0 | 1
 d = 1 | 4 | 5 | 2 | 3 | 1 | 0
 d = 2 | 0 | 1 | 5 | 4 | 2 | 3
 d = 3 | 0 | 1 | 4 | 5 | 3 | 2

ตารางนี้เข้ารหัสด้วยนิพจน์ต่อไปนี้:

'504405076067'[d * 6 + i >> 1] ^ i

ลองออนไลน์!

ในแต่ละย้ำเราปรับปรุงและตำแหน่งD[] pเราเพิ่ม\$\pm 1\$ถึง\$p\$เมื่อเคลื่อนที่ในแนวนอนหรือ\$\pm w\$เมื่อเคลื่อนที่ในแนวตั้งโดยที่\$w\$คือความยาวของอาร์เรย์อินพุต (ขอบเขตด้านบนของระยะทางที่สามารถเดินทางได้ในทิศทางเดียว) เราทดสอบว่าเรากลับไปที่จุดเริ่มต้นเมื่อสิ้นสุดกระบวนการหรือไม่

Answer 2

J , 79 ไบต์

ใช้เส้นทางลูกเต๋าเป็นรายการย้อนกลับของกล่อง 0 ถึง 5

0 0-:[:+/(0,(,-@|.)=i.2){~]i.~&>[:}.(]A.~0 224 283 389 489{~i.~)&.>/\.@,&(<i.6)

ลองออนไลน์!

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

0 1 2 3 4 5เรามีลูกเต๋าเริ่มต้นรายการ เมื่อมองหาตัวเลขบนสุดถัดไปเรามี1 2 3 4เป็นดัชนี ( 0และ5จะเป็นการเคลื่อนไหวที่ผิดกฎหมาย) การใช้ดัชนีแอนนาแกรม224 283 389 489เรากำหนดรายการดำเนินการย้ายลูกเต๋า 0 1 2 3 4 5│4 0 2 3 5 1│3 0 4 1 5 2เราทำเช่นนี้สำหรับเส้นทางทั้งหมดและรวบรวมผลกลาง: อีกครั้งหลังจากที่มองหาดัชนีที่เราแผนที่พวกเขาไปสู่การเปลี่ยนแปลงการประสานงาน_1 0, 0 _1, 1 0, 0 1, 0 0รวมพวกเขาขึ้นมาและตรวจสอบว่าพวกเขาจบลงที่

ควรจะมีการบันทึกโดยแมปหมายเลขลูกเต๋า 6-4, 5-3 ไบต์, ... , 1-5 เพื่อบันทึกสองศูนย์หุ่น ( 0,และ0 ) 0 1 2 3โดยขยับดัชนีไปได้ที่จะ แต่รู้สึกผิดมากที่ฉันจะพยายามคิดวิธีอื่นก่อน :-)

Answer 3

ถ่าน , 55 48 ไบต์

≔324516θＦＳ«≔⌕θιιＭ✳⊗ι≔⭆§⪪”)⊟？2p}Þ↔～>”⁶ι§θＩκ軬∨ⅈⅉ

ลองออนไลน์! ลิงก์คือรหัสเวอร์ชันที่ละเอียด รับอินพุตเป็นสตริงของตัวเลขและเอาต์พุต Charcoal boolean กล่าวคือ-สำหรับย้อนกลับที่จุดเริ่มต้นเว้นวรรคถ้าไม่ใช่ (+2 ไบต์เพื่อลบช่องว่าง) คำอธิบาย:

≔324516θ

ตัวเลขบนแม่พิมพ์เรียงตามลำดับขวาขึ้นซ้ายลงบนล่าง

ＦＳ«

วนรอบตัวเลขที่ป้อน

≔⌕θιι

ค้นหาว่าแม่พิมพ์หมุนไปในทิศทางใด

Ｍ✳⊗ι

ไปในทิศทางนั้น

≔⭆§⪪”)⊟？2p}Þ↔～>”⁶ι§θＩκ軬∨ⅈⅉ

จัดตำแหน่งตัวเลขให้อยู่ในตำแหน่งใหม่โดยใช้ตารางค้นหา514302 052413 415320 042531ขึ้นอยู่กับทิศทาง

»¬∨ⅈⅉ

เรากลับมาที่จุดเริ่มต้นหรือไม่?

Answer 4

Python 2 , 91 ไบต์

a=b=1
t=0
for c in input():t=1+t*1j**(a*c*(a*a-c*c)*b**5%7*2/3+2*(a==c));a,b=b,c
print t==0

ลองออนไลน์!

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

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

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

ในกรณีที่เหลือยังคงตรวจจับได้ว่าจุดบกพร่องหันไปทางซ้ายจากขวานั่นคือใบหน้าทั้งสามเป็นมือซ้ายหรือมือขวา สำหรับเรื่องนี้เรายืมเคล็ดลับเกี่ยวกับพีชคณิตจากการแก้ปัญหา CW ของฉันในการกำหนดมูลค่าลูกเต๋าจากมุมมองด้านข้าง นิพจน์3*a*c*(a*a-c*c)จะเท่ากับbหรือ-bโมดูโล 7 ขึ้นอยู่กับว่าทั้งสามคนถนัดขวาหรือมือซ้าย จากนั้นนวดบางส่วนจะใช้เวลาสี่กรณีของการหันทิศทางไปยังหมายเลขที่เท่ากับ0,1,2,3โมดูโล 4 1j**เพื่อที่ว่าเราจะได้รับความซับซ้อนหมุนขวาโดยใช้สัญลักษณ์ที่ซับซ้อน

Answer 5

เยลลี่ 35 ไบต์

6RW;⁸œ?@\ḊḢ€⁼
“§ṫ²G‘×J$ṗLçƇ:19Ḣı*S¬

monadic Link ที่ยอมรับ dice-path เป็นรายการของใบหน้าใน\ $ [1,6] \ $ซึ่งให้ผล1(จริง) หากกลับไปสิ้นสุดที่จุดเริ่มต้นหรือเป็นอย่างอื่น0(falsey)

ลองออนไลน์! หรือดูชุดทดสอบ (ลบออกนานที่สุด 6 รายการเนื่องจากวิธีนี้ไม่มีประสิทธิภาพ)

อย่างไร?

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

“§ṫ²G‘×J$ṗLçƇ:19Ḣı*S¬ - Main Link: dice-path
“§ṫ²G‘                - list of code-page indices = [225,245,130,71]
      ×J$             - multiply by their indices = [225,490,390,284]
                        (these correspond to [up, down, right, left])
          L           - length (of the dice-path)
         ṗ            - Cartesian power (all lists of that length using {225,490,390,284})
            Ƈ         - filter keep those for which:
           ç          -   call Link 1 as a dyad - f(potential-path, dice-path)
             :19      - integer divide by 19 (225,490,390,284 -> 11,25,20,14)
                Ḣ     - head (get the single path that filering found)
                        (having Ḣ here rather than before the :19 saves a byte)
                 ı*   - i exponentiate (that) (11,25,20,14 -> -i,i,1,-1)
                        (yep we've mirrored but it makes no difference)
                   S  - sum
                    ¬ - logical NOT

6RW;⁸œ?@\ḊḢ€⁼ - Link 1: potential-path (as permutation indices), dice-path
6             - six
 R            - range -> [1,2,3,4,5,6]
  W           - wrap -> [[1,2,3,4,5,6]]
   ;⁸         - concatenate with the permutation indices -> [[1,2,3,4,5,6],a,b,c,...]
        \     - cumulative reduce (current-state, permuation index) by:
       @      -   with swapped arguments:
     œ?       -     permuation (of the current state) at index (permutation index)
         Ḋ    - dequeue (remove the leading [1,2,3,4,5,6])
          Ḣ€  - head of each (get the list of face-up pips)
            ⁼ - equals (the dice-path)?

Answer 6

ไพทอน 3 , ^{174 \$\cdots\$ 130} 129 ไบต์

บันทึกมหันต์15 30 35 ไบต์ขอบคุณชายคนนี้เองArnauld !!!
บันทึกอีกมหันต์3 9 10 ไบต์ขอบคุณovs !!!

def f(l,p=[3,2,4,5,1,6],v=0):
 for d in l:n=p.index(d);v+=1j**n;p=[p[int(i)]for i in'%06d'%ord('񽣾첽񥙘꘣'[n])]
 return v==0

ลองออนไลน์!

ส่งคืนTrueหากเรากลับไปที่จุดเริ่มต้นหรือFalseอย่างอื่น

พอร์ตของนีล 's คำตอบถ่านโดยใช้คณิตศาสตร์ที่ซับซ้อนเพื่อดูว่าเรากำลังกลับมาที่เราเริ่มต้น

Answer 7

R , 143 ... 116102ไบต์

การแก้ไข: -13 ไบต์โดยเปลี่ยนเป็นเชิงเส้นแทนรายการเมทริกซ์ของการเปลี่ยนจากนั้น -4 ไบต์โดยการลดรายการการเปลี่ยนลงครึ่งหนึ่งและคำนวณค่าตายด้านซ้ายด้านหลังและด้านล่างเป็น 7 ลบค่าด้านขวาค่าด้านหน้าและด้านบนในแต่ละม้วน จากนั้น -3 ไบต์โดยเปลี่ยนเป็นตัวเลขที่เข้ารหัสฐาน -7 เพื่อสร้างรายการการเปลี่ยนจากนั้น -14 ไบต์โดยการจัดเรียงรายการการเปลี่ยนใหม่เป็นขึ้น, ขวา, ลง, ซ้ายเพื่อให้คำนวณตำแหน่งใหม่ได้ง่ายขึ้นโดยใช้พาวเวอร์ของ i, และ -6 ไบต์โดยกอล์ฟรายย่อยอื่น ๆ ที่ไม่ได้เปลี่ยนแนวทาง

p=a=1:4;m=5032105982%/%7^(11:0)%%7;for(i in scan()){p[6:4]=7-p;p=p[m[q<-(p[m[a]]==i)]];F=F+1i^a[q]};!F

ลองออนไลน์!

อย่างไร?

(แสดงความคิดเห็นก่อนตีกอล์ฟ)

is_dice_loop=
function(s,                     # s = vector of top die values along path
 p=1:6,                         # p = positions of current die values
                                #     (top,front,right,left,back,bot)
 m=matrix(                      # m = matrix of transitions at each roll
  utf8ToInt(                    #     created from ASCII values of
   "bedcfabbccafddfaafeeebcd")  #     this string
   -96,                         #     -96,
  4)                            #     matrix has 4 rows.
 ){
 for(i in s){                   # Now, for each die value i along the path
  r=match(i,p[m[,1]]);          #  calculate the roll direction r
                                #  (1:4 -> up,down,right,left),
  p=p[m[r,]];                   #  then calculate the new positions of die values,
  F=F+(-.5+r%%2)*1i^(r>2)       #  and calculate the new location of the die
                                #  as a complex number (real=left->right, imaginary=down->up)
                                #  (F is initialized as 0+0i by default).
 }
 !F                             # If we end up back at 0+0i, then we've done a loop,
}                               # so NOT F is true.  

Answer 8

ภาษา Wolfram (Mathematica) , 96 91 83 74 ไบต์

<<Quaternions`
0==Tr[a={-1,-K,J,-J,K,1};(a=#**a**#/2;#-1)&[1+a[[#]]]&/@#]&

ลองออนไลน์!

Quaternions` ต้องโหลดก่อนนิยามฟังก์ชัน

<<Quaternions`          (* load the Quaternions` package *)
a={-1,-K,J,-J,K,1};     (* (a die roll of i moves the die in direction a[[i]]) *)
(a=#**a**#/2;#-1)&      (* rotate `a` in a direction, returning the direction, *)
% [1+a[[#]]]&/@#        (* taking directions one at a time from input. *)
0==Tr[ % ]&             (* check if sum of those directions returns to the origin. *)

Answer 9

Perl 5 -pF , 130 , 121 ไบต์

@A=(2,4,-1,1,-@F,@F+!s/^/1/);s/.(?=.(.))/$x+=$A[$&==$1||$&+$1!=7&&($P[$|--]=$&)&&$1==$P[$|]?$A[$|]^=1:$A[$|]]/ge;$_=$x==1

ลองออนไลน์!

วิธีการแก้ปัญหาที่แตกต่างกันตรงไปตรงมาเป็นหนึ่งใน173 ไบต์ซึ่งอาจจะแข็งแรงเล่นกอล์ฟไป165 ไบต์

แก้ไข: ฉันรู้ว่าหลังจากนั้นตรงไปตรงมาสามารถตีกอล์ฟได้ถึง136 ไบต์

แต่การเล่นกอล์ฟมากขึ้นฉันว่าแตกต่างกัน การใช้ความจริงที่ว่าผลรวมของด้านตรงข้ามคือ 7 และการติดตามตัวเลขก่อนหน้านี้อาจเป็นประโยชน์ในการหาทิศทาง

• อาร์เรย์ A:
  • [0]= {2 | 3} และ[1]= {4 | 5}: เพื่อจัดเก็บทิศทางบน (+/-) x หรือ (+/-) y โดยที่ x และ y ขึ้นอยู่กับทิศทางการเคลื่อนที่ครั้งแรกบนแกนเหล่านี้
  • ถัดไป[2..5]: เพื่อจัดเก็บตัวเลขเพื่อเพิ่มให้$xสอดคล้องกับทิศทาง
• s/^/1/: 1นำหน้าเริ่มต้น
• regex .(?=.(.)): ใช้หนึ่งหน้าตาย$&และจับภาพถัดไป$1
• $&==$1 ทิศทางกำลังเปลี่ยนไปข้างหลัง
• $&+$1==7 ทิศทางไม่เปลี่ยนการทดสอบกลับหัวเพราะไม่ต้องทำอะไร
• มิฉะนั้นทิศทางจะเปลี่ยนเป็นความเข้มงวดหรือด้านซ้ายเมื่อเทียบกับทิศทางก่อนหน้า
• อาร์เรย์ P: เก็บหน้าตายสุดท้าย [0] x, [1] y โดยที่ x และ y ขึ้นอยู่กับการเคลื่อนที่ครั้งแรก
  • $P[$|--]=$& :
    • $P[$|]=$& เพื่อจัดเก็บหน้าตายเมื่อเลี้ยวซ้ายหรือขวา
    • $|-- สลับดัชนีแกน 0/1 สำหรับ x / y
• $1==$P[$|] หน้าถัดไปจะเทียบกับหน้าสุดท้ายเมื่อเคลื่อนที่บนแกนเดียวกันถ้าเท่ากันทิศทางกำลังเปลี่ยนไปข้างหลังเมื่อเทียบกับทิศทางก่อนหน้า
• ^=1 : เพื่อสลับโดยใช้ bytwise xor (2 <-> 3) หรือ (4 <-> 5)
• $_=$x==1: ตำแหน่งเริ่มต้นเมื่อ$x==1ไม่ได้เพิ่มการเคลื่อนที่ครั้งแรก (ทิศทาง 2: -1)