Количество перестановок на кубе Рубика NxNxN

35

Введение:

Кубик Рубика 3x3x3 имеет возможных перестановок, что составляет приблизительно 43 квинтиллиона . Возможно, вы слышали об этом числе раньше, но как оно на самом деле рассчитывается?43,252,003,274,489,856,000

Кубик Рубика 3х3х3 имеет шесть граней, каждая из которых имеет девять стикеров. Глядя на (внешние) части вместо наклеек, у нас есть шесть центральных частей; восемь угловых частей; и двенадцать краев. Поскольку центры не могут быть перемещены, мы можем игнорировать их в расчетах. Что касается углов и краев:

  • Есть( ) способов расставить восемь углов. Каждый угол имеет три возможных ориентации, хотя только семь (из восьми) могут быть ориентированы независимо; ориентация восьмого / последнего угла зависит от предыдущих семи, учитывая ( 2 , 187 ) возможностей.8!40,320372,187
  • Есть 12!2 (239,500,800) способов расставить двенадцать ребер. Половина из12!это потому, что ребра всегда должны быть вчетной перестановкеименно тогда, когда углы. Одиннадцать ребер могут быть перевернуты независимо друг от друга, при этом переворот двенадцатого / последнего ребра зависит от предыдущих одиннадцати, учитывая211(2,048) возможностей.

Собирая это вместе, мы имеем следующую формулу:

8!×37×12!2×211знак равно43,252,003,274,489,+856,000

Источник: Википедия - Перестановки кубиков Рубика

Хотя это уже может показаться довольно сложным, но для куба 3x3x3 все еще довольно просто. Для четных кубиков формула немного отличается; это формула для куба 4x4x4, например:

8!×37×24!2247знак равно7,401,196,+841,564,901,869,+874,093,974,498,574,336,000,000,000

Что составляет примерно 7,40 кватурдесиллионов по короткой шкале .

А для больших кубов NxNxN (то есть текущего мирового рекорда 33x33x33) формула будет расширена совсем немного. Однако, чтобы не делать это введение слишком длинным, я поместил эти ссылки здесь вместо этого, где перестановки куба 4x4x4 и некоторых кубов NxNxN другого размера объясняются полученной формулой:

Вы можете задаться вопросом: есть ли общая формула, основанная на N для любого куба N x N x N ? Там, безусловно, есть. Вот три совершенно разных алгоритма, каждый из которых дает одинаковые результаты на основе N :

1: Формула Криса Хардвика:

(24×210×12!)N(модификация2)×(7!×36)×(24!)14×(N2-2×N)(4!)6×14×(N-2)2

Попробуйте это на WolframAlpha.

2: Формула триггера Кристофера Моула:

8!×37×(24!(4!)6)14×((N-1)×(N-3)+соз2(N×π2))×(24!)12×(N-2-грех2(N×π2))×(12!×210)грех2(N×π2)×124соз2(N×π2)

Попробуйте это на WolframAlpha.

3: простые числа Кристофера Моула:

212×(2×N×(N+7)1711×(-1)N)×3N×(N+1)+2×512×(2×N×(N-2)+1+(-1)N)×718×(6×N×(N-2)+3+5×(-1)N)×1114×(2×N×(N-2)-1+(-1)N)×9657718×(2×N×(N-2)-3+3×(-1)N)

где 96577 является (13×17×19×23) .

Попробуйте это на WolframAlpha.

Источник: Cubers-reddit - математические формулы подсчета количества позиций, числа Бога и т. Д.

Вызов:

Выберите и реализуйте одну из этих трех формул (или свою собственную производную), которая, учитывая входное целое число N в диапазоне [2,100] , выводит правильный результат.

