กำหนดตัวเลข 0 ถึง 7 ถึง 8 จุดยอดของลูกบาศก์ในแบบที่คุณต้องการ ต้องกำหนดหมายเลขหนึ่งให้กับแต่ละจุดสุดยอดอย่างแน่นอน

ตัวอย่างเช่นจุดยอดของคุณอาจถูกกำหนดเช่นนี้:

  3-----1
 /|    /|
4-----2 |
| |   | |
| 5---|-0
|/    |/
6-----7

เขียนโปรแกรมที่ใช้จำนวนเต็มตั้งแต่ 0 ถึง 5 แต่ละหมายเลข 6 ตัวเหล่านี้เชื่อมโยงกับคิวบ์หน้าเดียวของคุณในแบบที่คุณต้องการ เมื่อป้อนหนึ่งในตัวเลขเหล่านี้จะต้องพิมพ์ตัวเลขสี่จุดยอดของใบหน้าที่เกี่ยวข้องไปยัง stdout ในรูปแบบตัวเลข 2 × 2 ใบหน้าจะต้องถูกมองตรงจากนอกลูกบาศก์ การหมุนใบหน้าทั้ง 4 ใบหน้านั้นถูกต้อง

ตัวอย่างเช่นถ้า 0 เกี่ยวข้องกับด้านหน้าของคิวบ์ตัวอย่างด้านบนนี่จะเป็นเอาต์พุตที่ถูกต้องสำหรับอินพุต0:

42
67

ใบหน้าอาจถูกมองด้วยการหมุน 90 °ดังนั้นสิ่งเหล่านี้จึงถูกต้อง:

27
46

76
24

64
72

เอาต์พุตนี้ (และการหมุน) ไม่ถูกต้องเนื่องจากดูจากด้านที่ผิดของใบหน้า:

24
76

แนวคิดเดียวกันนี้ใช้กับใบหน้าอื่น ๆ ทั้งหมด เช่นหาก 1 เชื่อมโยงกับส่วนหลังส่วนหน้าข้อมูลขาเข้า1อาจสร้างผลลัพธ์13[newline]05(และ31[newline]50อาจไม่ถูกต้อง)

ดังนั้นความท้าทายที่แท้จริงคือการเลือกหมายเลขจุดสุดยอดและการหมุนของคุณเพื่อให้การแปลอินพุตเป็นตัวเลข 4 จุดนั้นง่ายและสั้น

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ Tiebreaker เป็นโพสต์ก่อนหน้า (ตัวนับไบต์ที่มีประโยชน์ )

หมายเหตุ

• คุณสามารถเขียนฟังก์ชั่นแทนโปรแกรมได้ ควรใช้จำนวนเต็มตั้งแต่ 0 ถึง 5 และพิมพ์หรือส่งกลับสตริงกริด 2 × 2 หลัก
• รับอินพุตจาก stdin, command line หรือ function arg คุณอาจจะถือว่าอินพุตนั้นถูกต้อง
• เอาต์พุตอาจมีทางเลือกขึ้นบรรทัดใหม่
• อย่าลืมบอกจุดสุดยอดและหมายเลขใบหน้าที่คุณเลือก

CJam, 23 16 ไบต์

อาจมีทางออกทางคณิตศาสตร์ที่สง่างามสำหรับปัญหานี้ แต่ฉันไม่รู้เลยว่าจะหามันได้อย่างไรดังนั้นมันจึงถูกเข้ารหัสอย่างหนัก!

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

li_o1^_p_6|o3+6%

ลองออนไลน์

เลย์เอาต์ Cube

  4-----7          4-----7          3-----2
 /|    /|         /  0  /|         /  3  /|
1-----0 |        1-----0 |        6-----5 |
| |   | |        |     |2|        |     |4|
| 5---|-2        |  1  | 2        |  5  | 7
|/    |/         |     |/         |     |/ 
6-----3          6-----3          1-----4  

