Вопрос

Given the atomic number of an elementв диапазоне [1-118] выведите group and period, того элемента, как указано в следующей периодической таблице элементов.

Для элементов в рядах лантаноидов и актинидов (диапазоны [57-71] и [89-103]) вы должны вместо этого вернуться Lза лантаноидами и Aактинидами

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

Вы можете использовать любой язык программирования , но учтите, что эти лазейки по умолчанию запрещены.

^{[Источник]}

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

Поскольку имеется только 118 возможных входов, полный список ожидаемых входов и выходов приведен ниже.

Создано вручную, дайте мне знать, если есть ошибка!

1,1,1
2,18,1
3,1,2
4,2,2
5,13,2
6,14,2
7,15,2
8,16,2
9,17,2
10,18,2
11,1,3
12,2,3
13,13,3
14,14,3
15,15,3
16,16,3
17,17,3
18,18,3
19,1,4
20,2,4
21,3,4
22,4,4
23,5,4
24,6,4
25,7,4
26,8,4
27,9,4
28,10,4
29,11,4
30,12,4
31,13,4
32,14,4
33,15,4
34,16,4
35,17,4
36,18,4
37,1,5
38,2,5
39,3,5
40,4,5
41,5,5
42,6,5
43,7,5
44,8,5
45,9,5
46,10,5
47,11,5
48,12,5
49,13,5
50,14,5
51,15,5
52,16,5
53,17,5
54,18,5
55,1,6
56,2,6
57, l,
58, l,
59, l,
60, l,
61, l,
62, l,
63, l,
64, l,
65, l,
66, l,
67, l,
68, l,
69, l,
70, l,
71, l,
72,4,6
73,5,6
74,6,6
75,7,6
76,8,6
77,9,6
78,10,6
79,11,6
80,12,6
81,13,6
82,14,6
83,15,6
84,16,6
85,17,6
86,18,6
87,1,7
88,2,7
89, А,
90, А,
91, А,
92, А,
93, А,
94, A,
95, А,
96, А,
97, А,
98, А,
99, А,
100, А,
101, А,
102, А,
103, А,
104,4,7
105,5,7
106,6,7
107,7,7
108,8,7
109,9,7
110,10,7
111,11,7
112,12,7
113,13,7
114,14,7
115,15,7
116,16,7
117,17,7
118,18,7

счет

Простой код-гольф . Наименьшее количество байтов побеждает

CJam , 64 59 58 56 54 байта

Спасибо Деннису за сохранение 2 байта.

{_80-zG-z8<{80>"LA"=}{_"X8"f>[-14_AAGH].*+:+Imd)}?}

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

Оставляет либо точку и группу, либо один символ в стеке.

объяснение

Здесь есть две основные идеи:

• Сначала мы имеем дело с лантаноидами и актинидами. Мы имеем условие 56 <x <72 для лантаноидов и 88 <x <104 для актинидов. Оба из них можно выразить как одно сравнение, взяв абсолютную разницу в центр диапазона: неравенства становятся | x - 64 | <8 и | х - 96 | <8 соответственно. Но они все еще очень похожи, и выполнение двух сравнений по отдельности стоит дорого. Таким образом, мы применяем ту же идею проверки симметричного диапазона, беря еще одну абсолютную разницу с центром между двумя диапазонами, 80 , сначала: || x-80 | - 16 | <8, Это условие указывает, что атом является либо лантаноидом, либо актинидом, но различие между этими двумя случаями столь же тривиально, как сравнение с 80 (или некоторым другим значением между диапазонами).
• Поскольку выходные данные на самом деле являются индексом в таблице ширины 18, очевидный подход состоит в том, чтобы попытаться преобразовать базовое значение в основное значение 18, чтобы две цифры давали группу и период. Чтобы сделать это, нам нужно изменить некоторые значения. Все, что нам действительно нужно сделать, это добавить разрывы в периоды 1, 2 и 3 и закрыть разрывы в периоды 6 и 7. Это проще всего сделать с конца, чтобы значения других разрывов не затрагивались. (и сохранить свои ценности).

_            e# Make a copy of the input, to figure out whether the output
             e# should be L or A.
