Напишіть програму або функцію, яка буде приймати ліве і праве значення кісток як цілі числа (1-6) і повертати значення зверху.

Макет кісток:

    +---+
    | 1 |
+---+---+---+---+
| 2 | 3 | 5 | 4 |
+---+---+---+---+
    | 6 |
    +---+

  ,^.
<´ 5 `>  <-- Top value
|`._,´|
.6 | 4,  <-- Side values
 `.|,´

Тож введення 6 4повернеться 5.

Порядок важливий:

2 3 -> 1
3 2 -> 6

Програма не повинна працювати з недійсними вхідними значеннями.

Щоб відмовитись від очевидного підходу (використання таблиці з усіма комбінаціями), використання будь-якого вбудованого кодування тексту або де / стиснення підпрограм або базового кодування або що-небудь ще подібне для зменшення розміру не дозволяється. Зауважте, що використання таблиці все ще дозволено, і прокрутка власної декомпресії також дозволена, доки це не робиться за допомогою деякої готової функції бібліотеки.

Для довідкових цілей, ось таблиця всіх комбінацій (тобто всіх можливих входів і виходів):

23, 35, 42, 54 -> 1
14, 31, 46, 63 -> 2
12, 26, 51, 65 -> 3
15, 21, 56, 62 -> 4
13, 36, 41, 64 -> 5
24, 32, 45, 53 -> 6

Найкоротший код виграє, і застосовуються стандартні лазівки.

Пітона, 30

lambda a,b:a^b^7*(2<a*a*b%7<5)

Ніяких пошукових запитів, просто біт-бит.

Протилежні грані складаються парами, які є трибітними доповненнями один одного, тобто вони XOR до 7.

1,6
2,5
3,4

Враховуючи два обличчя з одного набору, ми хочемо отримати обличчя з іншого. Бо (1,2,3)ми можемо це зробити за допомогою XOR ( ^). Отже, ^дає правильну відповідь до трибітного доповнення, значення x^7. Ми можемо умовно доповнити x^7*_.

Щоб вирішити, приймати чи ні доповнення (XOR з 7), ми перевіряємо, чи порушує триплет праворучне правило. Це означає, що a,bйде в зворотному циклічному порядку

1,6
2,5
3,4

трактуючи кожен рядок як одну з трьох категорій. Оскільки елементи в кожному рядку є негативом мод 7, ми можемо "хешировать" їх, роблячи x*x%7.

1,6 -> 1
2,5 -> 4
3,4 -> 2

Кожен рядок виходить з циклічний попереднього множення на 4 по модулю 7, так що ми можемо перевірити , чи має це відношення для (b,a)вирішити , слід чи доповнити: a*a%7==b*b*4%7.

Це еквівалентно перевірці, чи a**2 * b**(-2)рівний модуль 7 рівним 4. Оскільки b**6дорівнює 1модулю 6, це еквівалентно a**2 * b**4. Оскільки інше можливе значення дорівнює 2 (перевіряючи випадки), ми можемо перевірити, чи є 4 порівняно з 3.

Існує приємний поліноміальний вираз 7 для третьої сторони з двома сторонами a і b .

або фактор

Модуль 7 відображає залишок у {0,1,2,3,4,5,6}.

Я пояснюю, чому це працює у цій відповіді Math SE , хоча я думаю, що я, мабуть, є більш чистим аргументом, який я пропускаю. Єдиний інший двочленний поліном, який працює, - це

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

Будь ласка, не соромтесь додавати порти цього на улюблену мову; це посада CW.

J, 9 - Synthetica

7|3***+*-

Дивіться мій пост

Dyalog APL, 9 на ngn (друкарська помилка, зафіксована Adám)

7|3×××+×-

Відверто вкрадена зверху J відповідь.

TI-Basic, 14 від Timtech

7fPart((A³B-AB³)/21

Pyth, 16 від FryAmTheEggman

M%*3-*H^G3*^H3G7

Визначає функцію gз двох значень.

Гольфскрипт, 18 Пітер Тейлор (старий поліном)

~1$*.5?3*@.*@*- 7%

CJam, 18 - Мартін Бюттнер (портував із Golf's PeterScript) (старий поліном)

l~1$*_5#3*@_*@*m7%

Математика, 20 Мартін Бюттнер

Mod[+##(#-#2)3##,7]&

Так, це одинарний плюс, і ні, немає більш короткого способу, який не використовує одинарний плюс.

DC, 21 від Toby Speight

sb7+d3^lb*rlb3^*-3*7%

Я повинен додати 7, щоб aпереконатися, що різниця завжди позитивна (DC має підписаний %оператор).

Джулія, 24 23 Мартін Бюттнер

f(a,b)=3a*b*(a^2-b^2)%7

CoffeeScript, 28 26 від rink.attendant.6

x=(a,b)->3*a*b*(a*a-b*b)%7

JavaScript (ES6), 28 26 від rink.attendant.6

x=(a,b)=>3*a*b*(a*a-b*b)%7

По суті те саме, що і CoffeeScript.

Python 28, автор xnor

lambda a,b:3*a*b*(a*a-b*b)%7

Баш, 31

Нічого особливого:

echo $[3*($1**3*$2-$1*$2**3)%7]

або альтернативно:

echo $[3*$1*$2*($1*$1-$2*$2)%7]

Ще один (довший, але, можливо, цікавий) підхід .

Нім, 36 - Сіллеста

proc(x,y:int):int=3*x*y*(x*x-y*y)%%7

Java 7, 46 44 від rink.attendant.6

int f(int a,int b){return(a*a-b*b)*a*b*3%7;}

Ява 8, 25 23 Кевін Круїссен

a->b->(a*a-b*b)*a*b*3%7

PHP, 49 47 від rink.attendant.6

function x($a,$b){echo($a*$a-$b*$b)*3*$a*$b%7;}

Пачка, 52 нечистого м’яса

set/aa=(3*(%1*%1*%1*%2-%1*%2*%2*%2)%%7+7)%%7
echo %a%

CMD не підтримує істинний модуль спочатку (тому не може обробляти негативні числа) - отже %%7+7)%%7.

МЕНШЕ (як параметричний міксин ), 62 60 від rink.attendant.6

.x(@a,@b){@r:mod(3*@a*@b*(@a*@a-@b*@b),7);content:~"'@{r}'"}

Дивіться мою публікацію нижче .

05AB1E, 10 8 - Емінья (-2 байти Кевін Круїссен)

nÆs`3P7%

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