Правила соревнований:

  • Вы можете использовать другую формулу помимо этих трех, но имейте в виду, что эти три оказались правильными. Если вы используете другую формулу, пожалуйста, добавьте ссылку, откуда вы ее взяли (или, если вы придумали ее самостоятельно, добавьте подробное объяснение). И я проверю все целые числа в диапазоне, если вывод правильный. Возможно, в oeis можно найти вдохновение для этой последовательности: A075152 .
  • Если ваш язык автоматически выводит научный вывод (т.е. 1,401 ...×1045 вместо числа после формулы 4x4x4), это разрешается. Но, пожалуйста, добавьте дополнительный код в ваш ответ, чтобы преобразовать это научное округление в точный вывод, чтобы результаты могли быть проверены, поскольку ошибки округления из-за точности с плавающей запятой при выполнении формулы в вашем коде не допускаются - фактический результат должен быть точный.
  • Ваша программа / функция должна быть правильной, по крайней мере, для входов в диапазоне [2,100] (хотя, поскольку Nзнак равно100 уже приводит к большому количеству заданий, любой больший N , вероятно, будет работать так же хорошо, если вы сможете выведите это правильно).
  • Вы не можете циклически перебирать все возможные перестановки со счетчиком, так как это никогда не выдаст ничего за разумное время. Только реализация формулы (либо одна из трех представленных, производная от одной из них, либо совершенно новая формула), либо другой метод, который даст правильные результаты за разумное время (без жесткого кодирования, конечно ) разрешено. Я думал о добавлении для обеспечения этого, но я лично против в сочетании с , поэтому я не буду. Тем не менее, пожалуйста, убедитесь, что ваша программа дает ответы, и, если по какой-то причине она слишком медленная для TIO, добавьте несколько скриншотов с выводом с вашего локального компьютера в качестве проверки.

Основные правила:

  • Это , поэтому выигрывает самый короткий ответ в байтах.
    Не позволяйте языкам кода-гольфа отговаривать вас от публикации ответов на языках, не относящихся к кодексу. Попробуйте придумать как можно более короткий ответ для «любого» языка программирования.
  • Стандартные правила применяются к вашему ответу с правилами ввода / вывода по умолчанию , поэтому вам разрешено использовать STDIN / STDOUT, функции / метод с правильными параметрами и типом возврата, полные программы. Ваш звонок.
  • По умолчанию лазейки запрещены.
  • Если возможно, добавьте ссылку с тестом для вашего кода (например, TIO ).
  • Кроме того, добавление объяснения для вашего ответа настоятельно рекомендуется.

Тестовые случаи:

Вот тестовые случаи для N в диапазоне [2,10] (не стесняйтесь использовать ссылки WolframAlpha выше для больших тестовых случаев):

n=2
3674160

n=3
43252003274489856000

n=4
7401196841564901869874093974498574336000000000

n=5
282870942277741856536180333107150328293127731985672134721536000000000000000

n=6
157152858401024063281013959519483771508510790313968742344694684829502629887168573442107637760000000000000000000000000

n=7
19500551183731307835329126754019748794904992692043434567152132912323232706135469180065278712755853360682328551719137311299993600000000000000000000000000000000000

n=8
35173780923109452777509592367006557398539936328978098352427605879843998663990903628634874024098344287402504043608416113016679717941937308041012307368528117622006727311360000000000000000000000000000000000000000000000000

n=9
14170392390542612915246393916889970752732946384514830589276833655387444667609821068034079045039617216635075219765012566330942990302517903971787699783519265329288048603083134861573075573092224082416866010882486829056000000000000000000000000000000000000000000000000000000000000000

n=10
82983598512782362708769381780036344745129162094677382883567691311764021348095163778336143207042993152056079271030423741110902768732457008486832096777758106509177169197894747758859723340177608764906985646389382047319811227549112086753524742719830990076805422479380054016000000000000000000000000000000000000000000000000000000000000000000000000000000000

ПРИМЕЧАНИЕ. Так как это задача , она сводится к следующему: реализовать одну из этих трех формул (или производный / ваш собственный метод, который все еще дает правильные результаты) как можно короче.

