มดเดินไปตามขอบ (ไม่ใช่ใบหน้า) ของคิวบ์โครงลวด แต่ละจุดสุดยอดที่พบนำเสนอด้วยส้อมที่สองขอบใหม่ออก เลือกมดวิธีที่จะเปิด - หรือleft rightทิศทางเหล่านี้สัมพันธ์กับมดซึ่งหันหน้าไปทางจุดยอดและอยู่นอกลูกบาศก์ เป้าหมายของคุณคือการพิจารณาจากลำดับleft/ rightตัวเลือกที่มดใช้ไม่ว่าจะสิ้นสุดที่ตำแหน่งเดียวกันกับที่เริ่มต้นหรือไม่

ตัวอย่างเช่นหากมดเลี้ยวซ้ายสี่ครั้ง ( left left left left) มันจะเคลื่อนที่กลับทวนเข็มนาฬิกาเป็นสี่เหลี่ยมจัตุรัสและสิ้นสุดที่ตำแหน่งเดิมที่เริ่มต้น แต่ถ้ามันไปleft left left left rightมันจะจบลงที่จุดที่แตกต่างของลูกบาศก์ นอกจากนี้ถ้ามันไปleft right right right leftก็จะสิ้นสุดลงที่ขอบเริ่มต้นของมัน แต่หันหน้าไปทางจุดยอดตรงข้ามซึ่งไม่นับเป็นตำแหน่งเดียวกัน

เส้นทางของมดอาจทำซ้ำขอบรวมถึงขอบเริ่มต้น แต่สิ่งที่สำคัญคือที่ที่มันจบลงหลังจากลำดับทั้งหมด

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

(แก้ไข: หากภาษาของคุณไม่สามารถสร้างฟังก์ชั่นที่มีชื่อได้ก็สามารถใช้ฟังก์ชั่นที่มีอินพุตและเอาท์พุตผ่าน STDIN / การพิมพ์หรือสแต็กหากไม่สามารถทำได้ให้ทำเป็นตัวอย่างที่บันทึกและอินพุต ตัวแปร.)

อินพุต

ลำดับของleft/ rightการตัดสินใจของความยาว0เป็น31รวมแสดงในรูปแบบที่คุณเลือก นี่อาจเป็นชุดตัวอักษรR/ Lรายการหมายเลข1/ -1หรืออาเรย์ของบูลีน ไม่มีอะไรวิเศษเหมือนการให้พวกเขาเป็นชื่อวิธีการหรือสตริงที่มีประโยชน์สำหรับรหัสของคุณ

กรุณาโพสต์กรณีทดสอบในรูปแบบของคุณถ้ามันแตกต่างจากกรณีทดสอบด้านล่าง

เอาท์พุต

True/ False, 0/ 1หรือ analogues ในภาษาของคุณ

เกณฑ์การชนะ

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

กรณีทดสอบ

True กรณี (หนึ่งรายการต่อบรรทัดรายการที่สองคือรายการว่าง):

1 1 1 1

-1 -1 -1 -1
1 -1 1 -1 1 -1
1 1 -1 -1 1 1 -1 -1
-1 1 1 -1 -1 1 1 -1
1 1 1 -1 -1 -1 -1 1
1 -1 -1 1 -1 -1
1 1 1 1 -1 -1 -1 -1 1 -1 -1 1 -1 -1
-1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

False กรณี (หนึ่งต่อบรรทัด):

1
1 1
1 1 1
-1 1
1 -1 -1 -1 1
1 -1 -1 1 1
-1 1 -1 1
1 1 1 1 -1
-1 -1 1 -1 1 -1 -1 1
1 -1 1 1 1 1 -1 -1 -1 1 1 -1 -1 -1

นี่คือกรณีทดสอบเช่นเดียวกันกับL'และR' s

True กรณี:

RRRR

LLLL
RLRLRL
RRLLRRLL
LRRLLRRL
RRRLLLLR
RLLRLL
RRRRLLLLRLLRLL
LLLRLLRRLRLRRRRRRRRRRRRRRRRR

False กรณี:

R
RR
RRR
LR
RLLLR
RLLRR
LRLR
RRRRL
LLRLRLLR
RLRRRRLLLRRLLL