80-z         e# Absolute difference from 80.
G-z          e# Absolute difference from 16.
8<           e# Check whether the result is less than 8.
{            e# If so...
  80>        e#   Check whether the input is greater than 80.
  "LA"=      e#   Select 'L or 'A accordingly.
}{           e# ...otherwise...
  _          e#   Duplicate input again.
  "X8"    e#   Push a string with character codes [88 56 12 4 1].
             e#   These are the values just before the gaps.
  f>         e#   Compare the input to each of these.
  [-14_AAGH] e#   Push [-14 -14 10 10 16 17]. These are the changes we need to
             e#   make to remove or insert the gaps corresponding to the above
             e#   positions. Note that the 17 doesn't get paired with an offset.
             e#   It's a constant offset to itself, which is equivalent to
             e#   decrementing the input (to make it zero based) and adding 18
             e#   to make the increment the period and make it 1-based.
  .*         e#   Multiply each gap by whether it's before the input value.
  +:+        e#   Add all of the applicable gaps to the input value.
  Imd        e#   Divmod 18, gives 1-based period and 0-based group.
  )          e#   Increment the group to make it one-based.
}?

05AB1E , 113 102 99 байт

X18©XY‚Dˆ13®Ÿ¯13®Ÿ®LD¯15'L×S15L3+©¯15'A×S®)˜¹<è,XXY8×SD>4 18×SD>S66Sð14×S6 15×S77Sð15×S7 15×S)˜¹<è,

Объяснение:

(start to construct the period part)
X18 ~ push 1 and 18
© ~ store 18 in register_c without p-opping
XY ~ push 1 and 2
13® ~ push 13 and the top element in register_c (18)
Ÿ ~ range - pop 2 values and push [a .. b]
XY ~ push 1 and 2
13®Ÿ ~ range - 13 to 18
XY ~ push 1, 2
13®Ÿ ~ range - 13 to 18
®LD ~ range - 1 to 18 (twice)
2L ~ range - 1 to 2
15'L×S ~ push 'L' 15 times
15L ~ range - 1 to 15
3+ ~ add 3 to each value in topmost element in stack
© ~ store in register-c without popping
2L ~ range - 1 to 2
15'A×S ~ push 'A' 15 times
® ~ push topmost value in register_c
) ~ wrap stack to array
˜ ~ deep flatten
¹<è ~ 1-indexed value of input in array
, ~ print & pop
(start to construct the group part)
XX ~ push 1 twice
Y8×SD ~ push 2 eight times (twice)
> ~ increment each value by 1
4 18×S ~ push 4 eighteen times (twice)
> ~ increment each value by one
66S ~ push 6 twice
ð15×S ~ push a space character 15 times
6 15×S ~ push 6 fifteen times
77S ~ push 7 two times
ð15×S ~ push a space character 15 times
7 15×S ~ push 7 fifteen times
)˜ ~ wrap stack to array and deep flatten
¹<è, ~ get 1-indexed value of input in array, then pop & print

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

Mathematica, 77 байтов

e=ElementData;Which[56<#<72,"L",88<#<104,"A",1>0,{#~e~"Group",#~e~"Period"}]&

Также было бы довольно легко использовать ElementData чтобы определить, является ли ввод лантаноидом или актинидом, но это займет около 20 байтов.

Python 2 , 205 136 байт

-26 байт благодаря @Dead Possum

def f(x):a=(x>71)+(x>99);print((((x-2*(x>1)-8*(x>4)-8*(x>12)+4*a-1)%18+1,(x-(x>17)-14*a)/18+(x>2)+(x>10)+1),'L'),'A')[88<x<104][56<x<72]

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

PHP, 144 байта

Примечание: используется кодировка IBM-850

$x=($a=$argn-1)<57|$a>70?$a>88&$a<103?A:0:L;foreach([16,19=>10,37=>10,92=>-14,110=>-14]as$l=>$m)$a>$l&&$a+=$m;echo$x?:$a%18+1 .~Ë.ceil(++$a/18);

Запустите так:

echo 118 | php -nR '$x=($a=$argn-1)<57|$a>70?$a>88&$a<103?A:0:L;foreach([16,19=>10,37=>10,92=>-14,110=>-14]as$l=>$m)$a>$l&&$a+=$m;echo$x?:$a%18+1 .~Ë.ceil(++$a/18);';echo
> 18,7

объяснение

Проверьте, находится ли вход в пределах диапазона для Lили A; диапазоны «исключений». Затем измените ввод, чтобы заполнить недостающие ячейки в сетке (или избавиться от лишних ячеек). Наконец, напечатайте исключение (если это не ложно 0) или преобразуйте положение в координаты сетки.

Желе , 57 байт

“9Ḳ*!}ḣE’ṃ“¢£Æ¥Ø‘r2/;€"“ⱮḶıð’ḃ7¤µ⁵,12Ṭœṗ;"⁾LAṁ€15¤j“”$⁺³ị