Haskell, _{31 27} 25 за загальним екраном

a#b=3*a*b*(a*a-b*b)`mod`7

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

Excel, 27 - Верніш

=MOD(3*(A1^3*B1-A1*B1^3),7)

Excel VBA, 25 Тейлор Скотт

?3*[A1^3*B1-A1*B1^3]Mod 7

Четвертий (gforth) 41 від reffu

: f 2>r 2r@ * 2r@ + 2r> - 3 * * * 7 mod ;

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

C #, 23 Кевін Круїссен

a=>b=>(a*a-b*b)*a*b*3%7

CJam, 43 28 байт

Не маю ідеї, чи підхід на основі повного столу буде коротшим, але ось що:

l_~^56213641532453s@S-#)g7*^

Вхід як

2 3

Вихід:

1

Це суміш мого попереднього алгоритму для визначення правильної грані з 2 граней та підходу xors до xors.

Спробуйте його онлайн тут

Менше, 62 байти

У цій публікації використовується алгоритм :

.x(@a,@b){@r:mod(3*@a*@b*(@a*@a+6*@b*@b),7);content:~"'@{r}'"}

Це могло б бути коротшим, якщо використовується ціле значення, але для його відображення мені потрібно було використовувати contentвластивість CSS, яка вимагала змінної інтерполяції .

Тим не менш, не так часто для гольфу коду використовується мова препроцесора CSS!

Щоб скористатися деяким HTML, ви зробите це:

p::after { .x(1, 3); }

<p>Number on top: </p>

Pyth, 30 байт

K"23542 31463 12651 "h/x+K_Kz6

Потрібні дві цифри як вхідні, між ними немає пробілу (наприклад, 23немає 2 3).

Пояснення:

Будь-яка двозначна послідовність, яка лежить всередині, 23542являє собою дві сторони, які мають 1зверху. Так само 31463для 2 і т.д. Повернення цього рядка дає послідовності для 4наскрізних 6.

Цей код просто здійснює пошук у рядку "23542 31463 12651 15621 36413 24532", ділить індекс на 6 та збільшує кроки, щоб визначити, якою повинна бути верхня сторона.

Тестуйте онлайн тут.

Дякуємо @FryAmTheEggman за поради щодо гольфу.

Використовує аналогічний підхід, як і es1024 з іншим рядком пошуку:

JavaScript (ES6), 73 72 61 байт

t=(l,r)=>-~('354233146312651215623641332453'.search([l]+r)/5)

JavaScript (ES5), 88 87 77 байт

function t(l,r){return -~('354233146312651215623641332453'.indexOf([l]+r)/5)}

CoffeeScript, 71 62 байт

І просто для задоволення від цього код на 1 байт коротший у CoffeeScript як ES6 через дозволене пропущення дужок

Завдяки використанню -~трюку виявилося таке ж число символів, що і ES6.

t=(l,r)->-~('354233146312651215623641332453'.indexOf([l]+r)/5)

J (9)

Використовує алгоритм з цієї публікації.

7|3***+*-

Деревовий графік функції (може очистити деякі речі):

    f=:7|3***+*-
    f