ความท้าทายเครดิตเพิ่มเติม

สิ่งเดียวกัน แต่มีเฟมากกว่าก้อน ดูHunt the Wumpusเพื่อหาแนวคิด

GolfScript, 24 chars (19 สำหรับตัวฟังก์ชันเท่านั้น)

คณิตศาสตร์ FTW!

{3,.@{[+~@\{@}*~]}/=}:f;

ทดสอบโซลูชันนี้ทางออนไลน์

ฟังก์ชันนี้รับอินพุตเป็นอาร์เรย์ไบนารี่ (0 สำหรับซ้าย, 1 สำหรับขวา) และส่งคืน 1 สำหรับจริงและ 0 สำหรับเท็จ

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

โดยเฉพาะอย่างยิ่งเราสามารถเป็นตัวแทนของการเลี้ยวซ้ายและขวาเป็นสองแผนที่เชิงเส้นในสามมิติที่เลี้ยวซ้ายสอดคล้องกับการหมุน 90 °รอบแกนxเช่นแผนที่ ( x , y , z ) → ( x , z , - y ) และทางเลี้ยวขวาสอดคล้องกับการหมุน 90 °รอบแกนyเช่นแผนที่ ( x , y , z ) → ( z , y , - x )

ที่จุดเริ่มต้นของฟังก์ชั่นเราเพียงแค่ตั้งค่าเวกเตอร์สามองค์ประกอบที่มีค่าบวกที่แตกต่างกัน (1, 2, 3) นำลำดับการหมุนแผนที่มาใช้กับมันและตรวจสอบว่าเวกเตอร์ที่เกิดขึ้นนั้น

(อันที่จริง, เพื่อบันทึกสองสามตัวอักษร, จริง ๆ แล้วฉันเปลี่ยนพิกัดเพื่อให้เวกเตอร์เริ่มต้นคือ (0, 1, 2) และแผนที่คือ ( x , y , z ) → ( x , z , −1− y ) และ ( x , y , z ) → ( z , y , −1− x ) แต่ผลลัพธ์สุดท้ายเหมือนกัน)

ps ขอขอบคุณผู้มีความภาคภูมิใจที่ได้ค้นพบข้อผิดพลาดในเวอร์ชั่นดั้งเดิมของโซลูชันนี้

Perl, 58 ตัวอักษร

ตามที่ร้องขอในความคิดเห็นต่อไปนี้เป็นวิธีการแก้ปัญหาเดียวกันส่งไปยัง Perl (เวอร์ชันนี้ใช้พิกัดที่ไม่เปลี่ยนรูปจริงเนื่องจากการแปลงไม่มีการบันทึกตัวอักษรใน Perl)

sub f{@a=@b=1..3;@a[$_,2]=($a[2],-$a[$_])for@_;"@a"eq"@b"}

ทดสอบโซลูชันนี้ทางออนไลน์

โบนัส: Ant บน Dodecahedron (GolfScript, 26 ตัวอักษร)