คำอธิบาย

คำตอบเก่าของฉันมีการจัดวางคิวบ์ไว้เพื่อให้แต่ละใบหน้าสามารถอธิบายได้ด้วยหมายเลขเวอร์เท็กซ์แรก (ซ้ายบน) เท่ากับจำนวนใบหน้า แต่ฉันต้องการคำนวณจำนวนจุดยอดมากขึ้นโดยใช้หมายเลขใบหน้า เมื่อถึงจุดหนึ่งฉันก็เกิดความคิดขึ้นมาพร้อมกับประตูเพื่อคำนวณจำนวนจุดยอดที่สอง (บนซ้าย) เป็นหมายเลขใบหน้า XOR 1 และหลังจากผ่านการลองผิดลองถูกมาระยะหนึ่ง กับรูปแบบที่แสดงข้างต้นและสูตรด้านล่างที่อนุญาตให้ผมในการคำนวณทุกจำนวนจุดสุดยอดสำหรับใบหน้าnค่อนข้างชัดถ้อยชัดคำ:

• บนซ้าย: n
• ด้านบนขวา: n^1
• ล่างซ้าย: (n^1)|6
• ด้านล่างขวา: ((n^1)+3)%6

สำหรับการอ้างอิงฉันจะทำซ้ำผลลัพธ์สำหรับแต่ละใบหน้าในเค้าโครงที่ต้องการที่นี่:

Face:      0     1     2     3     4     5

Vertices:  01    10    23    32    45    54
           74    63    70    65    72    61

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

เพื่อประโยชน์ของลูกหลานและเพราะฉันคิดว่ามันยังคงเป็นวิธีที่ดีงามนี่คือคำตอบเก่าของฉัน

CJam, 23 ไบต์

อาจมีทางออกทางคณิตศาสตร์ที่สง่างามสำหรับปัญหานี้ แต่ฉันไม่รู้เลยว่าจะหามันได้อย่างไรดังนั้นมันจึงถูกเข้ารหัสอย่างหนัก!

"pÜ×ñè¨"487b8b3/ri_o=~p

ลองออนไลน์

เลย์เอาต์ Cube

  0-----7          0-----7          3-----6
 /|    /|         /  0  /|         /  3  /|
1-----2 |        1-----2 |        4-----5 |
| |   | |        |     |2|        |     |5|
| 5---|-6        |  1  | 6        |  4  | 7
|/    |/         |     |/         |     |/ 
4-----3          4-----3          1-----0  

คำอธิบาย

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

นี่คือการเพิ่มประสิทธิภาพหลักสามประการที่ฉันทำกับโซลูชัน "ไร้เดียงสา":

