Câu hỏi

Given the atomic number of an elementtrong phạm vi [1-118], xuất ra group and periodphần tử đó, được đưa ra bởi Bảng các phần tử định kỳ sau đây.

Đối với các thành phần trong chuỗi Lanthanide và Actinide, (khoảng [57-71] và [89-103]), thay vào đó, bạn nên quay lại LLanthanides và Acho Actinides

Bạn có thể viết chương trình hoặc chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

^[Nguồn]

Các trường hợp thử nghiệm

Vì chỉ có 118 đầu vào có thể, nên một danh sách đầy đủ các đầu vào và đầu ra dự kiến ​​được đưa ra dưới đây.

Được tạo bằng tay, cho tôi biết nếu có lỗi!

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

Chấm điểm

Mã golf đơn giản . Số byte chiến thắng ngắn nhất

CJam , 64 59 58 56 54 byte

Cảm ơn Dennis vì đã tiết kiệm 2 byte.

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

Hãy thử trực tuyến!

Để lại dấu chấm và nhóm hoặc một ký tự đơn trên ngăn xếp.

Giải trình

Có hai ý chính ở đây:

• Đầu tiên, chúng tôi đối phó với Lanthanides và Actinides. Chúng ta có điều kiện 56 <x <72 đối với Lanthanides và 88 <x <104 đối với Actinides. Cả hai điều này có thể được thể hiện dưới dạng một so sánh duy nhất bằng cách lấy một sự khác biệt tuyệt đối đến trung tâm của phạm vi: các bất đẳng thức trở thành | x - 64 | <8 và | x - 96 | <8 , tương ứng. Nhưng những điều này vẫn rất giống nhau, và thực hiện hai so sánh riêng biệt là tốn kém. Vì vậy, chúng tôi áp dụng cùng một ý tưởng kiểm tra phạm vi đối xứng, bằng cách lấy một sự khác biệt tuyệt đối khác với tâm giữa hai phạm vi, 80 , đầu tiên: || x-80 | - 16 | <8. Điều kiện này chỉ ra rằng nguyên tử là Lanthanide hoặc Actinide, nhưng việc phân biệt giữa hai trường hợp này là tầm thường khi so sánh với 80 (hoặc một số giá trị khác giữa các phạm vi).
• Vì đầu ra thực sự là một chỉ mục trong bảng có chiều rộng 18, nên một cách tiếp cận rõ ràng là thử chuyển đổi giá trị cơ sở thành cơ sở 18, sao cho hai chữ số cho nhóm và dấu chấm. Để làm điều đó, chúng ta cần thay đổi một số giá trị xung quanh. Tất cả những gì chúng ta thực sự cần làm là thêm các khoảng trống trong giai đoạn 1, 2 và 3 và đóng các khoảng trống trong giai đoạn 6 và 7. Dễ dàng thực hiện điều này từ cuối, để các giá trị của các khoảng trống khác không bị ảnh hưởng (và giữ giá trị của họ).

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

Giải trình:

(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

Hãy thử trực tuyến!

Toán học, 77 byte

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

Nó cũng sẽ khá dễ sử dụng ElementDatađể xác định xem đầu vào là Lanthanide hay Actinide, nhưng sẽ mất thêm khoảng 20 byte.

Python 2 , 205 136 byte

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

Hãy thử trực tuyến!

PHP, 144 byte

Lưu ý: sử dụng mã hóa 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);

Chạy như thế này:

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

Giải trình

Kiểm tra xem đầu vào có nằm trong phạm vi cho Lhay A; phạm vi "ngoại lệ". Sau đó sửa đổi đầu vào để điền vào các ô bị thiếu trong lưới (hoặc loại bỏ các ô bổ sung). Cuối cùng, in ngoại lệ (trừ khi đó là giả 0) hoặc chuyển đổi vị trí thành tọa độ lưới.

Thạch , 57 byte

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

Chương trình đầy đủ mà in đầu ra mong muốn.

Hãy thử trực tuyến! (Một chương trình sửa đổi một chút mà in tất cảinput : outputcó thể được nhìn thấy ở đây ).

Làm sao?

Xây dựng danh sách 118 đầu ra có thể và sau đó chọn mục nhập tại chỉ mục của đầu vào.

Một số chuẩn bị:

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

Chương trình (rút ngắn bằng cách thay thế A, Bvà 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])}

Trước tiên, lấy 'A' và 'L' bằng thủ thuật bitmask, sau đó thử khớp với hình chữ nhật 18 * 7 và sử dụng 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]

Hãy thử trực tuyến!

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]

Hãy thử trực tuyến!

Ý tưởng là div-mod vị trí lưới để có được nhóm và thời gian. Vị trí lưới là đầu vào nđược điều chỉnh bởi một sự dịch chuyển để giải thích cho các khoảng trống và sự co lại L / A. Chúng được trích xuất từ ​​một danh sách.