Кевин Круйссен
источник
2
Делать это в x86-64 будет весело. Мне придется свернуть свой собственный bigint (вероятно, просто 256-битный или 512-битный int) и сделать его гольфием.
moonheart08
1
@ moonheart08 Обратите внимание, что при N = 100 результат занимает около 128 КБ (16 КБ): https://www.wolframalpha.com/input/?i=for+n+%3D+100,+N%5BLog%5B2, + ((24 * 2% 5E10 * 12)% 5EMod% 5BN + 2% 5D + 7 3% 5E6 + 24% 5EFloor% 5B (п% 5E2 + -!!! + 2 + п)% 2F4% 5D)% 2F4!% 5E (6 + Этаж% 5B (n + - + 2)% 5E2% 2F4% 5D)% 5D, 3% 5D
Соломон Уко
4
Обратите внимание, что формула «трига» Моулы просто использует и cos 2 для запутывания s. sin2cos2floor
attinat
4
@attinat, я думаю, что это более полезная перспектива, чтобы сказать, что и триг, и этажи запутывают Nмодификация2
Питер Тейлор
2
@ChristopherMowla Не принимайте их комментарии личными. Я поражен тем, что вы смогли найти эти формулы и, в первую очередь, сделали такие точные прогнозы, и ваши формулы были одним из вдохновителей этой задачи. Однако это код-гольф, поэтому читабельность, производительность, предупреждения, лучшие практики, историческое значение, а иногда и просто здравый смысл выбрасываются за борт, если это может сэкономить один байт в ответе. ;) attinat и PeterTaylor просто предложили такой гольф на основе ваших формул, поскольку N mod 2 гораздо короче для использования в языках программирования, чем trig.
Кевин Круйссен

Ответы:

12

Wolfram Language (Mathematica) , 59 байт

f@n_:=(s=24^6)(24!/s)^(m=n-2)f@m
f@2=7!3^6
f@3=4!12!2^10f@2

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

использует алгоритм Герберта Косиемба, найденный на странице OEIS

вот рекурсивная формула:
a(1)=1; a(2)=7!*3^6; a(3)=8!*3^7*12!*2^10; a(n)=a(n-2)*24^6*(24!/24^6)^(n-2)

6 байтов сохранено @Peter Taylor

еще один байт, сохраненный @Expired Data

J42161217
источник
65 байт
Истек срок действия данных
@ExpiredData очень приятно! Я пытался сделать то же самое, но это не удалось, потому что порядок был другим
J42161217
Вопрос не требует поддержки f@1, поэтому вы можете сэкономить 6 байт. Очевидно, вы также захотите настроить свою тестовую среду для использования Range[2,10].
Питер Тейлор
@PeterTaylor отличное наблюдение. Благодарность!
J42161217
@CSM unfortynately f[3] needs to be defined.Otherwise the formula returns wrong results
J42161217
9

машинный код x86, 119 байт

HexDump:

60 c6 02 02 33 db be 25 01 10 00 f6 c1 01 74 05
be 26 2a b2 36 33 ed 51 b1 06 33 ff 53 8a 04 1a
f6 e1 03 c7 b5 0a f6 f5 88 64 1a 02 66 98 8b f8
4b 79 ea 5b 43 43 f6 f5 66 89 02 84 c0 75 0c 60
8b fa 8d 72 01 8b cb f3 a4 61 4b 41 d1 ee 72 ca
75 f9 be 1d d4 0d 10 4d 79 be 59 49 49 8b e9 be
06 02 02 22 83 f9 02 73 ae c6 44 1a 01 00 80 0c
1a 30 4b 79 f9 61 c3

Функция получает число nв ecxи указатель на строку для заполнения edx(т.е. fastcallсоглашение).

Прежде чем я покажу исходный код, некоторые пояснения о том, как это работает. Он использует рекурсивную формулу, которую я написал следующим образом:

init = 2
m1 = 24^6 = 6*8*9*16*24*32*36
m2 = 24!/24^6 = 6*7*9*10*11*17*19*21*22*23*25*26*35
num(2) = init * 6*7*9*12*15*27
num(3) = init * 6*8*9*12*16*18*20*24*27*28*30*32*33*35*36
num(n+2) = num(n) * m1 * m2^n