• จัดวางคิวบ์เพื่อให้แต่ละใบหน้าสามารถอธิบายด้วยหมายเลขใบหน้าเป็นหมายเลขเวอร์เท็กซ์แรก เมื่อดูที่รูปแบบคิวบ์ของฉันตามที่แสดงไว้ด้านบนเราจะเห็นได้ว่าจำนวนจุดยอดด้านซ้ายบนของแต่ละใบหน้าเท่ากับจำนวนใบหน้า สิ่งนี้ช่วยให้ฉันเข้ารหัสจุดยอดที่น้อยลงหกค่าที่ต้องพิมพ์อินพุตกลับซึ่งจะช่วยประหยัดไบต์
• แพ็คข้อมูลจุดสุดยอดลงในสตริงที่ "อักขระ" แต่ละตัวมีขนาดใหญ่กว่า 256 สูงสุดเมื่อเพิ่มขึ้นสูงสุดนี้ 256 ความยาวของสตริงลดลงอย่างช้า ๆ แต่มันก็มีแนวโน้มว่า "อักขระ" ใด ๆ เกิน 256 และ จึงไม่ได้เป็นส่วนหนึ่งของชุดอักขระ ASCII 1 ไบต์อีกต่อไป ดังนั้นฉันจึงเขียนโปรแกรมที่พยายามเข้ารหัสข้อมูลจุดยอดในทุก ๆ ฐานจาก 256 ถึง 1,000 โดยที่ฉันพบประมาณ 10 เบสที่บันทึกข้อมูลอักขระหนึ่งไบต์เปรียบเทียบกับฐาน 256 ฉันเลือก 487 เนื่องจากมีคุณสมบัติที่ดีเช่นกัน สตริงผลลัพธ์ประกอบด้วย ASCII ที่พิมพ์ได้ทั้งหมด
• ผสมกับการปรับให้เหมาะสมครั้งแรกผลิตผลลัพธ์แบบไม่สมมาตร วิธีการปกติใน CJam จะจัดรูปแบบข้อมูลจุดสุดยอดเป็นรายการ 2 องค์ประกอบของรายการ 2 องค์ประกอบแทรกบรรทัดใหม่ตรงกลางและปล่อยให้พิมพ์โดยปริยาย แต่ฉันจะพิมพ์จุดสุดยอดแรก (เท่ากับจำนวนหน้าเข้า) ด้วยตัวดำเนินการที่ไม่เพิ่มบรรทัดใหม่เรียกรายการ 3 องค์ประกอบของจุดยอดอื่นคว้าจุดสุดยอดถัดไปและพิมพ์ด้วยตัวดำเนินการที่เพิ่ม ขึ้นบรรทัดใหม่และให้อีกสองจุดยอดถูกพิมพ์โดยปริยาย วิธีนี้ช่วยประหยัดไบต์

C, 69

f(c){int d=c++%2*2-1;printf("%d%d\n%d%d",(c-d)%6,c%6,c%2+6,(c+d)%6);}

Ungolfed ในโปรแกรมทดสอบ

f(c){
 int d=c++%2*2-1;
 printf("%d%d\n%d%d",(c-d)%6,c%6,c%2+6,(c+d)%6);
}

int n;
main(){
  scanf("%d",&n);
  f(n);
}

คำอธิบาย

การจัดลำดับคิวบ์ของฉันเมื่อคลี่ออกจะมีลักษณะเช่นนี้:

0---7
|   |
| 0 |
|   |
1---2---7 
|   |   |
| 1 | 2 |
|   |   |
6---3---4---7
    |   |   |
    | 3 | 4 |
    |   |   |
    6---5---0
        |   |
        | 5 |
        |   |
        6---1

มุมซ้ายบนมีหมายเลขเดียวกับใบหน้า

มุมขวาล่างมีตัวเลข (n+2)%6

สำหรับคี่nมุมขวาบนคือ(n+1)%6และซ้ายล่าง6

แม้แต่nมุมบนขวาก็คือ7และมุมล่างซ้าย(n+1)%6

โปรแกรมจะแสดงตัวเลขคี่ตามที่แสดงและตัวเลขคู่จะหมุน 180 องศา วิธีการนี้ที่มุมขวาบนอยู่เสมอและที่ด้านล่างซ้ายอยู่เสมอ(n+1)%6 (n+1)%2+6Inverting nและn+2ทำได้ง่ายขึ้น (ทำได้โดยการตั้งค่าc=n+1และใช้dเพื่อเพิ่มหรือลบ1หรือ-1ตามความจำเป็น)

เอาท์พุต

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

องค์ประกอบ, 18

_4:2%6+``2+6%`-5+`

ซึ่งแตกต่างจากภาษากอล์ฟขั้นสูงอื่น ๆ Element ไม่มีตัวดำเนินการบีบอัดดังนั้นความกะทัดรัดของการแก้ปัญหาจึงเชื่อมโยงอย่างใกล้ชิดกับรูปแบบหมายเลขที่แน่นอนที่ใช้ หลังจากการทดลองฉันได้สร้างรูปแบบการกำหนดหมายเลขใหม่ซึ่งช่วยให้สามารถคำนวณจุดยอดได้โดยใช้การคำนวณทางคณิตศาสตร์อย่างง่ายเท่านั้น

  1-----0          1-----0          2-----5
 /|    /|         /  4  /|         /  3  /|