Việc xử lý Lanthanide và Actinide là xấu xí. Chúng được chỉ định chuyển vị lớn 200 và 400 có thể được phát hiện /200. Tôi muốn đặt các nhân vật Lvà Aở đây, nhưng sau đón+=... sẽ thêm một ký tự vào một số, gây ra lỗi ngay cả khi nkhông được sử dụng. Nếu không dùng cho chỉ mục 1, chỉ divmodcó thể được sử dụng để nchỉ một lần, và sau đó nó có thể được thay thế bằng biểu thức của nó,

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>

Giải thích: Chuỗi 'L' và 'A' được phân loại đặc biệt, sử dụng một số logic bitwise giúp tôi tiết kiệm 3 byte so với so sánh trực tiếp. Mặt khác, hàm đệ quy tìm khoảng thời gian pchứa số nguyên tử mong muốn, số phần tử cuối cùng trong giai đoạn trước xvà số phần tử cuối cùng trong khoảng thời gian yđược tính mỗi lần bằng cách lưu ý rằng sự khác biệt là 2, 2, 8 , 8, 18, 18 tức là lặp lại các số vuông gấp đôi. Sau đó, nhóm được tìm thấy bằng cách bù đắp từ bên trái hoặc bên phải của bảng tùy thuộc vào việc phần tử có nằm dưới đường chéo Beryllium-Scandium hay không.

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)

Kiểm tra

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]

Hãy thử trực tuyến!

Cách quá nhiều dấu ngoặc. Nó trông giống như Brain-Flak.

Excel, 192 byte

Xa đẹp. Mượn từ các câu trả lời Python hiện có

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

Đấu tranh để xử lý trường hợp MOD(x,18)=0cho giá trị nhóm một cách duyên dáng.

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

Nhận xét trong chương trình thử nghiệm

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

lấy đầu vào từ STDIN, chạy với -nR.

một số ma thuật Bitwise cho nguyên tố nhóm Lantan và Actinides,
các $n-=phần bổ sung và trừ offsets cho các khoảng trống và nguyên tố nhóm Lantan / Actinides,
phần còn lại là đơn giản mod / div.

Một cổng lặp của câu trả lời Neil Neil có 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"

Sử dụng:

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

Thạch , 49 43 42 41 39 byte

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

Hãy thử trực tuyến!

Lý lịch

Ngoại trừ lanthanides và actinide, đầu ra sẽ bao gồm một số nguyên được biểu thị trong cơ sở _{phỏng đoán} 18. Ví dụ, hydro tương ứng với 19 ₁₀ = 11 _b18 , helium đến 36 ₁₀ = 1I _b18 và eka-radon / ununoctium / oganesson 114 ₁₀ = 7I _b18 .

Chúng tôi bắt đầu bằng cách ánh xạ tất cả các số nguyên tử có thể vào các số nguyên tương ứng, trong khi ánh xạ lanthanide và actinide đến các số tương ứng với lanthanum ( 111 ₁₀ = 63 _b18 ) và _Actinium ( 129 ₁₀ = 73 _b18 ).

Để làm điều này, chúng tôi ghi lại sự khác biệt về phía trước của các số nguyên đại diện cho các nguyên tử. Ví dụ: đầu tiên là 1I _b18 - 11 _b18 = H _b18 = 17 ₁₀ , lần thứ hai là 1 (như tất cả các khác biệt giữa các yếu tố liên tiếp của bảng tuần hoàn chưa được mở rộng), lần thứ tư ( B đến Be ) là 2D _b18 - 22 _b18 = B _b18 = 11 ₁₀ , v.v. Để ánh xạ tất cả các lanthanide và tất cả các actinide, chúng tôi sẽ xem xét tất cả sự khác biệt giữa hai lanthanide hoặc các actinide (ví dụ: La đến Ce ) là 0 .

Để có được số nguyên mong muốn cho số nguyên tử n , tất cả những gì chúng ta phải làm là thêm 19 (hydro) vào các khác biệt và tính tổng của n phần tử đầu tiên của vectơ kết quả. Đầu ra sau đó được hiển thị đơn giản trong cơ sở sinh học 18, trừ khi điều này sẽ hiển thị 6 3 (lanthanides) hoặc 7 3 (actinide). Trong trường hợp sau, chúng tôi chỉ đơn giản là thay thế các kết quả tính toán với L hoặc Một .

Được bao bọc cho sự tỉnh táo theo chiều ngang, vectơ chúng ta phải mã hóa trông như sau.

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

Sau khi mã hóa chiều dài chạy, chúng tôi nhận được sau đây.

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

Để giảm không gian cần thiết để mã hóa vectơ hơn nữa, chúng tôi tước hết ( 1 ) độ dài bên phải và thêm 1 vào các lần chạy.

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

Bây giờ chúng ta có thể chuyển đổi ngược lại các mảng chữ số này từ cơ sở 45 sang số nguyên.

20      18      92     12      97     12      134     59      108     59      105

Tất cả những cái này nhỏ hơn 250 , vì vậy chúng tôi có thể biểu diễn chúng bằng các ký tự từ trang mã của Jelly . Được bao quanh với “(bắt đầu bằng chữ) và ‘(diễn giải thành mảng số nguyên), chúng ta có được chữ Jelly

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

mà xuất hiện nguyên văn trong mã.

Làm thế nào nó hoạt động

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