Поэтому все, что должен делать код, это умножение на маленькие числа. Числа находятся в диапазоне 6 ... 36, который достаточно мал, чтобы быть представленным в 32-битном растровом изображении. Я на самом деле не храню бит, который представляет умножение на 6 - это позволяет мне расположить код в do-whileцикле, начиная с безусловного умножения на 6.

Большие числа представлены в десятичной форме - каждый байт является значением в диапазоне 0 ... 9, начиная с MSB.

Умножение выполняется от LSB до MSB; Предполагается, что число цифр будет расти на 2 для каждого умножения. После умножения на небольшой коэффициент, такой как 6, количество цифр может увеличиться только на 1. Поэтому, если MSB = 0, он сдвигает весь промежуточный результат влево. На самом деле может случиться так, что количество цифр совсем не увеличится, и тогда MSB все равно будет равен 0, но эта проблема исправится сама по себе, когда код переходит к большим факторам.

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

Код C:

void num(int n, char* x)
{
    *x = 2;
    int len = 1;
    int exp_i;
    uint32_t m32_1;
    int m1;
    int carry;
    int temp;
    int str_i;
    bool cf;

    if (n % 2 == 0)
    {
        m32_1 = 0x100125; // 6*7*9*12*15*27
    }
    else
    {
        m32_1 = 0x36b22a26; // 6*8*9*12*16*18*20*24*27*28*30*32*33*35*36
    }

    exp_i = 0;
    while (true)
    {
        for (; exp_i >= 0; --exp_i)
        {
            m1 = 6;
            cf = true;
        do_mult:
            carry = 0;
            for (str_i = len - 1; str_i >= 0; --str_i)
            {
                temp = x[str_i] * m1 + carry;
                x[str_i + 2] = temp % 10;
                carry = temp / 10;
            }
            len += 2;
            x[1] = carry % 10;
            carry /= 10;
            x[0] = carry;
            if (carry == 0)
            {
                --len;
                for (str_i = 0; str_i < len; ++str_i)
                    x[str_i] = x[str_i + 1];
            }

        shift_m1:
            ++m1;
            cf = m32_1 & 1;
            m32_1 >>= 1;
            if (cf)
                goto do_mult;
            if (m32_1)
                goto shift_m1;

            m32_1 = 0x100dd41d; // 24!/24^6 = 6*7*9*10*11*17*19*21*22*23*25*26*35
        }
        --n;
        --n;
        exp_i = n;
        if (n < 2)
            break;
        m32_1 = 0x22020206; // 24^6

    }
    x[len] = 0;
    for (str_i = len - 1; str_i >= 0; --str_i)
    {
        x[str_i] += '0';
    }
}

Разборка:

60                     pushad;
C6 02 02               mov byte ptr [edx], 2; // edx = x
33 DB                  xor ebx, ebx; // ebx = len - 1
BE 25 01 10 00         mov esi, 0x100125; // esi = m32_1
F6 C1 01               test cl, 1;
74 05                  jz skip1;
BE 26 2A B2 36         mov esi, 0x36b22a26; // esi = m32_1
                   skip1:
33 ED                  xor ebp, ebp; // ebp = exp_i

                   loop_n:

51                     push ecx;
                   loop_exp_i:
B1 06                  mov cl, 6; // cl = m1
                   do_mult:
33 FF                  xor edi, edi; // edi = carry
53                     push ebx; // ebx = str_i
                   loop_str_i:
8A 04 1A               mov al, [edx + ebx];
F6 E1                  mul cl;
03 C7                  add eax, edi;
B5 0A                  mov ch, 10;
F6 F5                  div ch;
88 64 1A 02            mov [edx + ebx + 2], ah;
66 98                  cbw;
8B F8                  mov edi, eax;
4B                     dec ebx;
79 EA                  jns loop_str_i;