4-----6 |        4-----6 |        3-----7 |
| |   | |        |     |0|        |     |5|
| 7---|-5        |  2  | 5        |  1  | 0
|/    |/         |     |/         |     |/ 
3-----2          3-----2          4-----1  

มุมซ้ายบนคือ 6 ถ้าเป็นเลขคู่และ 7 ถ้าเป็นเลขคี่ มุมบนขวาคือหมายเลขใบหน้า ด้านล่างซ้ายคือหมายเลขใบหน้าบวก 2, mod 6 ด้านล่างขวาคือ 5 ลบหมายเลขใบหน้า

นี่คือคำอธิบายของรหัส

_4:2%6+``2+6%`-5+`
_4:                    take input and make several copies of it
   2%6+`               take face #, mod 2, add 6, and output
        `              output input, which already has the newline attached
         2+6%`         take face #, add 2, mod 6, and output
              -5+`     negate face #, add 5, and output

นี่คือผลลัพธ์สำหรับแต่ละใบหน้า:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

คู่, 108 100 68 50 ไบต์

แน่นอนว่ามันเป็นวิธีที่จะทำให้มันดูดีกว่าวิธีก่อนหน้าของฉันนั่นคือการเข้ารหัสแบบธรรมดา ฉันประหลาดใจที่ Octave เป็นวิธีที่เหมาะสำหรับ codegolf มากกว่า Matlab =)

f=@(n)['040201375767';'261345154623'](:,2*n+(1:2))

เค้าโครง:

(ขออภัยฉันลืมเพิ่ม)

เลย์เอาต์ Cube

  1-----5          1-----5          6-----7
 /|    /|         /  2  /|         /  5  /|
0-----4 |        0-----4 |        2-----3 |
| |   | |        |     |4|        |     |3|
| 3---|-7        |  0  | 7        |  1  | 5
|/    |/         |     |/         |     |/ 
2-----6          2-----6          0-----1  

เวอร์ชั่นเก่า:

f=@(n)[0 4 0 2 0 1 3 7 5 7 6 7;2 6 1 3 4 5 1 5 4 6 2 3](:,2*n+(1:2))

แม้แต่เวอร์ชั่นที่เก่ากว่า:

นี่จะสร้างอาร์เรย์ 2x2x2 จากนั้นเลือก 'ชิ้น' เราทำการเรียงสับเปลี่ยนเมทริกซ์ 3 มิติและแต่ละครั้งเลือกชิ้นด้านบนหรือด้านล่าง (อันนี้ใช้ไม่ได้กับ matlab เพราะการสร้างดัชนีของนิพจน์มากกว่าเมทริกซ์) ฉันแน่ใจว่าจะมีวิธีการทำตรงที่จะสั้นกว่านี้

f=@(n)squeeze(permute(reshape(0:7,2,2,2),circshift((1:3)',n))(n=fix(n/3)+1,circshift((1:2)',n-1),:))

f=@(n)squeeze(permute(reshape(0:7,2,2,2),circshift((1:3)',n))(floor(n/3)+1,circshift((1:2)',floor(n/3)),:))

CJam, 31 28 (หรือ 26) ไบต์

8,2/W%_1m<]z[D75K46]2/+ri=N*

ซึ่งสามารถบีบอัดได้โดยใช้การแปลงฐานเป็นเวอร์ชัน 26 ไบต์ไบต์รุ่น

ถือว่าลูกบาศก์เป็นเช่น:

  7-----1
 /|    /|
5-----3 |
| |   | |
| 6---|-0
|/    |/
4-----2

ด้วยใบหน้าเช่น

  7-----1      .-----.      .-----.      .-----.
 /  4  /|     /  4  /|     /  4  /|     /  0  /|
