Pytanie

Given the atomic number of an elementw zakresie [1-118] wyprowadza group and period, tego elementu, jak podano w poniższym układzie okresowym pierwiastków.

Dla elementów w szeregu lantanowców i aktynowców (zakresy [57-71] i [89-103]), należy zamiast wrócić Ldo lantanowców i Adla aktynowców

Możesz napisać program lub funkcję i użyć dowolnej z naszych standardowych metod otrzymywania danych wejściowych i zapewniania danych wyjściowych.

Możesz używać dowolnego języka programowania , ale pamiętaj, że te luki są domyślnie zabronione.

^[Źródło]

Przypadki testowe

Ponieważ istnieje tylko 118 możliwych danych wejściowych, poniżej podano pełną listę oczekiwanych danych wejściowych i wyjściowych.

Stworzone ręcznie, daj mi znać, jeśli wystąpi błąd!

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, A,
90, A,
91, A,
92, A,
93, A,
94, A,
95, A,
96, A,
97, A,
98, A,
99, A,
100, A,
101, A,
102, A,
103, A,
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

Punktacja

Prosty golf . Najkrótsza liczba bajtów wygrywa

CJam , 64 59 58 56 54 bajtów

Dzięki Dennis za oszczędność 2 bajtów.

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

Wypróbuj online!

Pozostawia kropkę i grupę lub pojedynczy znak na stosie.

Wyjaśnienie

Istnieją tutaj dwa główne pomysły:

• Najpierw mamy do czynienia z Lantanowcami i Aktynowcami. Mamy warunek 56 <x <72 dla lantanowców i 88 <x <104 dla aktynowców. Oba z nich można wyrazić jako pojedyncze porównanie, biorąc absolutną różnicę do środka zakresu: nierówności stają się | x - 64 | <8 i | x - 96 | Odpowiednio <8 . Ale są one nadal bardzo podobne, a wykonanie tych dwóch porównań osobno jest drogie. Dlatego stosujemy ten sam pomysł sprawdzania zakresu symetrycznego, biorąc kolejną absolutną różnicę ze środkiem między dwoma zakresami, 80 , po pierwsze: || x-80 | - 16 | <8. Ten warunek wskazuje, że atom jest albo lantanowcem, albo aktynowcem, ale rozróżnienie między tymi dwoma przypadkami jest wtedy tak proste, jak porównanie z 80 (lub inną wartością między zakresami).
• Ponieważ dane wyjściowe są tak naprawdę indeksem w tabeli o szerokości 18, oczywistym podejściem jest próba przekształcenia wartości podstawowej w podstawę 18, aby dwie cyfry podały grupę i kropkę. Aby to zrobić, musimy jednak zmienić niektóre wartości. Wszystko, co naprawdę musimy zrobić, to dodać luki w okresach 1, 2 i 3 i zamknąć luki w okresach 6 i 7. Najłatwiej to zrobić od końca, aby nie wpływać na wartości innych luk (i zachowaj swoje wartości).

_            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 bajtów

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)˜¹<è,

Wyjaśnienie:

(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

Wypróbuj online!

Mathematica, 77 bajtów

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

Byłoby również dość łatwe w użyciu, ElementDataaby ustalić, czy wsad jest lantanowcem czy aktynowcem, ale zajmie to około 20 dodatkowych bajtów.

Python 2 , 205 136 bajtów

-26 bajtów dzięki @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]

Wypróbuj online!

PHP, 144 bajty

Uwaga: używa kodowania 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);

Uruchom tak:

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

Wyjaśnienie

Sprawdź, czy dane wejściowe mieszczą się w zakresie dla Llub A; zakresy „wyjątków”. Następnie zmodyfikuj dane wejściowe, aby wypełnić brakujące komórki w siatce (lub pozbyć się dodatkowych komórek). Na koniec wydrukuj wyjątek (chyba że jest to fałsz 0) lub przekonwertuj pozycję na współrzędne siatki.

Galaretka , 57 bajtów

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

Pełny program, który drukuje żądane wyjście.

Wypróbuj online! (Nieco zmodyfikowany program, który drukuje wszystkoinput : outputmożna zobaczyć tutaj ).

W jaki sposób?

Tworzy listę 118 możliwych wyników, a następnie wybiera wpis na podstawie indeksu wejścia.

Niektóre prep:

“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)

Program (skrócony przez podstawienie A, Bi 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 bajtów

$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)

Rubinowy, 130 bajtów

->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])}

Najpierw zdobądź „A” i „L” za pomocą sztuczki z maską bitową, a następnie spróbuj dopasować się do prostokąta 18 * 7 i użyj div / mod.

Python 2 , 137 bajtów

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]

Wypróbuj online!

Python 2 , 115 bajtów

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]

Wypróbuj online!

Chodzi o div-mod pozycji siatki, aby uzyskać grupę i kropkę. Pozycja siatki jest wejściemn korygowane przez przesunięcie uwzględniające luki i skurcz L / A. Są one wyodrębniane z listy.

