Призначте числа 0 до 7 8 вершинам куба будь-яким способом. Кожній вершині має бути призначено саме одне число.

Наприклад, вершини можуть бути призначені так:

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

Напишіть програму, яка займає ціле число від 0 до 5. Кожне з цих 6 чисел асоціюється саме з одним обличчям вашого куба будь-яким способом, який вам подобається. Коли вводиться одне з цих чисел, 4 вершинні номери асоційованого обличчя повинні бути надруковані для викреслювання в 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 вершинні номери легко та коротко.

Виграє найкоротший код у байтах. Tierereaker - це раніше повідомлення. ( Зручний лічильник байтів. )

Примітки

• Ви можете записати функцію замість програми. Потрібно взяти ціле число від 0 до 5 та надрукувати або повернути дворядкову сітку 2 × 2.
• Візьміть дані зі stdin, командного рядка або arg. Ви можете припустити, що введення дійсне.
• Необов'язково вихід може мати зворотний новий рядок.
• Обов’язково повідомте нам обрані вершини та номери обличчя.

CJam, 23 16 байт

Мабуть, є елегантне математичне рішення цієї проблеми. Але я не маю поняття, як його знайти, настільки складене жорстке кодування це!

Я знайшов одного! Ну, це не класично елегантне математичне рішення, оскільки воно використовує побітові операції, але цілком формульне.

li_o1^_p_6|o3+6%

Спробуйте в Інтернеті.

Макет куба

  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

Спробуйте в Інтернеті.

Макет куба

  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 і становить таким чином, більше не є частиною 1-байтового набору символів ASCII. Тому я написав програму, яка намагається кодувати вершинні дані у кожній базі від 256 до 1000, за допомогою якої я виявила близько 10 баз, які зберігають один байт даних символів порівняно з базовою 256. Я вибрав 487, оскільки це також має хорошу властивість, отримана рядок повністю складається з друкованого ASCII.
• Змішані з першою оптимізацією, отримують вихід асиметрично. Звичайним підходом у CJam було б форматування даних вершин у вигляді двоелементного списку двоелементних списків, вставлення нового рядка посередині та нехай друкований результат буде неявним. Але я замість цього надрукую першу вершину (рівну номеру обличчя входу) з оператором, який не додає новий рядок, витягнути 3-елементний список інших вершин, захопити наступну вершину та роздрукувати її з оператором, який додає новий рядок, і нехай друге дві вершини будуть неявно надруковані. Це економить байт.

С, 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+6. Інвертувати 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, мод 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 набагато більше підходить для кодового гольфу, ніж Matlab =)

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

Макет:

(Вибачте, я забув додати це.)

Макет куба

  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, а потім вибрати "фрагмент". Робимо перестановку матриці 3d і кожен раз вибираємо верхній або нижній зріз. (Цей не працює в 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*

Демонстрація в Інтернеті

Куб:

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

Це чисто жорстке кодування, з кубовими вершинами, вибраними для максимальної стисливості основи. Я декодую двозначні числа, тому жодне з них не може починатися з 0. Я також не хочу починати з 7, оскільки це підштовхує другу базу занадто високо. Тому 0 і 7 повинні бути на довгій діагоналі. Я хочу, щоб 10 крайок було першим, щоб зменшити значення, які я кодую. Крім цього, існує достатня кількість гнучкості без зміни кількості байтів.

Я трохи розчарований, що, вискочивши першого символу з чарівної струни, потрібно передати його до int, перш ніж використовувати його як базу для перетворення бази. Будемо сподіватися, що майбутні версії CJam врятують цей байт, хоча використовувати це тут буде вже пізно.

JavaScript (ES6), 53 62

Редагуйте Збережіть 8 байтів за допомогою рядків шаблону, thx @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

Перегляньте фрагмент, щоб переглянути кількість асоціацій ( це було весело)

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>

Рубін Рев. 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

Рубін Рев 0, 56 52 50

Збережено 4 байта, видаливши unnecesary ()%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 %оператор повертає негативне значення з від’ємним числом. У Ruby це завжди повертає позитивне значення, тому немає необхідності додавати 1 доc . Як результат, вигідно зрушити нумерацію граней на 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

Піт, 30

Дякую @Jakube за 2 байти.

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

Спробуйте тут.

Поради щодо гольфу від експертів-пітістів будуть ласкаво прийняті. Зокрема, я думаю, що вихідний розділ може мати деякі покращення.

Порт наступного пітона: ...

Пітона, 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]

... який є портом

Чистий Баш, 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, або навпаки, залежно від того, встановлений прапор swap (номер обличчя mod 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= 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.