Frage

Given the atomic number of an elementGeben Sie im Bereich [1-118] das Ergebnis group and perioddieses Elements aus, wie im folgenden Periodensystem der Elemente angegeben.

Für Elemente der Lanthaniden- und Actiniden-Reihe (Bereiche [57-71] und [89-103]) sollten Sie stattdessen Lfür die Lanthaniden und Afür die Actiniden zurückkehren

Sie können ein Programm oder eine Funktion schreiben und eine unserer Standardmethoden zum Empfangen und Bereitstellen von Eingaben verwenden.

Sie können jede Programmiersprache verwenden , beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind.

^[Quelle]

Testfälle

Da es nur 118 mögliche Eingaben gibt, finden Sie unten eine vollständige Liste der erwarteten Ein- und Ausgaben.

Von Hand erstellt, lass es mich wissen, wenn ein Fehler vorliegt!

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

Wertung

Einfaches Code-Golf . Die kürzeste Anzahl von Bytes gewinnt

CJam , 64 59 58 56 54 Bytes

Vielen Dank an Dennis für das Speichern von 2 Bytes.

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

Probieren Sie es online!

Lässt entweder Punkt und Gruppe oder ein einzelnes Zeichen auf dem Stapel.

Erläuterung

Hier gibt es zwei Hauptideen:

• Zunächst beschäftigen wir uns mit den Lanthanoiden und Actinoiden. Wir haben die Bedingung 56 <x <72 für Lanthanoide und 88 <x <104 für Actinoide. Beide können als ein einziger Vergleich ausgedrückt werden, indem ein absoluter Unterschied zur Mitte des Bereichs genommen wird: Die Ungleichungen werden zu | x - 64 | <8 und | x - 96 | Jeweils <8 . Diese sind jedoch immer noch sehr ähnlich, und es ist teuer, die beiden Vergleiche getrennt durchzuführen. Wir wenden also die gleiche Idee an, einen symmetrischen Bereich zu prüfen, indem wir zunächst einen weiteren absoluten Unterschied zum Mittelpunkt zwischen den beiden Bereichen 80 nehmen : || x-80 | - 16 | <8. Diese Bedingung zeigt an, dass das Atom entweder ein Lanthanoid oder ein Actinoid ist, aber die Unterscheidung zwischen diesen beiden Fällen ist genauso trivial wie der Vergleich mit 80 (oder einem anderen Wert zwischen den Bereichen).
• Da es sich bei der Ausgabe in Wirklichkeit um einen Index in einer Tabelle mit der Breite 18 handelt, ist es naheliegend, den Wert mit der Basis in die Basis 18 umzuwandeln, damit die beiden Ziffern Gruppe und Punkt ergeben. Dazu müssen wir allerdings einige Werte verschieben. Alles, was wir wirklich tun müssen, ist, die Lücken in den Perioden 1, 2 und 3 hinzuzufügen und die Lücken in den Perioden 6 und 7 zu schließen. Dies ist am einfachsten am Ende, damit die Werte der anderen Lücken nicht beeinflusst werden (und behalten ihre Werte).

_            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 Bytes

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

Erläuterung:

(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

Probieren Sie es online!

Mathematica, 77 Bytes

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

Es wäre auch recht einfach zu ElementDatabestimmen, ob es sich bei der Eingabe um ein Lanthanoid oder ein Actinoid handelt, aber es würde ungefähr 20 weitere Bytes benötigen.

Python 2 , 205 136 Bytes

-26 Bytes dank @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]

Probieren Sie es online!

PHP, 144 Bytes

Anmerkung: Verwendet die IBM-850-Codierung

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

Laufen Sie wie folgt:

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

Erläuterung

Überprüfen Sie, ob die Eingabe innerhalb der Bereiche für Loder liegt A. die "Ausnahme" Bereiche. Ändern Sie dann die Eingabe, um die fehlenden Zellen im Raster zu füllen (oder entfernen Sie die zusätzlichen Zellen). Drucken Sie abschließend die Ausnahme aus (es sei denn, dies ist falsch 0) oder konvertieren Sie die Position in Gitterkoordinaten.

Jelly , 57 Bytes

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

Volles Programm, das die gewünschte Ausgabe druckt.

Probieren Sie es online! (Ein leicht modifiziertes Programm, das alle drucktinput : output, ist hier zu sehen).

Wie?

Erstellt eine Liste der 118 möglichen Ausgaben und wählt dann den Eintrag am Index der Eingabe aus.

Einige vorbereiten:

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

Das Programm (gekürzt durch Substitution A, Bund 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 Bytes

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

Ruby, 130 Bytes

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

Holen Sie sich zuerst das 'A' und 'L' mit dem Bitmaskentrick, dann versuchen Sie, in ein 18 * 7-Rechteck zu passen und verwenden Sie ein div / mod.

Python 2 , 137 Bytes

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]

Probieren Sie es online!

Python 2 , 115 Bytes

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]

Probieren Sie es online!

Die Idee ist, die Rasterposition zu div-modifizieren, um die Gruppe und den Zeitraum zu erhalten. Die Gitterposition ist die Eingabe n, die durch eine Verschiebung angepasst wird, um Lücken und die L / A-Kontraktion zu berücksichtigen. Diese werden aus einer Liste extrahiert.