Полная программа, которая печатает желаемый результат.

Попробуйте онлайн! (Слегка измененная программа, которая печатает все,input : outputможно увидеть здесь ).

Как?

Создает список из 118 возможных выходных данных и затем выбирает запись по индексу входных данных.

Некоторая подготовка:

“9Ḳ*!}ḣE’ - base 250 number: 14334152882934570 (call this A)

“¢£Æ¥Ø‘   - a list using Jelly's code page: [1, 2, 13, 4, 18] (call this B)

“ⱮḶıð’    - base 250 number: 2354944025 (call this C)

Программа (укорачивается путем замены A, Bи C):

AṃBr2/;€"Cḃ7¤µ⁵,12Ṭœṗ;"⁾LAṁ€15¤j“”$⁺³ị - Main link: atomicNumber
AṃB                                    - number A with digits B: [1,1,18,18,1,2,13,18,1,2,13,18,1,18,1,18,1,2,4,18,1,2,4,18]
    2/                                 - pair-wise reduce with
   r                                   -     inclusive range: [[1],[18],[1,2],[13,14,15,16,17,18],[1,2],[13,14,15,16,17,18],[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18],[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18],[1,2],[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18],[1,2],[4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]]
            ¤                          - nilad followed by link(s) as a nilad:
         C                             -     number C
          ḃ7                           -     converted to bijective base 7: [1,1,2,2,3,3,4,5,6,6,7,7]
        "                              - zip with:
      ,€                               -     pair each: [[1,1],[18,1],[[1,2],[2,2]],[[13,2],[14,2],[15,2],[16,2],[17,2],[18,2]],[[1,3],[2,3]],[[13,3],[14,3],[15,3],[16,3],[17,3],[18,3]],[[1,4],[2,4],[3,4],[4,4],[5,4],[6,4],[7,4],[8,4],[9,4],[10,4],[11,4],[12,4],[13,4],[14,4],[15,4],[16,4],[17,4],[18,4]],[[1,5],[2,5],[3,5],[4,5],[5,5],[6,5],[7,5],[8,5],[9,5],[10,5],[11,5],[12,5],[13,5],[14,5],[15,5],[16,5],[17,5],[18,5]],[[1,6],[2,6]],[[4,6],[5,6],[6,6],[7,6],[8,6],[9,6],[10,6],[11,6],[12,6],[13,6],[14,6],[15,6],[16,6],[17,6],[18,6]],[[1,7],[2,7]],[[4,7],[5,7],[6,7],[7,7],[8,7],[9,7],[10,7],[11,7],[12,7],[13,7],[14,7],[15,7],[16,7],[17,7],[18,7]]]
             µ                         - monadic chain separation (call the result x)
              ⁵                        - 10
               ,12                     - pair with 12: [10,12]            10↓ 12↓
                  Ṭ                    - truthy indexes: [0,0,0,0,0,0,0,0,0,1,0,1]
                   œṗ                  - partition x at the truthy indexes 
                                       -     (the locations of the runs of L's and A's)
                              ¤        - nilad followed by link(s) as a nilad:

                       ⁾LA             -     ['L','A']
                          ṁ€15         -     mould each like 15: [['L','L','L','L','L','L','L','L','L','L','L','L','L','L','L'],['A','A','A','A','A','A','A','A','A','A','A','A','A','A','A']]
                      "                - zip with:
                     ;                 -     concatenation: [[[1,1],[18,1],[[1,2],[2,2]],[[13,2],[14,2],[15,2],[16,2],[17,2],[18,2]],[[1,3],[2,3]],[[13,3],[14,3],[15,3],[16,3],[17,3],[18,3]],[[1,4],[2,4],[3,4],[4,4],[5,4],[6,4],[7,4],[8,4],[9,4],[10,4],[11,4],[12,4],[13,4],[14,4],[15,4],[16,4],[17,4],[18,4]],[[1,5],[2,5],[3,5],[4,5],[5,5],[6,5],[7,5],[8,5],[9,5],[10,5],[11,5],[12,5],[13,5],[14,5],[15,5],[16,5],[17,5],[18,5]],[[1,6],[2,6]],'L','L','L','L','L','L','L','L','L','L','L','L','L','L','L'],[[[4,6],[5,6],[6,6],[7,6],[8,6],[9,6],[10,6],[11,6],[12,6],[13,6],[14,6],[15,6],[16,6],[17,6],[18,6]],[[1,7],[2,7]],'A','A','A','A','A','A','A','A','A','A','A','A','A','A','A'],[[4,7],[5,7],[6,7],[7,7],[8,7],[9,7],[10,7],[11,7],[12,7],[13,7],[14,7],[15,7],[16,7],[17,7],[18,7]]]

             µ⁵,12Ṭœṗ;"⁾LAṁ€15¤j“”$⁺³ị
                                  $    - last two links as a monad:
                               j“”     -     join with [''] (a workaround for no "flatten by 1")
                                   ⁺   - repeat last link (flatten once more): [[1,1],[18,1],[1,2],[2,2],[13,2],[14,2],[15,2],[16,2],[17,2],[18,2],[1,3],[2,3],[13,3],[14,3],[15,3],[16,3],[17,3],[18,3],[1,4],[2,4],[3,4],[4,4],[5,4],[6,4],[7,4],[8,4],[9,4],[10,4],[11,4],[12,4],[13,4],[14,4],[15,4],[16,4],[17,4],[18,4],[1,5],[2,5],[3,5],[4,5],[5,5],[6,5],[7,5],[8,5],[9,5],[10,5],[11,5],[12,5],[13,5],[14,5],[15,5],[16,5],[17,5],[18,5],[1,6],[2,6],'L','L','L','L','L','L','L','L','L','L','L','L','L','L','L',[4,6],[5,6],[6,6],[7,6],[8,6],[9,6],[10,6],[11,6],[12,6],[13,6],[14,6],[15,6],[16,6],[17,6],[18,6],[1,7],[2,7],'A','A','A','A','A','A','A','A','A','A','A','A','A','A','A',[4,7],[5,7],[6,7],[7,7],[8,7],[9,7],[10,7],[11,7],[12,7],[13,7],[14,7],[15,7],[16,7],[17,7],[18,7]]
                                    ³  - program's first input
                                     ị - index into the list