5B                     pop ebx; // ebx = len - 1
43                     inc ebx;
43                     inc ebx;
F6 F5                  div ch;
66 89 02               mov [edx], ax;

84 C0                  test al, al;
75 0C                  jnz skip2;

60                     pushad;
8B FA                  mov edi, edx;
8D 72 01               lea esi, [edx + 1];
8B CB                  mov ecx, ebx;
F3 A4                  rep movsb;
61                     popad;
4B                     dec ebx;
                   skip2:

                   shift_m1:
41                     inc ecx;
D1 EE                  shr esi, 1;
72 CA                  jc do_mult;
75 F9                  jnz shift_m1;

BE 1D D4 0D 10         mov esi, 0x100dd41d;

4D                     dec ebp;
79 BE                  jns loop_exp_i;

59                     pop ecx; // ecx = n
49                     dec ecx;
49                     dec ecx;
8B E9                  mov ebp, ecx;
BE 06 02 02 22         mov esi, 0x22020206;
83 F9 02               cmp ecx, 2;
73 AE                  jae loop_n;

C6 44 1A 01 00         mov byte ptr [edx + ebx + 1], 0;
                   loop_to_ascii:
80 0C 1A 30            or byte ptr [edx + ebx], '0';
4B                     dec ebx;
                       dec         ebx  
79 F9                  jns loop_to_ascii;

61                     popad;
C3                     ret;

Время выполнения для n = 100 составляет около 4 секунд, и в результате получается число с 38416 цифрами:

23491019577617 (здесь много цифр) ... (здесь много нулей) 0000000000000000

анатолиг
источник
8

05AB1E , 38 байт

Начальная попытка
Использует формулу Криса Хардвика .
Попробую дальше поиграть в гольф и объяснить, когда у меня будет время.

24©To12!PIÉm7!729®!InI·-4÷mP®IÍn4÷6*m÷

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

Эминья
источник
8

Юлия 1,0 , 83 76 байт

n->^(24576*~12,n%2)*3^6*~7(~24)^((m=n-2)n÷4)/24^(m^2÷4*6)
~n=prod(big,1:n)

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

Использует формулу Криса Хардвика. Принимает ввод как большое целое число.

Спасибо H.PWiz за -7 байт

Кирилл Л.
источник
1
~=n->factorial(big(n))-> ~n=prod(big,1:n)и (24576*~12)^(n%2)->^(24576*~12,n%2)
H.PWiz
Почему вы используете ~=n->вместо ~n=?
H.PWiz
@ H.PWiz, просто потому, что я даже не знал, что это сработает, а также не заметил этого в своем предыдущем комментарии :)
Кирилл Л.
6

JavaScript (Node.js) , 81 байт

Рекурсивная формула Герберта Косиембы. Принимает BigInt в качестве ввода.

f=n=>[1n,3674160n,322252536375n<<27n][--n]||f(--n)*0xb640000n*0xb88d4641131f0n**n

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


JavaScript (Node.js) ,  102 98  96 байт

Формула Криса Хардвика. Принимает BigInt в качестве ввода.

n=>(n&1n?1403325n<<25n:4n)*918540n*0x83629343d3dcd1c00000n**(n*n-n-n>>2n)/24n**(6n*(n*n/4n-~-n))

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

Arnauld
источник
6

JavaScript (Node.js) , 77 75 73 байта

n=>0xb88d4641131f0n**(n*(n-2n)/4n)*13824n**n*851558400n**(n%2n)*315n>>14n

Попробуйте онлайн! Основано на формуле Кристофера Моула. Принимает BigInt в качестве ввода. Испытание жгута бесстыдно украдено у @Arnauld. 0xb88d4641131f0nнаходится 3246670537110000nв десятичной системе счисления. Объяснение: я начал с последнего простого показателя и упростил его до n*(n-2n)/4n(это целочисленное деление, поэтому мне не нужно корректировать нечетные числа). Затем я изучил другие простые числа, чтобы увидеть, были ли их показатели связаны с этим значением (которое я буду называть o), и обнаружил, что они были не в моде, если бы я позволил использовать паритет n(который я буду обозначать как p). Формулы для показателей следующие:

23:       o
19:       o
17:       o
13:       o
11:      2o +   p
 7:      3o +   p +  1
 5:      4o +  2p +  1
 3: 3n + 4o +  3p +  2
 2: 9n + 4o + 14p - 14

Затем полномочия могут быть сгруппированы по показателю степени, например, pпоказатель степени 11*7*5**2*3**3*2**14.

Нил
источник
5

Ракетка , 151 141 байт

-7 байт благодаря fede s.!

(λ(n[e expt])(/(*(e 11771943321600(modulo n 2))3674160(e 620448401733239439360000(floor(/(*(- n 2)n)4))))(e 24(*(floor(/(sqr(- n 2))4))6))))

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

Самый длинный ответ с использованием формулы Криса Хардвика :)

Гален Иванов
источник
1
Вы можете изменить определить для Й (2 байта), а также использовать значение по умолчанию для дополнительного параметра , чтобы сохранить больше 3 байта из трех exptвызовов: (λ(n[e expt])...(e ...)...).
Федерация с.
@fedes. Благодарность!
Гален Иванов
4

Python 2 , 122 байта

import math
f=math.factorial
x=lambda n:(1,f(7)*729,f(8)*3**7*f(12)*1024)[n-1]if n<4else x(n-2)*24**6*(f(24)/24**6)**(n-2)

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

Использует рекурсивный метод Герберта Косиемба.

-2 байта благодаря Herman L

GotCubes
источник
2 байт может быть сохранен путем замены 3**6с 729 и 2**10с 1024 TIO
Herman L
Эй, хороший улов!
GotCubes
Определение вашей собственной факториальной функции на 3 байта короче
ovs
103 байта с фиксированными факториальными значениями
ovs
3

CJam (47 байт)