Die Handhabung von Lanthanoiden und Actinoiden ist hässlich. Diesen sind große Verschiebungen 200 und 400 zugeordnet, mit denen erkannt werden kann /200. Ich möchte die Zeichen Lund Ahier n+=...einfügen, füge dann aber ein Zeichen zu einer Zahl hinzu und gebe einen Fehler, auch wenn dieser nnicht verwendet wird. Wenn nicht für die 1-Indizierung verwendet werden divmodkönnte, um nnur einmal zu verweisen , und dann könnte es durch seinen Ausdruck ersetzt werden,

JavaScript (ES7), 100 98 Bytes

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>

Erläuterung: Die Reihen 'L' und 'A' sind mit einem speziellen Gehäuse versehen, wobei eine bitweise Logik verwendet wurde, die mir 3 Bytes gegenüber direkten Vergleichen ersparte. Andernfalls findet die Funktion rekursiv die Periode, pdie die gewünschte Ordnungszahl enthält, die Nummer des letzten Elements in der vorherigen Periode xund die Nummer des letzten Elements in der Periode y, die jedes Mal berechnet wird, indem festgestellt wird, dass die Differenzen 2, 2, 8 sind , 8, 18, 18 dh wiederholte doppelte Quadratzahlen. Die Gruppe wird dann durch Versetzen von links oder rechts von der Tabelle gefunden, je nachdem, ob das Element unter der Beryllium-Scandium-Diagonale liegt oder nicht.

JavaScript (ES6), 136 Byte

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)

Prüfung

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 Bytes

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]

Probieren Sie es online!

Viel zu viele Klammern. Es sieht eher aus wie Brain-Flak.

Excel, 192 Bytes

Weit davon entfernt, hübsch zu sein. Entlehnt sich aus vorhandenen Python-Antworten

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

Kämpfen, um den Fall zu behandeln, in dem MOD(x,18)=0für die Gruppe Wert anmutig.

Ruby, 116 Bytes

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

Kommentiert im Testprogramm

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 Bytes

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

Nimmt Eingaben von STDIN, laufe mit -nR.

etwas bitweise Magie für die Lanthaniden und Actiniden,
der $n-=Teil addiert und subtrahiert Offsets für die Lücken und Lanthaniden / Actiniden,
der Rest ist einfach mod / div.

Ein iterativer Port von Neils Antwort benötigt 108 Bytes :

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 Bytes

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"

Verwenden von:

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

Jelly , 49 43 42 41 39 Bytes

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

Probieren Sie es online!

Hintergrund

Mit Ausnahme von Lanthanoiden und Actinoiden wird die Ausgabe aus einer ganzen Zahl bestehen, die in der bijektiven Basis 18 ausgedrückt wird. Beispielsweise entspricht Wasserstoff 19 ₁₀ = 11 _b18 , Helium 36 ₁₀ = 1 _{I b18} und Eka-Radon / Ununoctium / Oganesson bis 114 ₁₀ = 7I _b18 .

Wir beginnen mit der Zuordnung aller uns zur Verfügung stehenden Ordnungszahlen zu den entsprechenden ganzen Zahlen, während wir Lanthaniden und Actiniden denjenigen _zuordnen , die Lanthan ( 111 ₁₀ = 63 _b18 ) und Actinium ( 129 ₁₀ = 73 _b18 ) entsprechen.

Dazu zeichnen wir die Vorwärtsdifferenzen der Ganzzahlen auf, die die Atome darstellen. Zum Beispiel ist die erste 1I _b18 - 11 _b18 = H _b18 = 17 ₁₀ , die zweite ist 1 (wie alle Unterschiede zwischen aufeinanderfolgenden Elementen des nicht expandierten Periodensystems), die vierte ( B bis Be ) ist 2D _b18 - 22 _b18 = B _b18 = 11 ₁₀ und so weiter. Um alle Lanthanoide und alle Actinoide abzubilden, betrachten wir alle Unterschiede zwischen zwei Lanthanoiden oder Actinoiden (z. B. La bis Ce ) als 0 .

Um die gewünschte ganze Zahl für eine Ordnungszahl n zu erhalten , müssen wir den Differenzen lediglich 19 (Wasserstoff) voranstellen und die Summe der ersten n Elemente des resultierenden Vektors berechnen . Die Ausgabe wird dann einfach in der bijektiven Basis 18 angezeigt, es sei denn, dies würde 6 3 (Lanthaniden) oder 7 3 (Aktiniden) anzeigen . Im letzteren Fall ersetzen wir einfach das berechnete Ergebnis mit L oder A .

Umwickelt für horizontale Vernunft sieht der Vektor, den wir codieren müssen, wie folgt aus.

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

Nach der Lauflängencodierung erhalten wir Folgendes.

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

Um den Raum zu reduzieren erforderlich , um den Vektor noch mehr zu kodieren, abzustreifen wir am weitesten rechts liegenden 1 ‚s (Längen) und füge 1 zu den Läufen.

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

Jetzt können wir diese Ziffernfelder reversibel von Basis 45 in ganze Zahlen konvertieren.

20      18      92     12      97     12      134     59      108     59      105

Alle diese Werte sind kleiner als 250 , sodass wir sie mit Zeichen aus Jellys Codepage darstellen können . Umgeben von “(wörtlicher Start) und ‘(interpretiert als Integer-Array) erhalten wir das Jelly-Literal

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

das erscheint wörtlich im Code.

Wie es funktioniert

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