Считаем от 2 000 000 ₄ до миллиона

[Солохин]

10(-2)31 = 9831

Использовал десятичную систему счисления, в которой, однако, не используются цифры 6,7,8,9 - вместо них в ходу -4,-3,-2,-1.

Преимущество её в том, что таблица умножения получается в четыре раза меньше

9831 = 10000-200+30+1

[Python]

 ТТГЕА   ЕТПМ   ЖТГ   ЬАПЕТ (9832)

[Солохин]

1165_21+- = 9833 - снова простое число!

Для записи использовал 21-ичную систему счисления с положительными и отрицательными цифрами -10-9,-8,-7,-6,-5,-4,-3,-2,-1,0,1,2,3,4,5,6,7,8,9,10.

Эта система записи любопытная своей лаконичностью и тем, что таблицу умножения для неё выучить не труднее, чем нашу обычную 10*10

[Python]

dgjknfb
(9834)

[Солохин]

dgjknfb
(9834)

И, кстати 9834 = 910₃₃


113311₆ = 810₃₅ = 35*281 = 9835, причем 281 - простое число

[Солохин]

(13)(13)8₂₇ = 200(10)₁₇ = 9836

[Солохин]

 14440₉ = 111111100₃ =  9837

[Солохин]

14441₉ = 9838

[Солохин]

1634321_!=9839 - снова простое число!

[Python]

٩٨٤٠
(9840)

[Солохин]

٩٨٤٠
(9840)

И кроме того оно весьма круглое.

2*2*2*2*3*5*41  = 1640000_!= 660₄₀ = 2670₁₆ =  303330₅ =  9840

[Python]

2 G81 WG1
(9841)

[Солохин]

2 G81 WG1
(9841)

Не могу не отметить, что это ещё и христианский символ, и довольно круглое число.

♱= 13*757  = 1(40)(40)₈₁ = (13)(13)(13)₂₇ = 4630₁₃ =  14444₉ = 111111111₃ =  = 9841

[Солохин]

♲ = 2(-4)(-4)(-4)(-4)₉ = 113322₆ =  1(-1)(-1)(-1)(-1)(-1)(-1)(-1)(-1)(-1)₃  = 9842

[Солохин]

♳= 1(-11)(-11)(-11)₂₆ = 303333₅ =  9843

[Солохин]

♴= 1(-7)(-44)₁₀₃ =  (98)(44)₁₀₀ =  12(44)₉₈ =  17(-44)₉₆ =  20(44)₇₀ =  2(44)4₆₀ = 37(44)₅₆ = 3(46)(44)₅₀ = 44(44)₄₉ =  9844

Странное число, которое любит "44" 

[Python]

CLVX̅ = 9845

[Солохин]

{71624385}= 9846

Поясняю.

Мне понадобилось пронумеровать все перестановки. И я придумал алгоритм такой нумерации. Теперь каждая перестановка имеет свой уникальный номер, а каждому числу соответствует перестановка.

Например:

0 это {}
1 это {21}=2!-1
2 это {132}
3 это {231}
4 это {312}
5 это {321}=3!-1
6 это {1243}
7 это {2143}
8 это {1342}
9 это {2341}
10 это {3142}
11 это {3241}
12 это {1423}
13 это {2413}
14 это {1432}
15 это {2431}
16 это {3412}
17 это {3421}
18 это {4123}
19 это {4213}
20 это {4132}
21 это {4231}
22 это {4312}
23 это {4321}=4!-1
24 это {12354}
25 это {21354}
26 это {13254}
27 это {23154}
28 это {31254}
29 это {32154}
...
115 это {54213}
116 это {54132}
117 это {54231}
118 это {54312}
119 это {54321}=5!-1
120 это {123465}
121 это {213465}
122 это {132465}
123 это {231465}
124 это {312465}
...
718 это {654312}
719 это {654321}=6!-1
720 это {1234576}
721 это {2134576}
и так далее

Сама запись перестановки расшифровывается так: на каждом месте стоит номер того места, с которого надо взять значение.

Работает это так: {321}дома=мода. Если число переставляемых объектов превышает длину перестановки, то они остаются на своих местах. Пустая перестановка {} все оставляет на своих местах.

[Python]

፺፰፻፵፯ (9847) благодарностей! А можно посмотреть сам алгоритм присвоения перестановке номера?

Тоже когда-то задумывался над подобным вопросом в контексте перестановки двоичных разрядов в машинном представлении числа. На уровне железа подобное довольно просто реализовать — странно, что в существующих процессорах нет команды произвольной побитной перестановки, задаваемой номером.

[Солохин]

Конечно! Никаких проблем.
Python-у - на Python-е!

Код Выделить Развернуть


def red(x: list) -> list:
    "Убирает в перестановке лишние (тривиальные) элементы"
    a = x
    while len(a) > 0 and a[len(a) - 1] == len(a):
        a.pop(len(a) - 1)
    return a


def fc(n):
    """переводит число в факториальную систему исчисления
    ответ в виде списка"""
    c = []
    k = 1
    while n:
        c.append(n % k)
        n = n // k
        k = k + 1
    return c


def tl(n):
    """Вычисляет перестановку по номеру, ответ в виде списка"""
    a = fc(n)
    s = []
    ll = len(a)
    m = 1
    for n in range(ll):
        s.insert(len(s) - a[n], m)
        m = m + 1
    return red(s)

def tlpr(n):
    "вычисляет перестановку по номеру n, ответ в виде строки"
    a=tl(n)
    s="{"
    for k in range(len(a)):
        x=a[k]
        if 0<x<10:
            s=s+str(x)
        else:
            s=s+"("+str(x)+")"
    s=s+"}"
    return s


def tr(a):
    "вычисляет номер перестановки"
    a = red(a)
    s = 0
    n = len(a)
    while n > 0:
        k = a.index(n)
        s = s * n + n - k - 1
        a.pop(k)
        n = len(a)
    return s


♷ = {72614385} = 1640101_!= 113331₆ =  9847

[Солохин]

♸= {71634285} = 1640110_!= 23170₈ =  10011001111000₂ = 2*2*2*1231  =  9848

[Солохин]

♹=9849 = {72634185} = 1640111_! = 450₄₉ = 777₃₇ =   40500₇ = (14)(14)(21)₂₆ = 7444₁₁ = 113333₆ = 3*7*7*67  =  9849

Из этого числа прямо-таки лезут семёрки. Из всех щелей.

[Python]

MↂDCCCL(9850)

[Солохин]

Захотелось проверить, как мой комп справится с большими числами. С полпинка! Для него это совсем небольшое число. Посчитал молниеносно.

{81(16)(10)(11)(17)53(18)9(13)7(14)(12)(15)64(19)2} = 19111334537747323110_! = 52754441776475525₉ = 6022650156216021542₇ = 40312142241000000000000₅ = 1202211211111101212120112112120212₃ = 100010111111110110111010101011101011101011000000000000₂ =
(2*5)¹²*9851  =  9851 биллион.

(Во французской системе наименований больших числе биллион - это 1 000 000 000 000)

[Солохин]

"Ага!" - сказали мужики.

Теперь он думал примерно полсекунды.

{9(20)(24)(15)1(17)(16)72(25)(21)3(18)6(19)(13)(11)45(14)8(22)(23)(12)(10)}
1521221218891312133614080520000_!= 11120111210012211111002020121121201122012100101201220₃ =
100000100110001111011111110101111011100010101110001110010101100000000000000000000000₂ = 9852 триллиарда

(Триллиардом во французской системе называется 1000000000000000000000 =10²¹)