Perl5, 202 байта

$x=substr(" !2ABMNOPQRabmnopqr\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\301\302LLLLLLLLLLLLLLL\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\341\342KKKKKKKKKKKKKKK\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362",$ARGV[0],1);print$x=~/K/?"A":$x=~/L/?$x:(ord($x)&31).",".(ord($x)>>5)

Рубин, 130 байт

->a{(w=32767)[a-57]>0??L:w[a-89]>0??A:([[1,2],[20,8],[38,8],[107,32],[125,32]].map{|x,y|a>x&&a+=18-y};[(b=a%18)>0?b:18,~-a/18+1])}

Сначала получите 'A' и 'L' с помощью трюка с битовой маской, затем попробуйте вписаться в прямоугольник 18 * 7 и использовать div / mod.

Python 2 , 137 байт

lambda x:[(1+(x>2)+(x>10)+min((~-x/18),3)+(x>86),(x+(x>1)*15+((x>4)+(x>12))*10-((x>71)+(x>103))*14)%18+1),"AL"[89<x]][57<x<72or 89<x<104]

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

Python 2 , 115 байт

def f(n):n+=([0,17]+[33]*3+[43]*8+[53]*45+[200]*14+[39]*18+[400]*14+[25]*15)[n];print[(n%18+1,n/18),'L','A'][n/200]

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

Идея состоит в том, чтобы разделить позицию сетки, чтобы получить группу и период. Положение сетки является входнымn скорректированный смещением, чтобы учесть зазоры и сокращение L / A. Они извлечены из списка.

Работа с лантаноидом и актинидом безобразна. Им назначены большие смещения 200 и 400, которые могут быть обнаружены с помощью /200. Я хотел бы поместить символы Lи Aздесь, но затем n+=...добавлю символ к числу, выдавая ошибку, даже если nона не используется. Если бы не 1-индексирование, divmodможно было бы сослаться на него nтолько один раз, а затем его можно заменить его выражением,

JavaScript (ES7), 100 98 байт

f=(n,p=1,x=0,y=x+2*(p+2>>1)**2)=>(n-57&95)<15?n>71?'A':'L':n>y?f(n,p+1,y):[n-x-1>p/2?n-y+18:n-x,p]

<input type=number min=1 max=118 oninput=o.textContent=f(this.value)><pre id=o>

