Присвойте числа от 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 числа вершин легко и быстро.

Самый короткий код в байтах побеждает. Tiebreaker - более ранний пост. ( Удобный счетчик байтов. )

Примечания

• Вы можете написать функцию вместо программы. Он должен принимать целое число от 0 до 5 и печатать или возвращать 2 × 2-разрядную строку сетки.
• Возьмите ввод из стандартного ввода, командной строки или функции 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  

объяснение

Основной подход заключается в том, чтобы жестко закодировать вершины для каждой грани как можно меньше места. По аналогии с базовым решением преобразования Optimizer, этот список вершин обрабатывается как восьмеричное число, упакованное как символьные данные ASCII. Но на этом сходство заканчивается, чтобы освободить место для дальнейшей оптимизации!

Вот три ключевых оптимизации, которые я сделал для «наивного» решения:

• Расположите куб так, чтобы каждая грань была описана с номером грани в качестве первого номера вершины. Глядя на мой макет куба, представленный выше, можно увидеть, что номер верхней левой вершины каждой грани равен номеру грани. Это позволяет мне кодировать на шесть вершин меньше за счет необходимости печатать ввод обратно, что, как оказывается, позволяет сохранить байт.
• Упакуйте данные вершин в строку, для которой каждый «символ» имеет максимум, превышающий 256. Когда этот максимум увеличивается после 256, длина строки медленно уменьшается, но становится все более вероятным, что любой «символ» превышает 256 и равен таким образом, больше не является частью 1-байтового набора символов ASCII. Итак, я написал программу, которая пытается кодировать данные вершин в каждой базе от 256 до 1000, с помощью которой я нашел около 10 баз, которые сохраняют один байт символьных данных по сравнению с базой 256. Я выбрал 487, так как у этого также есть хорошее свойство, которое результирующая строка полностью состоит из печатного ASCII.
• Смешиваясь с первой оптимизацией, производим вывод асимметрично. Обычный подход в CJam состоит в том, чтобы отформатировать данные вершин в виде двухэлементного списка из двухэлементных списков, вставить новую строку в середине и позволить неявно печатать выходные данные. Но вместо этого я печатаю первую вершину (равную номеру входного лица) с помощью оператора, который не добавляет символ новой строки, извлекаю список из трех элементов из трех других вершин, беру следующую вершину и печатаю ее с помощью оператора, который добавляет символ новой строки, и пусть две другие вершины будут напечатаны неявно. Это сохраняет байт.

С, 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);}

Неуправляемый в тестовой программе

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 намного лучше подходит для Codegolf, чем 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*

Онлайн демо

Cube:

  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>

Ruby Rev 1, 40 36

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

Спасибо @rcrmn за предложение использовать лямбду для сохранения 4 байтов. Я не был уверен, что оставлю это анонимно, но, похоже, это обсуждалось здесь и решил, что все в порядке.

Здесь это как 40-байтовая функция, для сравнения с моим ответом Ruby Rev 0, также ниже (Оригинальный ответ 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 ответа. В Си %оператор возвращает отрицательное значение с отрицательным числом. В 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 или наоборот, в зависимости от того, установлен ли флаг обмена (номер лица мод 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.