7 | 3 * * * + * -
   5 !: 4 < 'f'
  ┌─ 7            
  ├─ |            
──┤   ┌─ 3        
  │   ├─ *        
  └───┤   ┌─ *    
      │   ├─ *    
      └───┤   ┌─ +
          └───┼─ *
              └─ -

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

   3 f 5
1
   4 f 6
2
   2 f 6
3
   2 f 1
4
   1 f 2
3
   4 f 5
6

PHP, 81 байт

Те саме, що і моє рішення JavaScript:

function t($l,$r){echo(int)(1+strpos('354233146312651215623641332453',$l.$r)/5);}

Луа 118

Довелося відновити останню версію через помилку, яку я не можу знайти, ні встигнути її шукати.

z=io.read;o={"","","34","5 2","2165","46 13",""," 31064","  5612","   2 5","    43"}a=z();b=z();print(o[a+b]:sub(a,a))

Все ще над цим працюю.

JavaScript (ES6), 79 байт

Не найкоротший, але я спробував інший підхід, ніж зараз у відповідях.

f=(a,b)=>[a,b,7-a,7-b].reduce((p,v,i,r)=>p?p:'2312132'.indexOf([v]+r[i+1])+1,0)

Луа, 89 байт

Прямий порт рішення Python xnor.

x=require('bit32').bxor
function(a,b)c=a*a*b%7;return x(a,x(b,2<c and c<5 and 7 or 0))end

Баш, 85

Це не конкурує з гольфом з магічним поліномом @ xnor. Але я думаю, що це ще один цікавий спосіб обчислити відповідь:

g(){
((d[$1$2]))||{
d[$1$2]=$3
g $2 $1 $[7-$3]
g $2 $3 $1
}
}
g 1 2 3
echo ${d[$1$2]}

Конкретно нам відомо про кубики:

• Якщо ліве обличчя дорівнює 1, а праве - 2, то верхнє - 3
• Обертання навколо протилежних вершин на 120 ° дає ще трійку номінальних значень. Наприклад, ми повертаємо {l = 1, r = 2, t = 3}, як тільки отримаємо {l = 2, r = 3, t = 1} і, обертаючись знову, отримаємо {l = 3, r = 1, t = 2}
• Сума протилежних граней завжди 7

Поєднуючи вище рекурсивно (використовуючи {1,2,3} твердокодований як вихідний пункт), ми можемо генерувати ціле відображення {l, r} -> t для всіх можливих значень. Ця відповідь визначає рекурсивну функцію g (), яка заповнює повний масив таким, що d [lr] = t. Рекурсивна функція спочатку називається {1,2,3} і повторюється по всьому кубу, поки не буде встановлено більше елементів масиву, які не були встановлені. Функція повторюється в собі двома способами:

• з l і r замінено і t віднято від 7 (протилежні грані)
• при {l, r, t} повернуто до {r, t, l}

Потім виконується простий пошук масиву необхідних значень.

Діалог APL , 9 байт

Відверта заміна символів рішення J ʇǝɥʇıʇǝɥʇuʎs J :

7|3×××+×-

Редагувати: Пізніше я помітив, що саме це рішення було запропоновано ngn 17, 15 січня.

  the division remainder when divided by seven of
  |        three times
  |        | the product of the arguments
  |        |   times   \┌───┐
  |        |     \  ┌───┤ × │
┌────┐   ┌────┐   ┌─┴─┐ └───┘ ┌───┐
│ 7| ├───┤ 3× ├───┤ × │   ┌───┤ + │ - the sum of the arguments
└────┘   └────┘   └─┬─┘ ┌─┴─┐ └───┘      
                    └───┤ × │ ---- times
                        └─┬─┘ ┌───┐
                          └───┤ - │ - the difference between the arguments
                              └───┘

СпробуйтеAPL онлайн!

Джулія, 26 байт

f(a,b)=a$b$7*(2<a^2*b%7<5)

або

f(a,b)=(3*a^5*b^5-a^3*b)%7

або

f(a,b)=3*a*b*(a+b)*(a-b)%7

Лист звичайний, 45 байт

(lambda(a b)(mod(* 3 a b(-(* a a)(* b b)))7))

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

Порт рішення xnor.

C # (Visual C # Interactive Compiler) , 49 байт

x=>1+("3542331463126512156236413"+x).IndexOf(x)/5

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

-1 байт завдяки @GB!

Вхід - це рядок з двома символами, що містить видимі ліві та праві цифри.

Нижче наведено рішення, яке я придумав самостійно. Використовуючи рядок пошуку з відповіді на JavaScript rink.attendant.6 , я зміг відголити 5 байт (але тепер наші відповіді досить схожі;)

C # (Visual C # Interactive Compiler) , 55 байт

x=>1+"42354 31463 51265 21562 41364 24532".IndexOf(x)/6

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