Pertanyaan

Given the atomic number of an elementdalam kisaran [1-118] menghasilkan group and period, dari unsur tersebut sebagaimana diberikan oleh Tabel Unsur Berkala berikut.

Untuk elemen dalam seri Lanthanide dan Actinide, (rentang [57-71] dan [89-103]), Anda harus kembali Luntuk Lanthanides dan Auntuk Actinides

Anda dapat menulis sebuah program atau fungsi dan menggunakan salah satu metode standar kami untuk menerima input dan memberikan output.

Anda dapat menggunakan bahasa pemrograman apa pun , tetapi perhatikan bahwa celah ini dilarang secara default.

^[Sumber]

Uji Kasus

Karena hanya ada 118 input yang mungkin, daftar lengkap dari input dan output yang diharapkan diberikan di bawah ini.

Diciptakan dengan tangan, beri tahu saya jika ada kesalahan!

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

Mencetak gol

Golf kode sederhana . Jumlah byte terpendek menang

CJam , 64 59 58 56 54 byte

Terima kasih kepada Dennis karena telah menghemat 2 byte.

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

Cobalah online!

Meninggalkan periode dan grup atau satu karakter di tumpukan.

Penjelasan

Ada dua ide utama di sini:

• Pertama, kita berurusan dengan Lanthanides dan Actinides. Kami memiliki kondisi 56 <x <72 untuk Lantanida dan 88 <x <104 untuk Aktinida. Kedua hal ini dapat dinyatakan sebagai perbandingan tunggal dengan mengambil perbedaan absolut ke pusat rentang: ketidaksetaraan menjadi | x - 64 | <8 dan | x - 96 | <8 masing-masing. Tetapi ini masih sangat mirip, dan melakukan dua perbandingan secara terpisah itu mahal. Jadi kami menerapkan ide yang sama untuk memeriksa rentang simetris, dengan mengambil perbedaan absolut lainnya dengan pusat di antara dua rentang, 80 , pertama: || x-80 | - 16 | <8. Kondisi ini menunjukkan bahwa atom adalah suatu Lantanida atau Aktinida, tetapi membedakan antara kedua kasus ini kemudian sepele dibandingkan dengan 80 (atau nilai lain di antara rentang).
• Karena output benar-benar sebuah indeks dalam tabel lebar 18, pendekatan yang jelas adalah mencoba basis-mengubah nilai ke basis 18, sehingga dua digit memberi grup dan titik. Untuk melakukan itu, kita perlu mengubah beberapa nilai. Yang perlu kita lakukan adalah menambahkan celah di periode 1, 2 dan 3 dan menutup celah di periode 6 dan 7. Ini paling mudah untuk melakukan ini dari akhir, sehingga nilai celah lainnya tidak terpengaruh (dan pertahankan nilainya).

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

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

Penjelasan:

(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

Cobalah online!

Mathematica, 77 byte

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

Ini juga akan sangat mudah digunakan ElementDatauntuk menentukan apakah input adalah Lantanida atau Aktinida, tetapi akan membutuhkan sekitar 20 byte lebih.

Python 2 , 205 136 byte

-26 byte berkat @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]

Cobalah online!

PHP, 144 byte

Catatan: menggunakan pengkodean 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);

Jalankan seperti ini:

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

Penjelasan

Periksa apakah input berada dalam kisaran untuk Latau A; rentang "pengecualian". Kemudian modifikasi input untuk mengisi sel-sel yang hilang dalam kisi (atau singkirkan sel ekstra). Akhirnya, cetak pengecualian (kecuali yang salah 0) atau ubah posisi menjadi koordinat kisi.

Jelly , 57 byte

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

Program lengkap yang mencetak output yang diinginkan.

Cobalah online! (Program sedikit dimodifikasi yang mencetak semuainput : outputdapat dilihat di sini ).

Bagaimana?

Buat daftar dari 118 kemungkinan keluaran dan kemudian pilih entri pada indeks input.

Beberapa persiapan:

“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 (disingkat dengan menggantikan A, B, dan 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 byte

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

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

Pertama dapatkan 'A' dan 'L' dengan trik bitmask, kemudian coba masuk ke dalam persegi panjang 18 * 7 dan gunakan div / mod.

Python 2 , 137 byte

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]

Cobalah online!

Python 2 , 115 byte

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]

Cobalah online!

Idenya adalah untuk div-mod posisi grid untuk mendapatkan grup dan titik. Posisi kisi adalah input yang ndisesuaikan dengan perpindahan untuk memperhitungkan kesenjangan dan kontraksi L / A. Ini diekstraksi dari daftar.