5-----3 |    .-----. |    .-----. |    .-----. |
|     |2|    |     |1|    |     |0|    |     |5|
|  1  | 0    |  0  | .    |  3  | .    |  3  | .
|     |/     |     |/     |     |/     |     |/ 
4-----2      .-----.      .-----.      .-----.    

ลองออนไลน์ได้ที่นี่

CJam (25 ไบต์)

"ñRXµ  roM~"(ib65b2/q~=N*

สิ่งนี้มีอักขระที่ไม่สามารถพิมพ์ได้และแท็บ (ซึ่งจะถูกจัดการด้วยซอฟต์แวร์ StackExchange) ดังนั้นในรูปแบบ xxd:

0000000: 22f1 5258 1fb5 0972 6f4d 7e22 2869 6236  ".RX...roM~"(ib6
0000010: 3562 322f 717e 3d4e 2a                   5b2/q~=N*

การสาธิตออนไลน์

Cube:

  1-----0        Faces:
 /|    /|        10 46
4-----6 |        14 37
| |   | |        20 31
| 3---|-2        23 57
|/    |/         56 20
7-----5          57 64

นี่คือการเข้ารหัสแบบฮาร์ดบริสุทธิ์โดยมีการเลือกจุดยอดลูกบาศก์เพื่อเพิ่มความสามารถในการบีบอัดฐานให้สูงสุด ฉันถอดรหัสตัวเลข 2 หลักดังนั้นไม่มีใครสามารถเริ่มต้นด้วย 0 ฉันไม่ต้องการให้เริ่มต้นด้วย 7 อย่างใดอย่างหนึ่งเนื่องจากที่ผลักฐานที่สองสูงเกินไป ดังนั้น 0 และ 7 จะต้องอยู่ในแนวทแยงยาว ฉันต้องการให้ขอบ 10 ขีดไปก่อนเพื่อลดค่าที่ฉันกำลังเข้ารหัส นอกจากนั้นยังมีความยืดหยุ่นพอสมควรโดยไม่ต้องเปลี่ยนจำนวนไบต์

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

JavaScript (ES6), 53 62

แก้ไขบันทึก 8 ไบต์โดยใช้สตริงแม่แบบ, ขอบคุณ @NinjaBearMonkey ระวังบรรทัดใหม่ภายในเครื่องหมายคำพูดมีความสำคัญและไม่สามารถยุบได้

ไม่สามารถฉลาดใน Javascript ได้มันเป็นเรื่องละเอียดเกินไป

f=n=>`01
23
45
67
01
31
5702
64`.substr(n-4?n*3:20,5)

เอาท์พุต for(i=0;i<6;i++)console.log(f(i),i)

01
23
0

23
45
1

45
67
2

67
01
3

02
64
4

31
57
5

ดูข้อมูลโค้ดเพื่อ veify สมาคมหมายเลข ( ที่สนุก)

function P3D(x,y,z) {
    this.x = x;this.y = y;this.z = z;
    this.rotateX = angle => {
        var rad = angle * Math.PI / 180,
        cosa = Math.cos(rad),sina = Math.sin(rad),
        y = this.y * cosa - this.z * sina,
        z = this.y * sina + this.z * cosa
        return new P3D(this.x, y, z)
    }
    this.rotateY = angle => {
        var rad = angle * Math.PI / 180,
        cosa = Math.cos(rad), sina = Math.sin(rad),
        z = this.z * cosa - this.x * sina,
        x = this.z * sina + this.x * cosa
        return new P3D(x,this.y, z)
    }
    this.rotateZ = angle => {
        var rad = angle * Math.PI / 180,
        cosa = Math.cos(rad), sina = Math.sin(rad),
        x = this.x * cosa - this.y * sina,
        y = this.x * sina + this.y * cosa
        return new P3D(x, y, this.z)
    }
    this.project = (viewWidth, viewHeight, fov, viewDistance) => {
        var factor = fov / (viewDistance + this.z),
        x = this.x * factor + viewWidth / 2,
        y = this.y * factor + viewHeight / 2
        return new P3D(x, y, this.z)
    }
}
 
var vx = [
    new P3D(-1,1,-1),
    new P3D(1,1,-1),
    new P3D(-1,-1,-1),
    new P3D(1,-1,-1),
    new P3D(-1,-1,1),
    new P3D(1,-1,1),
    new P3D(-1,1,1),
    new P3D(1,1,1),
];
// Define the vx that compose each of the 6 faces. These numbers are
// indices to the vertex list defined above.

var faces = [[0,1,3,2],[2,3,5,4],[4,5,7,6],[6,7,1,0],[0,2,4,6],[1,3,5,7]]

faces.map((f,i)=>{
    var mx=vx[f[0]].x+vx[f[1]].x+vx[f[2]].x+vx[f[3]].x,
    my=vx[f[0]].y+vx[f[1]].y+vx[f[2]].y+vx[f[3]].y,
    mz=vx[f[0]].z+vx[f[1]].z+vx[f[2]].z+vx[f[3]].z
    vx[i+10]=new P3D(mx/4, my/4, mz/4)
    f[4]=i
    f[5]=i+10
})

var angle = 0;

var ctx = CV.getContext("2d");

setInterval(loop,33)
 
function loop() {
    ctx.fillStyle = "#fff"
    ctx.fillRect(0,0,400,200);
    ctx.font = "20px Arial"
    angle += 2
    
    var t = vx.map(v=>
        v
        .rotateX(angle).rotateY(-angle).rotateZ(-angle)
        .project(400,200,128,3)
    )
    
  
    ctx.strokeStyle = "#f00"
    t.forEach((v,i)=>i<8?ctx.strokeText(i,v.x,v.y):0)

    ctx.strokeStyle = "#428"
    ctx.beginPath()
    faces.forEach(f=>(                         
        ctx.moveTo(t[f[0]].x,t[f[0]].y),
        ctx.lineTo(t[f[1]].x,t[f[1]].y),
        ctx.lineTo(t[f[2]].x,t[f[2]].y),
        ctx.lineTo(t[f[3]].x,t[f[3]].y),
        ctx.lineTo(t[f[0]].x,t[f[0]].y),
        ctx.strokeText(f[4],t[f[5]].x,t[f[5]].y)
    ))
    ctx.closePath(),
    ctx.stroke()
}

<canvas id=CV width=400 height=200></canvas>

Ruby Rev 1, 40 36

->(c){print(c^1,c,"\n",6|c,(c+3)%6)}

ขอบคุณ @rcrmn ที่แนะนำให้ใช้แลมบ์ดาเพื่อบันทึก 4 ไบต์ ฉันไม่แน่ใจเกี่ยวกับการปล่อยให้มันไม่ระบุชื่อ แต่ดูเหมือนว่าจะมีการหารือเกี่ยวกับเมตาที่นี่และตัดสินใจที่นี้คือตกลง

นี่คือฟังก์ชั่น 40- ไบต์เปรียบเทียบกับคำตอบ Rev 0 Ruby ของฉันด้านล่าง (คำตอบ C ดั้งเดิมอยู่ในโพสต์แยกต่างหาก)

def f(c)print(c^1,c,"\n",6|c,(c+3)%6)end

แรงบันดาลใจเพิ่มเติมจาก Runer112: สิ่งนี้ขึ้นอยู่กับการปรับเปลี่ยนรูปแบบหมายเลขที่ใช้ในคำตอบล่าสุดของเขา (16 ไบต์!) พอร์ตโดยตรงของโครงการของ PhiNotPi จะให้คะแนนเท่ากัน

ด้วยการเลื่อนตัวเลขจาก Rev 0 ปัดหนึ่งก้าวและทำทุกอย่างที่ XOR 1 เราจะได้ลูกบาศก์ต่อไปนี้:

4---7
|   |
| 1 |
|   |
1---0---7
|   |   |
| 0 | 3 |
|   |   |
6---3---2---7
    |   |   |
    | 2 | 5 |
    |   |   |
    6---5---4
        |   |
        | 4 |
        |   |
        6---1

เอาท์พุต

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

Ruby Rev 0, 56 52 50

ที่บันทึกไว้ 4 ไบต์โดยการเอาไม่จำเป็น()%6จากc-dและอีก 2 (แรงบันดาลใจจาก runer112) 6+c%2 --> 6|cโดย

คะแนนสำหรับฟังก์ชั่นซึ่งเป็นเพียงบรรทัดแรก ฉันใหม่กับ Ruby และฉันประหลาดใจที่ฉันไม่สามารถหาวิธีที่สั้นกว่า 12 ตัวอักษร (11 บวกบรรทัดใหม่) เพื่อให้ได้หมายเลขผู้ใช้ที่ป้อนลงใน n ดังนั้นการทำหน้าที่แทนโปรแกรมจะประหยัด 1 ไบต์

def f(c)d=c%2*2-1;print((c+d)%6,c,"\n",c|6,c-d)end

n=gets.to_i
f(n)

นี่คือพอร์ตของคำตอบ C ของฉัน ใน C ตัว%ดำเนินการส่งคืนค่าลบด้วยจำนวนลบ ในทับทิมก็มักจะส่งกลับค่าบวกดังนั้นจึงไม่มีความจำเป็นต้องเพิ่ม c1 ด้วยเหตุนี้จึงเป็นประโยชน์ในการเปลี่ยนหมายเลขใบหน้าเป็น 1 ดังนี้:

0---7
|   |
| 1 |
|   |
1---2---7 
|   |   |
| 2 | 3 |
|   |   |
6---3---4---7
    |   |   |
    | 4 | 5 |
    |   |   |
    6---5---0
        |   |
        | 0 |
        |   |
        6---1

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

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Pyth, 30

ขอบคุณ @Jakube สำหรับ 2 ไบต์

Jc2jkfx>Q2!.&T^2%Q3U8jb?_J%Q2J

ลองที่นี่

คำแนะนำการเล่นกอล์ฟจากผู้เชี่ยวชาญ pyth จะได้รับการยอมรับอย่างงดงาม โดยเฉพาะฉันคิดว่าส่วนผลผลิตอาจมีการปรับปรุงบางอย่าง

พอร์ตของไพ ธ อนต่อไปนี้: ...

Python, 109

Q=input()
s=''.join(map(str,filter(lambda v:(Q<3)^(v&(1<<Q%3)>0),range(8))))
print s[1-Q%2::2],'\n',s[Q%2::2]

... ซึ่งเป็นพอร์ตของ

Pure Bash, 130

สำหรับวัตถุประสงค์ของการอธิบาย:

for v in {0..7};{
if(($1/3));then((v&(1<<$1%3)))&&a+=$v
else((v&(1<<$1%3)))||a+=$v
fi
}
i=$[$1%2*2]
echo "${a:i:2+i}
${a:2-i:4-i}"

จุดยอดของคิวบ์จะถูกกำหนดหมายเลขดังนี้:

  4-----5
 /|    /|
0-----1 |
| |   | |
| 6---|-7
|/    |/
2-----3

และใบหน้ามีหมายเลขดังนี้:

Face  Vertices  Swap
   0  0,2,4,6
   1  0,1,4,5   x
   2  0,1,2,3
   3  1,3,5,7   x
   4  2,3,6,7
   5  4,5,6,7   x

Swapบ่งบอกว่าคำสั่งของจุดที่ควรจะเปลี่ยนในการส่งออก

อัลกอริธึมเริ่มต้นจากจุดยอดทั้งหมด {0..7} จุดยอดจะถูกกำจัดตามบิตที่กำหนดในตัวเลขจุดสุดยอด:

• สำหรับใบหน้า 0,1 และ 2 จะมีการเก็บจุดยอดที่มีบิต 1,2 หรือ 3 ตามลำดับ
• สำหรับใบหน้า 3,4 และ 5 จะมีการรักษาจุดยอดที่มีบิต 1,2 หรือ 3 ชุดตามลำดับ

จุดยอด "ที่เก็บไว้" ถูกผนวกเข้ากับสตริง สตริงเป็นตัวอักษรผลลัพธ์ 0,1 จากนั้น 2,3 หรือในทางกลับกันขึ้นอยู่กับว่ามีการตั้งค่าการตั้งค่าสถานะการแลกเปลี่ยน (ตัวแก้ไขหมายเลขหน้า 2)

J - 26 ไบต์

ฟังก์ชั่นรับจำนวนหน้าเป็นอาร์กิวเมนต์และส่งกลับตารางของตัวเลข

0{.@":"0@{0&(|:|.)&(i.3#2)

เรากำลังใช้คิวบ์ต่อไปนี้:

  4-----5    Face numbers:
 /|    /|     0 - front
0-----1 |     1 - top
| |   | |     2 - left
| 6---|-7     3 - back
|/    |/      4 - bottom
2-----3       5 - right

ตัวอย่าง (ลองด้วยตัวเองที่tryj.tk ):

   0{.@":"0@{0&(|:|.)&(i.3#2) 3         NB. inline
76
54
   f =: 0{.@":"0@{0&(|:|.)&(i.3#2)      NB. named
   f each 0 1 2 3 4 5                   NB. all results
+--+--+--+--+--+--+
|01|40|64|76|37|13|
|23|51|20|54|26|57|
+--+--+--+--+--+--+

0&(|:|.)ขนมปังและเนยเป็น นี่คือคำกริยาที่ผันกลับและหมุนลูกบาศก์ในลักษณะที่จะเข้าชมทุกหน้าเมื่อมีการใช้ซ้ำ ๆ ซึ่งเป็นสิ่งที่เราทำโดยใช้อาร์กิวเมนต์อินพุต จุดยอดของลูกบาศก์ถูกสร้างขึ้นโดยi.3#2ดังนั้นเราจึงใช้มันเป็นจุดเริ่มต้นและหันหน้าไปทางด้านหน้า0...{เมื่อเราทำเสร็จแล้ว

การพิมพ์ตัวเลขเป็นสตริงมีค่าใช้จ่าย 8 ตัวอักษร: {.@":"0@หากเราได้รับอนุญาตให้คืนค่าอาเรย์นั่นคือการประหยัดทั้ง 8 อักขระ [เริ่มต้นด้วยการเขย่าและจับไม่ได้]

> <> (ปลา) , 38 ไบต์

'/ =/2= 28"H5'a@i-!
noan~\;
~>:?!^1-@~

ทุกผลลัพธ์จะถูกเก็บไว้เป็นสองแถว 2 หลัก แถวจะถูกจัดเก็บเป็นอักขระในสตริง'/ =/2= 28"H'(ยกเว้นแถว10ที่ต่อท้ายหลังจากเป็นสตริงa) ตัวละครตัวแรก (/ = 47 ) ใช้เพื่อเปลี่ยนทิศทางการไหลของโปรแกรมในการโต้ตอบที่สอง

ด้านบน 2*(53-n)องค์ประกอบจะถูกยกเลิก (โดยที่ n คือรหัสของหมายเลขอินพุต) และรหัสสองรหัสถัดไปจะถูกพิมพ์ด้วยบรรทัดใหม่ระหว่าง

เค้าโครง:

  3-----2
 /|    /|
4-----7 |
| |   | |
| 5---|-0
|/    |/
6-----1      0 1 2 3 4 5 sides are top front bottom back left right respectively.