qi[1_7m!Z6#*_3*Cm!*2D#*]{2-_j24_m!\6#:P/@#*P*}j

Онлайн демо

Это реализует рекурсию Герберта Кочембы из OEIS:

a(N)знак равно{1 если N{0,1}7!×36 если Nзнак равно2a(N-1)×3×12!×213 если Nзнак равно3a(N-2)×(24!246)N-2×246 если N>3
используя запомнившийся оператор рекурсии CJam j. Я упорядочил термины в блоке MathJax в том же порядке, что и в коде, чтобы облегчить проверку соответствия для тех, кто читает CJam: любое дальнейшее изучение не будет проливать больше света.

Питер Тейлор
источник
2

C (gcc) -lgmp, 279 байтов

#include "gmp.h"
#define s mpz_init_set_str
#define m(X)mpz_##X
f(int N,m(t)_){m(t)x;m(init)(x);m(init_set_str)(_,N&1?"3LFbOUwC":"1",62);m(mul_si)(_,_,3674160);m(fac_ui)(x,24);m(pow_ui)(x,x,(N*N-2*N)/4);m(mul)(_,_,x);m(set_si)(x,24);N-=2;m(pow_ui)(x,x,6*N*N/4);m(tdiv_q)(_,_,x);}

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

LambdaBeta
источник
1
Предложить N--*--N/4вместо (N*N-2*N)/4и удалить N-=2и#define s mpz_init_set_str
потолок кошка
1

Шелуха , 51 48 44 байта

-4 байта благодаря H.PWiz

÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12

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

Это Формула Криса Хардвика. Кроме того, это моя первая программа шелухи, поэтому любые советы будут с благодарностью.

Zylviij
источник
1
Вот два простых байта:÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24*1024Π12
H.PWiz
1
Или, еще лучше,÷^*6÷4□-2⁰Π4*^÷4-D⁰□⁰Π24*729*Π7^%2⁰*24576Π12
H.PWiz
1

введите описание изображения здесь

C ++, 187 185 180 176 195 (была ошибка) 193 175 байт (с помощью потолочного кота)

При этом используется оболочка GMP C ++ (библиотека высокой точности GNU) и формула, используемая @ J42161217 ( https://codegolf.stackexchange.com/a/183381/55953 ).

Используйте g++ -g rubix.cpp -lgmp -lgmpxxдля компиляции и ссылки

#include <gmpxx.h>
#define R return
using z=mpz_class;z p(z a,z b){z c=1;while(b--)c*=a;R c;}z r(z n){if(n==2)R 3674160;if(n==3)R z("pX4dIaR7jDk",62);R r(n-2)*p(24,6)*p(z("ErvSErbeq",62),n-2);}

разряженный, с тестовым кодом

#include <gmpxx.h>
#include <iostream>
mpz_class p(mpz_class a, mpz_class b) // returns a to power of b. Only works for b  = positive integer
{
    mpz_class c=1;

    while(b--)
        c*=a;

    return c;
}


mpz_class r(mpz_class n) // returns the rubix permutations for a cube of size n
{
    if(n==2)
        return 3674160; // 7!*3^6;

    if(n==3)
        return z("pX4dIaR7jDk",62); // 43252003274489856000 = 8!*3^7*12!*2^10

    return r(n-2) * p(24,6) * p(z("ErvSErbeq", 62), n-2);

    // "ErvSErbeq"base 62 = 3246670537110000 = (24!/24^6)        
}    

main()
{
    for(int i=2; i<34; i++)
        std::cout<<i<<'\t'<<r(i) << std::endl;
}

https://tio.run/##PZAxb4MwEIV3foWVDrETqBpARMImWZqha7t0iFQZ4xC3xrg2tJERf73UIVXfcE937zvpdEzrqGZsmu6EYrKvOKkbfbncn3dBb4WqgSsa7d6YpNZiBzR0gIYOlGhwgBUb/H0WksMyihBbFRQb3vVGAYZHB4xnFRr@Rqoo4n2SbdNN9pD7Jtk7uNCvafVEn7fvjx@LMItRbqCKYrTSME7D7OoeOpivl4Mp@eeMhFcAj//3AiJa2xlOm13QUKEgCoYAeJ1aA4XqgChiDARJUl/XazRnXrar8py1fUeIIGR57JaE@AUECLllXFUSB2Mw/bCTpLWdIjm/5ua/

CSM
источник
Не могли бы вы добавить скриншот n=10тестового примера, чтобы я мог убедиться, что он работает? Я думаю, что нет никакого способа заставить это работать на C ++ (clang) или C ++ (gcc) TIO из-за используемой библиотеки?
Кевин Круйссен
argg. Это не работает для нечетных значений n
CSM
1
Спасибо за скриншот, и хорошо, что вы смогли точно определить ошибку и исправить ее. +1 от меня. :)
Кевин Круйссен
1
182 байта
потолок кошка
Та @ceilingcat. Возвращение #define больше не нужно, так как есть только две точки возврата
CSM
1

TI-BASIC, 63 62 байта , (неконкурентный)

{fPart(.5Ans),1,1,-6}int(4⁻¹{8,4,Ans²-2Ans,(Ans-2)²:prod({9*11!2^15,7!3^6,24!,24}^Ans

Выражение, которое принимает входные данные как целое число Ans. Реализация формулы Криса Хардвика. Неконкурентный, потому что аппаратное обеспечение, на котором он работает, будет хранить только до 16 десятичных знаков, поэтому ответ никогда не будет точным на 100%.

Объяснение:

{fPart(.5Ans),1,1,-6}              # the list {(N (mod 2))/2,1,1,-6}
                                   # implicitly multiplied by
int(4⁻¹{8,4,Ans²-2Ans,(Ans-2)²     # the list {2,1,⌊¼(N²-2N)⌋,⌊¼(N-2)²⌋}
:                                  # store this list of the formula's exponents as Ans
     {9*11!2^15,7!3^6,24!,24}      # list of the formula's bases
                             ^Ans  # raised to their exponents
prod(                              # multiplied together
                                   # implicit print
Скотт Милнер
источник