Penanganan Lanthanide dan Actinide jelek. Ini ditugaskan perpindahan besar 200 dan 400 yang dapat dideteksi dengan /200. Saya ingin meletakkan karakter Ldan di Asini, tetapi kemudian n+=...akan menambahkan char ke nomor, memberikan kesalahan bahkan jika ntidak digunakan. Jika tidak untuk pengindeksan 1, divmoddapat digunakan untuk merujuk nhanya sekali, dan kemudian dapat diganti dengan ekspresinya,

JavaScript (ES7), 100 98 byte

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>

Penjelasan: Seri 'L' dan 'A' adalah casing khusus, menggunakan beberapa logika bitwise yang menyelamatkan saya 3 byte dari perbandingan langsung. Jika tidak, fungsi secara rekursif menemukan periode yang pberisi nomor atom yang diinginkan, jumlah elemen terakhir pada periode sebelumnya x, dan jumlah elemen terakhir dalam periode yyang dihitung setiap kali dengan mencatat perbedaannya adalah 2, 2, 8 , 8, 18, 18 yaitu berulang bilangan kuadrat ganda. Kelompok ini kemudian ditemukan dengan mengimbangi dari kiri atau kanan meja tergantung pada apakah elemen tersebut terletak di bawah Berilium-Skandium diagonal atau tidak.

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)

Uji

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 byte

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]

Cobalah online!

Kurung terlalu banyak. Itu lebih mirip Brain-Flak.

Excel, 192 byte

Jauh dari cantik. Pinjam dari jawaban Python yang ada

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

Berjuang untuk menangani kasus di mana MOD(x,18)=0untuk nilai Grup anggun.

Ruby, 116 byte

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

Berkomentar dalam program uji

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 byte

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

mengambil input dari STDIN, jalankan dengan -nR.

beberapa bitwise magic untuk Lanthanides dan Actinides,
the$n-= sebagian menambah dan mengurangi offset untuk kesenjangan dan Lantanida / Aktinida,
sisanya adalah sederhana mod / div.

Port berulang dari jawaban Neil membutuhkan 108 byte :

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 byte

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"

Menggunakan:

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 byte

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

Cobalah online!

Latar Belakang

Dengan pengecualian lantanida dan aktinida, output akan terdiri dari bilangan bulat yang dinyatakan dalam basa bijective 18. Sebagai contoh, hidrogen sesuai dengan 19 ₁₀ = 11 _b18 , helium menjadi 36 ₁₀ = 1I _b18 , dan eka-radon / ununoctium / oganesson untuk 114 ₁₀ = 7I _b18 .

Kita mulai dengan memetakan semua nomor atom yang kita bisa ke bilangan bulat yang sesuai, sementara memetakan lantanida dan aktinida dengan yang sesuai dengan lantanum ( 111 ₁₀ = 63 _b18 ) dan actinium ( 129 ₁₀ = 73 _b18 ).

Untuk melakukan ini, kami merekam perbedaan maju bilangan bulat yang mewakili atom. Misalnya, yang pertama adalah 1I _B18 - 11 _B18 = H _B18 = 17 ₁₀ , yang kedua adalah 1 (seperti semua perbedaan antara unsur-unsur berturut-turut dari tabel periodik tidak dikembangkan), keempat ( B ke Be ) adalah 2D _B18 - 22 _B18 = B _b18 = 11 ₁₀ , dan seterusnya. Untuk memetakan semua lantanida dan semua aktinida, kami akan menganggap semua perbedaan antara dua lantanida atau aktinida (misalnya, La ke Ce ) menjadi 0 .

Untuk mendapatkan bilangan bulat yang diinginkan untuk nomor atom n , yang harus kita lakukan adalah menambahkan 19 (hidrogen) ke perbedaan dan menghitung jumlah elemen n pertama dari vektor yang dihasilkan. Output kemudian hanya ditampilkan dalam basis bijective 18, kecuali ini akan menampilkan 6 3 (lantanida) atau 7 3 (aktinida). Dalam kasus terakhir, kami cukup mengganti hasil yang dihitung dengan L atau A .

Dibungkus untuk kewarasan horisontal, vektor kita harus menyandikan terlihat sebagai berikut.

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

Setelah pengodean run-length, kami mendapatkan yang berikut ini.

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

Untuk mengurangi ruang yang dibutuhkan untuk menyandikan vektor lebih banyak lagi, kita lepaskan paling kanan 1 (panjang) dan tambahkan 1 ke run.

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

Sekarang kita dapat secara reversibel mengubah susunan digit ini dari basis 45 ke integer.

20      18      92     12      97     12      134     59      108     59      105

Semua ini lebih kecil dari 250 , sehingga kami dapat mewakilinya dengan karakter dari halaman kode Jelly . Dikelilingi dengan “(awal harfiah) dan ‘(menafsirkan sebagai array integer), kita mendapatkan literal Jelly

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

yang muncul kata demi kata dalam kode.

Bagaimana itu bekerja

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