Obsługa lantanowców i aktynowców jest brzydka. Są one przypisywane dużym przemieszczeniom 200 i 400, które można wykryć za pomocą /200. Chciałbym wstawić znaki Li Atutaj, ale następnie n+=...doda znak do liczby, dając błąd, nawet jeśli nnie zostanie użyty. Gdyby nie indeksowanie 1, divmodmożna by go użyć ntylko raz, a następnie zastąpić jego wyrażeniem,

JavaScript (ES7), 100 98 bajtów

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>

Objaśnienie: Serie „L” i „A” są specjalnie zaprojektowane, przy użyciu logiki bitowej, która pozwoliła mi zaoszczędzić 3 bajty w porównaniu z bezpośrednimi porównaniami. W przeciwnym razie funkcja rekurencyjnie znajdzie okres pzawierający pożądaną liczbę atomową, liczbę ostatniego elementu w poprzednim okresie xoraz liczbę ostatniego elementu w okresie, yktóry jest obliczany za każdym razem, zwracając uwagę, że różnice wynoszą 2, 2, 8 , 8, 18, 18 tzn. Powtarzane podwójne liczby kwadratowe. Grupę można następnie znaleźć poprzez przesunięcie z lewej lub prawej strony stołu w zależności od tego, czy element leży pod przekątną Beryl-Scandium, czy nie.

JavaScript (ES6), 136 bajtów

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)

Test

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 bajtów

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]

Wypróbuj online!

O wiele za dużo nawiasów. Wygląda bardziej jak Brain-Flak.

Excel, 192 bajty

Daleko od ładnego. Pożyczki z istniejących odpowiedzi w języku 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)

Walczy, aby poradzić sobie z przypadkiem, w którym MOD(x,18)=0dla Grupy wartość wdzięku.

Rubin, 116 bajtów

->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]}

Skomentowane w programie testowym

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 bajtów

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);

pobiera dane wejściowe ze STDIN, uruchom z -nR .

niektóre bitowe magia dla lantanowców i aktynowców, część dodaje i odejmuje offsety dla luk i lantanowców / aktynowców,
$n-=
reszta jest prosta mod / div.

Iteracyjny port odpowiedzi Neila zajmuje 108 bajtów :

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 bajtów

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"

Za pomocą:

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

Galaretka , 49 43 42 41 39 bajtów

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

Wypróbuj online!

tło

Z wyjątkiem lantanowców i aktynowców, wynik będzie składał się z liczby całkowitej wyrażonej w zasadzie bijective 18. Na przykład wodór odpowiada 19 ₁₀ = 11 _b18 , hel - 36 ₁₀ = 1 I _b18 i eka-radon / ununoctium / oganesson to 114 ₁₀ = 7 I _b18 .

Zaczynamy od mapowania wszystkich liczb atomowych, jakie możemy, do odpowiednich liczb całkowitych, a mapowania lantanowców i aktynowców na te, które odpowiadają lantanowi ( 111 ₁₀ = 63 _b18 ) i aktynowi ( 129 ₁₀ = 73 _b18 ).

Aby to zrobić, rejestrujemy różnice w przód liczb całkowitych reprezentujących atomy. Na przykład pierwszy to 1I _b18 - 11 _b18 = _Hb18 = 17 ₁₀ , drugi to 1 (podobnie jak wszystkie różnice między kolejnymi elementami nierozwiniętego układu okresowego), czwarty (od B do Be ) to 2D _b18 - 22 _b18 = B _b18 = 11 ₁₀ i tak dalej. Aby zmapować wszystkie lantanowce i wszystkie aktynowce, rozważymy wszystkie różnice między dwoma lantanowcami lub aktynowcami (np. La do Ce ) za 0 .

Aby uzyskać pożądaną liczbę całkowitą dla liczby atomowej n , wystarczy, że dodamy 19 (wodór) do różnic i obliczymy sumę pierwszych n elementów uzyskanego wektora. Dane wyjściowe są następnie wyświetlane po prostu w bazie bijective 18, chyba że wyświetlałoby to 6 3 (lantanowce) lub 7 3 (aktynowce). W tym drugim przypadku po prostu zamieniamy obliczony wynik na L lub A. .

Wektor, który musimy zakodować dla poziomego zdrowia psychicznego, wygląda następująco.

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

Po kodowaniu długości przebiegu otrzymujemy następujące informacje.

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

Aby jeszcze bardziej zmniejszyć przestrzeń wymaganą do zakodowania wektora, usuwamy skrajne wartości 1 (długości) i dodajemy 1 do przebiegów.

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

Teraz możemy odwracalnie przekształcić te tablice cyfr z bazy 45 na liczby całkowite.

20      18      92     12      97     12      134     59      108     59      105

Wszystkie są mniejsze niż 250 , więc możemy je reprezentować znakami ze strony kodowej Jelly . Otoczony“ (literał start) i ‘(interpretowany jako tablica liczb całkowitych), otrzymujemy literał Jelly

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

który pojawia się dosłownie w kodzie.

Jak to działa

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].