Объяснение: Ряды 'L' и 'A' имеют специальный регистр, используя некоторую побитовую логику, которая сэкономила мне 3 байта по сравнению с прямыми сравнениями. В противном случае функция рекурсивно находит период, pсодержащий требуемый атомный номер, номер последнего элемента в предыдущем периоде xи номер последнего элемента в периоде, yкоторый вычисляется каждый раз, отмечая, что различия равны 2, 2, 8 , 8, 18, 18 т.е. повторяющиеся двойные квадратные числа. Затем группу находят путем смещения от левой или правой части таблицы в зависимости от того, находится ли элемент под диагональю Бериллий-Скандий или нет.

JavaScript (ES6), 136 байт

n=>[...'112626ii2ff2fff'].reduce((p,i,j)=>(n-=parseInt(i,36))>0?n:+p?+(x='112233456L67A7'[j])?[p+(9258>>j&1?j>5?3:j>2?12:17:0),x]:x:p,n)

Тест

let f =

n=>[...'112626ii2ff2fff'].reduce((p,i,j)=>(n-=parseInt(i,36))>0?n:+p?+(x='112233456L67A7'[j])?[p+(9258>>j&1?j>5?3:j>2?12:17:0),x]:x:p,n)

<input oninput="o.innerHTML=f(+value)" type="number" min=1 max=118/>
<pre id="o"></pre>

Python 2 , 264 227 217 байт

lambda x:((((((((((((((1,1),(18,1))[x>1],(x-2,2))[x>2],(x+8,2))[x>4],(x-10,3))[x>10],(x,3))[x>12],(x-18,4))[x>18],(x-36,5))[x>36],(x-54,6))[x>54],'L')[x>56],(x-68,6))[x>71],(x-86,7))[x>86],'A')[x>88],(x-100,7))[x>103]

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

Слишком много скобок. Это больше похоже на Brain-Flak.

Excel, 192 байта

Далеко не красиво. Займы из существующих ответов Python

=SUBSTITUTE(SUBSTITUTE(IF(ABS(ABS(A1-80)-16)<8,IF(A1<80,"L","A"),MOD(A1-2*(A1>1)-8*(A1>4)-8*(A1>12)+4*((A1>71)+(A1>99)),18)&" ,"&1+(A1>2)+(A1>10)+(A1>18)+(A1>36)+(A1>54)+(A1>86)),0,18),118,10)

Изо всех сил пытается обработать случай, когда MOD(x,18)=0для группы значение изящно.

Рубин, 116 байт

->n{a=(17..143).map{|i|"#{[i%18+1,i/18]}"}
a[2..17]=a[21..30]=a[39..48]=[]
a[57]=[?L]*15
a[75]=[?A]*15
a.flatten[n]}

Комментарий в тестовой программе

f=->n{
a=(17..143).map{|i|"#{[i%18+1,i/18]}"} #Make an array with strings "[18,0]" to "[18,7]" (first value required as input is 1 indexed.)
a[2..17]=a[21..30]=a[39..48]=[]        #Delete "missing" elements from first three periods. 
a[57]=[?L]*15                          #Replace position 57 in the table with a 15-element array ["L".."L"]
a[75]=[?A]*15                          #Replace the correct position in the table with a 15-element array ["A".."A"]
a.flatten[n]}                          #Flatten the array (break the two above elements into 15) and output element n of the array.

1.upto(118){|n|print n,f[n],$/}

PHP, 120 байт

echo(($n=--$argn)-56&95)<15?LA[$n>70]:(($n-=14*($n>88)+14*($n>56)-10*($n>11)-10*($n>3)-16*!!$n)%18+1).",".(($n/18|0)+1);

принимает данные из STDIN, работает с -nR .

немного побитовой магии для лантаноидов и актинидов,
$n-= часть добавляет и вычитает смещения для зазоров и лантанидов / актинидов,
остальное просто мода / дела.

Итеративный порт ответа Нейла занимает 108 байтов :

for(;(95&71+$n=$argn)>14&&$n>$y+=2*(++$p+2>>1)**2;)$x=$y;
echo$p?$n-$x>$p/2+1?$n-$y+18:$n-$x:LA[$n>70],",$p";

Perl, 169 байт

90>($n-=14)&&($g=A)if($n=$v=pop)>88;58>($n-=14)&&($g=L)if$n>56;if(!$g){$c+=vec"\1\0\xe\xc0?\0".("\xff"x9)."?",$i++,1
while$c<$n;$p=1+($i-($g=$i%18||18))/18}say"$v,$g,$p"

С помощью:

perl -E '90>($n-=14)&&($g=A)if($n=$v=pop)>88;58>($n-=14)&&($g=L)if$n>56;if(!$g){$c+=vec"\1\0\xe\xc0?\0".("\xff"x9)."?",$i++,1 while$c<$n;$p=1+($i-($g=$i%18||18))/18}say"$v,$g,$p"' 103

