Питання

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, л,
60, л,
61, L,
62, л,
63, L,
64, L,
65, л,
66, L,
67, л,
68, л,
69, L,
70, л,
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, А,
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

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

Математика, 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.

Пітон 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 , а ека-радон / унаноктицій / оганессон до 114 ₁₀ = 7I _b18 .

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

Для цього записуємо прямі різниці цілих чисел, які представляють атоми. Наприклад, перший - 1I _b18 - 11 _b18 = H _b18 = 17 ₁₀ , другий - 1 (як і всі різниці між послідовними елементами розгорнутої періодичної таблиці), четвертий ( B to 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].