{5,.@{{2*2%[~\]}*(+}/=}:f;

ทดสอบโซลูชันนี้ทางออนไลน์

เช่นเดียวกับฟังก์ชั่น ant-on-a-cube ข้างต้นฟังก์ชั่นนี้ใช้เป็นอินพุตอาร์เรย์แบบไบเรกต์ (0 สำหรับซ้าย, 1 สำหรับขวา) และส่งคืน 1 หากมดจบลงที่ตำแหน่งและทิศทางเดียวกันกับที่เริ่มในหรือ 0 มิฉะนั้น.

โซลูชันนี้ใช้การแสดงนามธรรมที่เป็นนามธรรมมากกว่าโซลูชันคิวบ์ด้านบน โดยเฉพาะอย่างยิ่งมันใช้ความจริงที่ว่ากลุ่มสมมาตรการหมุนของโดเดนเดอร์เฮดโรนนั้น isomorphic กับกลุ่มสลับ A ₅คือกลุ่มของการเรียงสับเปลี่ยนของห้าองค์ประกอบ ดังนั้นการหมุนที่เป็นไปได้ในแต่ละครั้งของ dodecahedron (ที่แมปขอบกับขอบและจุดยอดถึงจุดยอด) สามารถแสดงได้อย่างมีเอกลักษณ์โดยเป็นการเรียงสับเปลี่ยนของอาเรย์ห้าองค์ประกอบที่มีการหมุนตามลำดับที่สอดคล้องกับการเรียงสับเปลี่ยนตามลำดับ

ดังนั้นสิ่งที่เราต้องทำคือหาพีชคณิตสองตัวLและRที่สามารถแทนการหมุนซ้ายและขวาได้ โดยเฉพาะการเรียงสับเปลี่ยนเหล่านี้จะต้องเป็น 5 รอบ (ดังนั้นการใช้พวกมันกลับคืนสู่สถานะเดิมห้าครั้ง) พวกเขาจะต้องไม่เป็นพลังของกันและกัน (เช่นR ≠ L ⁿสำหรับnใด ๆ) และพวกเขาต้องตอบสนองความสัมพันธ์ ( LR ) ⁵ = (1) โดยที่ (1) หมายถึงการเปลี่ยนแปลงตัวตน (มีผลบังคับใช้เกณฑ์นี้ระบุว่าเส้นทางLRLRLRLRLRต้องกลับสู่ตำแหน่งเดิม)

แก้ไขการเรียงสับเปลี่ยนLเพื่อเปลี่ยนบาร์เรลอย่างง่ายไปทางซ้ายเช่นการทำแผนที่ ( a , b , c , d , e ) → ( b , c , d , e , a ) เนื่องจากสามารถนำมาใช้ใน GolfScript ในเวลาเพียงสอง ตัวอักษร ( (+) เราพบว่ามีห้าตัวเลือกที่เป็นไปได้สำหรับการเปลี่ยนสับเปลี่ยนR จากนั้นฉันเลือกแผนที่ ( a , b , c , d , e ) → ( c , e , d ,b , a ), เนื่องจากมีการใช้ GolfScript ที่ค่อนข้างกะทัดรัด (อันที่จริงฉันใช้มันโดยการสอดแทรกองค์ประกอบแรกด้วย2*2%เพื่อรับ ( a , c , e , b , d ) จากนั้นสลับสององค์ประกอบสุดท้ายด้วย[~\]และในที่สุดก็ใช้การเรียงสับเปลี่ยนLโดยไม่มีเงื่อนไขเพื่อย้ายaไปยังจุดสิ้นสุด)

ลิงค์สาธิตออนไลน์ด้านบนมีบางกรณีทดสอบของเส้นทางที่ถูกต้องใน Dodecahedron ที่กลับไปยังจุดเริ่มต้นเช่น:

           # empty path
1 1 1 1 1  # clockwise loop
0 0 0 0 0  # counterclockwise loop
1 0 0 0 0 1 1 0 0 0 0 1  # figure of 8
1 0 1 0 1 0 1 0 1 0      # grand circle
1 0 0 0 1 0 0 0          # loop around two faces 
1 0 0 0 1 1 1 0 1 0 1 0 0 0 1 1 1 0 1 0  # Hamilton cycle

Python, 68

รับรายการ 1 และ -1 ยึดตามการหมุน 3D: ตรวจสอบว่าจุด (3,2,1) สิ้นสุดที่ตำแหน่งเดียวกันหลังจากใช้การหมุนแบบต่อเนื่องหรือไม่ มีการหมุนสองแบบที่เป็นไปได้ซึ่งสอดคล้องกับ 1 และ -1 แต่ละคนทำได้โดยอนุญาตให้สองพิกัดและเปลี่ยนสัญลักษณ์ของหนึ่งในนั้น พิกัดที่แน่นอนในการเปลี่ยนแปลงและการลงชื่อเพื่อเปลี่ยนแปลงไม่สำคัญ

def f(l):
 p=[3,2,1]
 for d in l:p[d],p[0]=-p[0],p[d]
 return[3,2]<p

แก้ไข: นี่เป็นวิธีแก้ปัญหาเดียวกับ "Perl, 58"

มาติกา

แรงบันดาลใจจากวิธีการแก้ปัญหาของ Ilmari Karonen สัดส่วนกลุ่มการหมุนของลูกบาศก์คือ isomorphic ไปที่ S 4

คิวบ์ 51 ไบต์

Fold[Part,r=Range@4,{{2,3,4,1},{3,4,2,1}}[[#]]]==r&

ใช้รายการ1s และ-1s เป็นอินพุต

ลองออนไลน์!

Dodecahedron ขนาด 55 ไบต์

Fold[Part,r=Range@5,{{2,3,4,5,1},{3,5,4,2,1}}[[#]]]==r&

ใช้รายการ1s และ-1s เป็นอินพุต

ลองออนไลน์!

C (gcc) , 118 116 107 105 ไบต์

-2 ไบต์ต้องขอบคุณแมวป่า

f(char*s){char*p,n[]="@ABCDEFG",y;for(;*s;s++)for(p=n;*p;*p++^=*s^82?y%2+1:4-(y&2))y=*p/2^*p;y=n[2]==66;}

ลองออนไลน์!

สมมติว่าเราให้ลูกบาศก์พิกัดต่อไปนี้:

            (1,1,1)       (1,1,0)
          G +--------------+ C
           /|             /|
          / |            / |
         /  |    (0,1,0)/  |
(0,1,1) +--------------+ D |
      H |   |          |   |
        |   |          |   |
        | F +----------|---+ (1,0,0)
        |  /(1,0,1)    |  / B           x
        | /            | /           y / 
        |/             |/            |/  
      E +--------------+ A      z ---*   
        (0,0,1)       (0,0,0)

หากเราเริ่มจากมุม D การเคลื่อนที่ไปยัง C หรือ H สามารถคิดได้ว่าเป็นการหมุนลูกบาศก์รอบตัวเราแทน การเลื่อนไปทางขวาหมายถึงการหมุนทวนเข็มนาฬิการอบแกน Z และการเลื่อนไปทางซ้ายจะหมายถึงการหมุนตามเข็มนาฬิการอบแกน X นี่เป็นเพียงการหมุนสองครั้งที่เราต้องใส่ใจ เนื่องจากการหมุนแต่ละครั้งนั้นมีค่าเท่ากับ 90 องศาเราจึงจินตนาการได้ว่ามุม "เลื่อน" ไปตามขอบ สำหรับการเลื่อนไปทางขวานี่หมายถึง A -> B, B -> C, C -> D, D -> A กับอีกด้านหนึ่งที่ทำ E -> F เป็นต้นสำหรับการเลื่อนไปทางซ้ายเราแทนที่จะได้ A -> E, E - > H เป็นต้น

เนื่องจากแต่ละมุมจะเลื่อนไปตามขอบเท่านั้นนั่นหมายถึงเพียงมิติเดียวของแต่ละจุดที่เปลี่ยนแปลงสำหรับแต่ละการหมุน เมื่อ B ย้ายไปที่ C ส่วนประกอบของ y จะเปลี่ยนเท่านั้นและเมื่อ H ย้ายไปที่ D จะเปลี่ยนเฉพาะส่วนประกอบ z และอื่น ๆ นอกจากนี้เนื่องจากพิกัดถูก จำกัด ที่ 0 และ 1 เราสามารถคิดว่าแต่ละจุดเป็นเลขฐานสองโดยที่บิตที่เหมาะสมพลิกไปตามการเคลื่อนไหว

เราจะเห็นได้ว่าสำหรับการเคลื่อนไหวไปทางขวา A และ C พลิก x ของพวกเขาในขณะที่ D และ B พลิก y ของพวกเขา ถ้าเราเปลี่ยนเปอร์สเปคทีฟเพื่อดูที่ด้านข้างของส่วนหัวของคิวบ์และละเว้นส่วนประกอบ z (ซึ่งไม่เปลี่ยนแปลงสำหรับการหมุนนี้) เราได้รับ:

D (0,1)         C (1,1)
 +-------------+
 |             |
 |             |
 |             |
 |             |
 |             |
 |             |
 +-------------+
A (0,0)         B (1,0)

รูปแบบเกิดขึ้น: สำหรับจุดที่พลิก x, x == y ในขณะที่สิ่งที่ตรงกันข้ามนั้นเป็นจริงสำหรับคะแนนที่หมุน y ของพวกเขา นี่ถือเป็นการหมุนแบบอื่น แต่มี z แทน x

ในคำอื่น ๆ :

Right
    if (x == y) x = !x
    if (x != y) y = !y

Left
    if (z == y) z = !z
    if (z != y) y = !y

ตอนนี้เราสามารถผ่านการหมุนทั้งหมดได้อย่างง่ายดายและในตอนท้ายดูว่า D สุดท้ายตรงกับ D เริ่มต้นของเราหรือไม่

การจัดเก็บแต่ละจุดเป็นตัวเลขเดียวจะได้รับ แต่ใน C การกำหนดอาเรย์ถ่านนั้นมีขนาดเล็กกว่าอาเรย์อิน เราใช้ความระมัดระวังในการเลือกตัวละครที่มีสามบิตต่ำกว่าตรงกับ 000..111 ทำให้เป็นไปได้ที่จะไม่สนใจส่วนที่เหลือของบิต การหมุนพิกัดเป็นเรื่องของ XOR'ing ด้วย bitmask ที่เหมาะสม

Python - 110, 150

ใช้เวลาในรายการจำนวนเต็มด้วย-1สำหรับเลี้ยวซ้าย1เพื่อเลี้ยวขวา

Cube, 110:

def f(l):
    c,p='07'
    for d in l:a="100134462634671073525275"[int(c)::8];c,p=a[(a.index(p)+d)%3],c
    return'1'>c

ทดสอบ:

l=map(int,'1 1 1 1'.split())
print f(l)

Dodecahedron, 150:

def f(l):
    c,p='0J'
    for d in l:a="I5H76E8BBA8F76543100JI0J21D3A5C7E9CJI2132H4GF94C6D98AHGBEDGF"[int(c,36)::20];c,p=a[(a.index(p)+d)%3],c
    return'1'>c

Marbelous 188

การขโมยอัลกอริทึมของIlmari Karonen ที่ไร้ยางอายเพื่อจุดประสงค์ในการแสดงภาษาใหม่

สคริปต์นี้คาดว่าสตริง 0x00 สำหรับซ้ายและ 0x01 สำหรับขวาบน stdin ตามด้วย 0x0A (ขึ้นบรรทัดใหม่) มันส่งออก "0" สำหรับกรณีที่ล้มเหลวและ "1" เพื่อความสำเร็จ

......@5@3FF
@0@1@2\\]]@5
010203@4=A@4
&0&0&0&0/\
MVMVMVMV..
@0@1@2@3..!!
:MV
}2}2}1}0}1}0}3
&0&1&0&1~~~~<A@P
{0{1{1{0&1&0=0&1
}0}1}2@P{2{2&030
=1=2=3&2FF}3..//
&2&2&231&2{3
\/\/\/&2!!..//

เรียกใช้ตัวอย่าง:

# echo -e "\x0\x0\x0\x1\x0\x0\x1\x1\x0\x1\x0\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1" | marbelous.py ant-on-a-cube.mbl
1

Python 2 , 57 ไบต์

f=lambda l:reduce(lambda n,x:n%4*64+n/4*16**x%63,l,27)<28

ลองออนไลน์!

สิ่งนี้ใช้การแสดงการเรียงสับเปลี่ยน

0: abcd -> dabc
1: abcd -> dcab

โดยที่ซ้ายและขวา (0 และ 1) ตรงกับความยาว 4 รอบใน 4 องค์ประกอบ เราวนซ้ำอินพุตที่ใช้การเปลี่ยนแปลงที่ระบุและตรวจสอบว่าผลลัพธ์เท่ากับค่าเริ่มต้น

เราเริ่มต้นเป็นรายการที่สี่องค์ประกอบa,b,c,d 0,1,2,3เรากระชับให้เป็นฐาน-4 หมายเลขเดียวn=abcdกับค่าเริ่มต้นn=27ที่สอดคล้องกับ0123ฐาน 4. เรายกตัวอย่างการเปลี่ยนแปลงแต่ละ arithmetically nบน

เนื่องจากผลทั้งสองเริ่มต้นด้วยการdที่เราสามารถทำได้n%4เพื่อให้สารสกัดdจากนั้นจะย้ายไปลงในตำแหน่งที่เหมาะสมn%4*64 d___ตัวเลขอื่น ๆ จะถูกสกัดเป็นabc n/4เราจำเป็นต้องแทรกค่าเหล่านี้ลงในค่าสถานที่สามค่าที่ต่ำกว่า

สำหรับทิศทางx=0เราใส่abcตามที่เป็นอยู่และเราหมุนพวกเขาเป็นx=1 cabการหมุนสามารถทำได้เป็น*16%63ซึ่งจะใช้เวลาabcในการที่จะabc00 cab(ความ%63ผิดพลาดจะเกิดขึ้นa==b==c==3แต่ค่าเหล่านี้เป็นไปไม่ได้) เนื่องจากการทำเพียงอย่างเดียว%63คือไม่มีการแสดงออกนิพจน์ขึ้นกับทิศทาง*16**x%63จะให้abcหรือcabตามที่ต้องการ

Python 2 , 55 ไบต์

f=lambda l:reduce(lambda n,x:n^(n*8%63|7*8**x),l,10)<11

ลองออนไลน์!

Haskell, 104 103 99 97 96/ 67 64 ตัวอักษร

ฉันรู้สึกว่าเทียบเท่าของขวา / ซ้ายจะเป็นประเภทข้อมูลทิศทางดังนี้:

Direction = R | L

ดังนั้นฉันจึงสันนิษฐานในคำตอบว่ามี
แก้ไข:จริง ๆ แล้วรู้ว่าบูลีนจะนำไปสู่รหัสที่สั้นกว่า True แสดงถึงการเลี้ยวซ้ายและ False หมายถึงการเลี้ยวขวา (แม้ว่าในทางเทคนิคแล้วโค้ดจะใช้งานได้เหมือนกันถ้ามันพลิก; มันสมมาตร)

96 ตัวอักษร:

m[p,l,r]b|b=[p%l,7-r-l,r]|0<1=[p%r,l,7-r-l]
p%x|odd$div p x=p-x|0<1=p+x
g l=foldl m[0..2]l<[0,2]

g คือฟังก์ชั่นที่ให้รายชื่อทิศทางจะคืนสภาพอากาศไม่ใช่มดได้กลับไปที่ตำแหน่งเดิม

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

จำนวนเต็มที่สองคือจำนวนที่จุดสุดยอดของมดจะเปลี่ยนถ้ามันจะไปทางซ้าย ตัวอย่างเช่นถ้ามดอยู่ที่จุดสุดยอด 3 และเลขจำนวนเต็มที่สองคือ 4 กว่าหลังจากเลี้ยวซ้ายจุดยอดจะเป็น 7 โปรดทราบว่านี่จะเป็นพลังของ 2 เสมอเพราะหนึ่งบิตถูกพลิกโดยการย้ายจุดยอดหนึ่ง

จำนวนเต็มที่สามเหมือนกัน แต่ไปทางขวา; ฉันรู้ว่านี่สามารถคำนวณได้โดยสองคนแรก แต่ฉันไม่รู้วิธีการ หากคุณมีความคิดโปรดบอกฉัน

สิ่งที่ควรสังเกตคือเมื่อเลี้ยวซ้ายจำนวนเต็มตัวที่สามจะยังคงเหมือนเดิมและตัวที่สองจะกลายเป็นหนึ่งระหว่าง 1 2 และ 4 ที่ไม่ใช่ทั้งจำนวนที่สองหรือที่สามซึ่งจะเท่ากับ 7 - จำนวนเต็มที่สอง - จำนวนเต็มที่สาม

ฉันเลือกวิธีนี้ในการแสดงตำแหน่งเนื่องจาก (ตามที่ระบุไว้ในย่อหน้าก่อนหน้า) มันไม่สำคัญที่จะคำนวณตำแหน่งต่อไป

คำอธิบายฟังก์ชั่น:

ฟังก์ชั่น (%) เป็นฟังก์ชั่นที่ใช้จุดยอดปัจจุบันและจำนวนเงินที่จะเปลี่ยนและเปลี่ยนมัน มันเป็นบิตที่กำลังจะเปลี่ยนและพลิกมัน (ในวิธีที่เป็นตัวเลขมาก)

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

จากนั้นฟังก์ชั่น m จะรวมกันโดยใช้ foldl (ซึ่งคล้ายกันเช่นreduceใน javascript, แต่เป็นการแสดงออกที่มากกว่า) เพื่อสร้างฟังก์ชั่น g, คำตอบสำหรับคำถามนี้

Haskell, 64 ตัวอักษร

ได้รับแรงบันดาลใจจากคำตอบของ @ alphaalpha นี่คือรุ่นที่ส่งไปยัง Haskell:

m[a,b,c,d]p|p=[b,c,d,a]|0<1=[b,d,a,c]
g l=foldl m[0..3]l<[0,1,3]

แก้ไข: ตอนนี้ฉันรู้สึกโง่อย่างไม่น่าเชื่อเพราะคำตอบของ lmari Karonen บางทีฉันอาจจะพอร์ตคำตอบของเขาเพื่อ Haskell การแก้ไขอื่น:ไม่รู้สึกงี่เง่าเหมือนคำตอบของเขาคือการ
แก้ไขที่ผิด :เปลี่ยนจากการใช้ tuples เป็นการใช้รายการเป็นOrdตัวอย่างและ[ ... ]น้ำตาล syntactic ทำให้สั้นลง

Haskell , 53 ไบต์

f=(<28).foldl(\n x->mod n 4*64+mod(div n 4*16^x)63)27

ลองออนไลน์!

ตรรกะเช่นเดียวกับคำตอบ Pythonของฉันแม้กระทั่งความคิดmodและdivเขียนนานกว่า

Haskell , 58 ไบต์

r=[1..3]
f=(==r).foldl(\[x,y,z]->(!!)[[x,-z,y],[-z,y,x]])r

ลองออนไลน์!

APL (Dyalog Unicode) , 22 ไบต์ ( SBCS ของAdám )

f←{x∊(-@3∘⌽⌽)/⍵,x←⊂⍳3}

ลองออนไลน์!

H.PWizแนะนำว่าการย้อนกลับขั้นตอนนั้นไม่ได้สร้างความแตกต่างและส่งผลให้เกิด -2 ไบต์

นี่มันน่าอายเพราะมันตั้งใจให้สั้นกว่า GolfScript อย่างน้อยฉันก็พยายาม

มีการตั้งชื่อฟังก์ชั่นfและในกรณีทดสอบ1แสดงถึงการเลี้ยวซ้าย (บูลีนจริง) และ0แสดงถึงการเลี้ยวขวา (บูลีนเท็จ) ⍬แสดงถึงรายการที่ว่างเปล่า

APL (Dyalog)ขนาด 21 ไบต์

f←{x≡(↓∪⊢∘⌽)/⍵,x←⊂⍳4}

ลองออนไลน์! (การใช้สภาพแวดล้อมการทดสอบจากคำตอบของ Erik Outgolfer )

ฉันใช้เวลาซ้ายและขวาเป็นและ1 2สิ่งนี้ใช้วิธีการเรียงสับเปลี่ยนของabcd :

1 : bcda
2 : cdba

ฉันใช้พีชคณิตที่สอดคล้องกับ1และ2เพื่อ⍳4 : 1 2 3 4ตรวจสอบว่ามันไม่เปลี่ยนแปลง

Bash , 71 65 ไบต์

f()(a=1234;for i;{ a=`tr 1-4 4$[$i?123:312]<<<$a`;};((a==1234));)

ลองออนไลน์!

เช่นเดียวกับคำตอบก่อนหน้านี้จำนวนมากให้ใช้การแทนกลุ่มการหมุนของคิวบ์ที่สร้างโดย 1234-> 4123 และ 1234-> 4312 ใช้ตัวเลขแทนตัวอักษรเพื่อให้ฉันสามารถใช้ตัวดำเนินการประกอบกับการขยายเลขคณิต คาดว่าอินพุตเป็น 0 และ 1 คั่นด้วยช่องว่างและส่งออกผ่านรหัสทางออก

บันทึกแล้ว 6 ไบต์ด้วยความเห็นของ @ manatwork!

brainfuck , 119 ไบต์, 137 ไบต์

ใช้ความจริงที่ว่ากลุ่มการหมุนของคิวบ์นั้น isomorphic ถึง $S_4$. Brainfuck ไม่มีฟังก์ชั่นเลยตั้งชื่อหรืออื่น ๆ ดังนั้นนี่เป็นโปรแกรมเต็มรูปแบบที่รับอินพุตผ่าน STDIN และส่งออกไปยัง STDOUT (หากคุณยืนยันตัวแปรให้ทำท่าค่าของเซลล์ที่โปรแกรมลงท้ายด้วยเป็นตัวแปร)

Cube, 119 ไบต์

++++>+++>++>+>,[+++[->+++<]<<<<[->>>>+<<<<]>[>]<+[[-]<[->+<]<<<[->>>+<<<]>[>]],]<[[<]>[->]<[>>]<]<[>>-<]-[----->+<]>--.

ลองออนไลน์!

++++>+++>++>+    Initialize tape as 4 3 2 1

>,[              For each input byte:

  +++[->+++<]       Add 3 and multiply by 3; if input is R, this will be 255

  <<<<[->>>>+<<<<]  Move first number to end (BCDA)

  >[>]<+[           If input wasn't R:

    [-]                Zero input cell (which is now negative 18)

    <[->+<]            Move previously moved number one slot further (BCD_A)

    <<<[->>>+<<<]      Move first number into vacated slot (CDBA)

  >[>]]

,]

<[[<]>[->]<[>>]<]     Determine whether tape is still 4 3 2 1

<[>>-<]               If not: subtract 1 from output cell

-[----->+<]>--.       Create "1" in output cell and output

Dodecahedron, 137 ไบต์

+++++>++++>+++>++>+>,[+++[->+++<]<<<<<[>>>>>+[<]>-]>[>]<+[[-]<<[[->>+<<]<<]>[>>>>>>+[<]<-]>>[>]],]<[[<]>[->]<[>>]<]<[>>-<]-[----->+<]>--.

ลองออนไลน์!

ความแตกต่างเพียงอย่างเดียวระหว่างสองโปรแกรมคือการตั้งค่าและการเรียงสับเปลี่ยน การเรียงสับเปลี่ยนซ้ายที่ใช้ที่นี่คือDCAEBซึ่งดูเหมือนว่าจะเป็นคอนจูเกตที่หายากที่สุด

เยลลี่ขนาด 14 ไบต์

3RðW;ṙN1¦ṚƊ/⁼⁸

ลองออนไลน์!

1= เลี้ยวซ้าย0= เลี้ยวขวา ขึ้นอยู่กับโซลูชัน Dyalog ของฉัน

น่าเสียดายที่ Jelly ไม่มีชื่อฟังก์ชั่น หากฉันไม่สามารถใช้อินพุตโดยนัยและจำเป็นต้องสมมติว่ามันอยู่ในตัวแปรเวอร์ชันที่มีความยาวเท่ากันนี้จะทำ:

3RµW;®ṙN1¦ṚƊ/⁼

มันถือว่าอินพุตอยู่ในการลงทะเบียน (© / ®)

Perl - 120, 214

ใช้อาร์เรย์ (รายการ) ของบูลีน

คิวบ์ (120):

sub e{$a=$b=0;for$c(@_){$_=(13,62,53,40,57,26,17,'04')[$b];$d=s/$a/($b-1)%8/e;($a,$b)=($b,substr($_,$c^$d,1))}return!$b}

โดเดกาเฮ็ดตรอน (214):

sub e{$a=$b='00';for$c(@_){$_=('01041102090307040500061807160308091502101114121019131714151016081706131819051200'=~/\d{4}/g)[$b];$d=s/$a/sprintf'%02d',($b-1)%20/e;($a,$b)=($b,substr($_,($c^$d)*2,2));}return!($b+0)}