Желе , 49 43 42 41 39 байт

45“ÞØ\€a€⁶;l;i‘bx/€F’ḣ¹Sḃ18µV=“?I‘⁾LAxȯ

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

Задний план

За исключением лантаноидов и актинидов, выход будет состоять из целого числа, выраженного в биективном основании 18. Например, водород соответствует 19 ₁₀ = 11 _b18 , гелию 36 ₁₀ = 1I _b18 и eka-radon / ununoctium / oganesson to 114 ₁₀ = 7I _b18 .

Мы начинаем с сопоставления всех атомных номеров, которые мы можем, с соответствующими целыми числами, а с лантаноидов и актинидов - с теми, которые соответствуют лантану ( 111 ₁₀ = 63 _b18 ) и актинию ( 129 ₁₀ = 73 _b18 ).

Чтобы сделать это, мы записываем прямые различия целых чисел, которые представляют атомы. Например, первое - 1I _b18 - 11 _b18 = H _b18 = 17 ₁₀ , второе - 1 (как и все различия между последовательными элементами нерасширенной периодической таблицы), четвертое (от B до Be ) - 2D _b18 - 22 _b18 = B _b18 = 11 ₁₀ и т. Д. Чтобы отобразить все лантаноиды и все актиниды, мы рассмотрим все различия между двумя лантанидами или к актинидам (например, La к Ce ) быть 0 .

Чтобы получить желаемое целое число для атомного номера n , все, что нам нужно сделать, это добавить 19 (водород) к разностям и вычислить сумму первых n элементов результирующего вектора. Выходные данные затем просто отображаются в биективном основании 18, если только это не будет отображать 6 3 (лантаноиды) или 7 3 (актиниды). В последнем случае мы просто заменим вычисленный результат на L или A .

Обернутый для горизонтального здравого смысла, вектор, который мы должны закодировать, выглядит следующим образом.

19 17  1  1 11  1  1  1  1  1  1  1 11  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1
 1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1  1
 1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  1  1  1  1  1  1  1  1  1  1  1  1  1
 1  1  1  1  1  0  0  0  0  0  0  0  0  0  0  0  0  0  0  1  1  1  1  1  1  1  1  1
 1  1  1  1  1  1

После кодирования длин серий мы получаем следующее.

19 1    17 1    1 2    11 1    1 7    11 1    1 44    0 14    1 18    0 14    1 15

Чтобы еще больше уменьшить пространство, необходимое для кодирования вектора, мы убираем самые правые 1 (длины) и добавляем 1 к серии.

20      18      2 2    12      2 7    12      2 44    1 14    2 18    1 14    2 15

Теперь мы можем обратимо преобразовать эти массивы цифр из основания 45 в целые числа.

20      18      92     12      97     12      134     59      108     59      105

Все они меньше, чем 250 , поэтому мы можем представить их с помощью символов из кодовой страницы Jelly . Окруженный “(буквальный запуск) и ‘(интерпретировать как целочисленный массив), мы получаем литерал Jelly

“ÞØ\€a€⁶;l;i‘

который появляется дословно в коде.

Как это работает

45“…‘bx/€F’ḣ¹Sḃ18µV=“?I‘⁾LAxȯ  Main link. Argument: n (atomic number)

45                             Set the return value to 45.
  “…‘                          Yield [20,18,92,12,97,12,134,59,108,59,105].
     b                         Convert the integers in the array to base 45.
      x/€                      Reduce each resulting digit array (length 1 or 2)
                               by repetition, mapping [z] -> [z] and
                               [y,z] -> [y,…,y] (z times).
         F                     Flatten the result.
          ’                    Decrement, yielding the vector of length 118 from
                               the previous section.
           ḣ¹                  Head; take the first n elements of the vector.
             S                 Compute their sum.
              ḃ18              Convert to bijective base 18, yielding [p, g].
                 µ             Begin a new chain with argument [p,g].
                  V            Eval. The atom casts to string first, so [6,3]
                               , e.g., is mapped to 63, [7,18] to 718, etc.
                   =“?I‘       Compare the result with [63,73], yielding
                               [1,0] for lanthanides, [0,1] for actinides, and
                               [0,0] otherwise.
                        ⁾LAx   Repeat 'L' and 'A' that many times, yielding "L" for
                               lanthanides, "A" for actinides, and "" otherwise.
                            ȯ  Flat logical OR; replace "" with [p,g].