Soru

Given the atomic number of an element[1-118] aralığında group and period, aşağıdaki Elementlerin Periyodik Tablosunda verilen şekilde o elementin çıktısını alın .

Lantanid ve Aktinid seri elemanlar için (aralıkları [57-71] ve [89-103]), bunun yerine döndürmelidir LLantanitlerin ve AAktinitlerin için

Bir program veya fonksiyon yazabilir ve standart girdi alma ve çıktı alma yöntemlerimizden herhangi birini kullanabilirsiniz .

Herhangi bir programlama dilini kullanabilirsiniz , ancak bu boşlukların varsayılan olarak yasak olduğunu unutmayın .

^[Kaynak]

Test Kılıfları

Sadece 118 olası giriş bulunduğundan, beklenen giriş ve çıkışların tam listesi aşağıda verilmiştir.

El ile düzenlendi, bir hata olup olmadığını bana bildirin!

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

puanlama

Basit kod-golf . En kısa bayt sayısı kazanır

CJam , 64 59 58 56 54 bayt

2 baytı kurtardığı için Dennis'e teşekkür ederim.

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

Çevrimiçi deneyin!

Yığında dönem veya grup veya tek bir karakter bırakır.

açıklama

Burada iki ana fikir var:

• İlk önce Lantanitler ve Aktinitler ile ilgileniyoruz. Biz koşul var 56 <x <72 Lantanitlerin için ve 88 <x <104 Aktinitlerin için. Bunların her ikisi de, aralığın merkezine mutlak bir fark alarak tek bir karşılaştırma olarak ifade edilebilir: eşitsizlikler | x - 64 | <8 ve | x - 96 | Sırasıyla <8 . Ancak bunlar hala çok benzerdir ve iki karşılaştırmanın ayrı ayrı yapılması pahalıdır. Dolayısıyla, simetrik bir aralığı kontrol etme fikrini uygularız , ilk önce iki aralık arasındaki merkez ile bir başka mutlak fark alarak , 80 , ilk: || x-80 | - 16 | <8. Bu durum, atomun bir Lantanit veya Aktinit olduğunu gösterir, ancak bu iki durum arasında ayrım yapmak 80 (veya aralıklar arasında başka bir değer) ile karşılaştırmak kadar önemsiz olduğunu gösterir.
• Çıktı gerçekten genişlik 18 tablosundaki bir endeks olduğundan, bariz bir yaklaşım, değeri baz 18'e dönüştürmeyi denemektir, böylece iki hane grup ve periyot verir. Bunu yapmak için bazı değerleri etrafında kaydırmamız gerekir. Tek yapmamız gereken, 1, 2 ve 3 numaralı periyotlardaki boşlukları eklemek ve 6 ve 7 numaralı periyotlardaki boşlukları kapatmak. Bunu diğer uçların değerlerinin etkilenmemesi için en kolay şekilde yapın. (ve değerlerini koru).

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

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

Açıklama:

(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

Çevrimiçi deneyin!

Mathematica, 77 bayt

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

ElementDataGirişin bir Lantanit mi yoksa Aktinit mi olduğunu belirlemek oldukça kolay olurdu, ancak yaklaşık 20 bayt daha alacaktır.

Python 2 , 205 136 bayt

@ Posside sayesinde -26 bayt

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]

Çevrimiçi deneyin!

PHP, 144 bayt

Not: IBM-850 kodlamasını kullanır

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

Bu şekilde koş:

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

açıklama

Girişin Lveya için aralıkta olup olmadığını kontrol edin A; "istisna" değişiyor. Ardından, ızgaradaki eksik hücreleri doldurmak için girişi değiştirin (veya fazladan hücrelerden kurtulun). Son olarak, istisnayı (sahte değilse 0) yazdırın veya konumu ızgara koordinatlarına dönüştürün.

Jöle , 57 bayt

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

İstenilen çıktıyı basan tam program.

Çevrimiçi deneyin! (Tümünü basan hafifçe değiştirilmiş bir program buradainput : output görülebilir).

Nasıl?

118 olası çıkışın bir listesini oluşturur ve daha sonra girişi girdi dizininde seçer.

Bazı hazırlık:

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

(İkame kısaltılabilir programı A, Bve 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 bayt

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

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

İlk önce 'A' ve 'L' yi bit maskesi numarasıyla alın, sonra 18 * 7 dikdörtgene sığmaya çalışın ve bir div / mod kullanın.

Python 2 , 137 bayt

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]

Çevrimiçi deneyin!

Python 2 , 115 bayt

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]

Çevrimiçi deneyin!

Fikir, grubu ve periyodu elde etmek için ızgara pozisyonunu div-mod etmektir. Izgara konumu, nboşlukları ve L / A büzülmesini hesaba katan bir yer değiştirme ile ayarlanan giriştir. Bunlar listeden çıkarıldı.

Lantanit ve Aktinit kullanımı çirkindir. Bunlara algılanabilecek büyük yer değiştirmeler 200 ve 400 atanır /200. Karakterleri buraya Lve Aburaya koymak istiyorum, ancak daha sonra kullanılmasa n+=...bile hata veren bir sayıya bir karakter ekleyecektir n. 1-indeksleme için değilse, sadece bir kere divmodifade etmek için kullanılabilir nve sonra ifadesiyle değiştirilebilir,

JavaScript (ES7), 100 98 bayt

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>

Açıklama: 'L' ve 'A' serisi, doğrudan karşılaştırmalarda bana 3 bayt kazandıran bir miktar bit mantığı kullanılarak özel olarak kaselenmiştir. Aksi taktirde fonksiyon p, istenen atom sayısını içeren periyodu x, önceki periyottaki son elementin sayısını ve periyoddaki yfarkların 2, 2, 8 olduğunu not ederek her seferinde hesaplanan periyodun son elementinin sayısını tekrarlı olarak bulur. , 8, 18, 18, yani tekrarlanan iki kat kare sayıları. Daha sonra grup, elemanın Berilyum-Sodyum Stadyumunun köşegen altında olup olmamasına bağlı olarak masanın solundan veya sağından kayma ile bulunur.

JavaScript (ES6), 136 bayt

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)

Ölçek

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 bayt

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]

Çevrimiçi deneyin!

Çok fazla parantez. Brain-Flak'a benziyor.

Excel, 192 bayt

Güzel olmaktan uzak. Mevcut Python cevaplarından ödünç

=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)=0Grubun zarafetle değer verdiği davayı ele almak için mücadele etmek .

Ruby, 116 bayt

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

Test programında yorum yaptı

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 bayt

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'den girdi alır, ile çalışır -nR.

Lantanlar ve Aktinitler için bir miktar bit sihir
, $n-=bölüm boşluklar ve Landanlar / Aktinitler için ofsetler ekler ve çıkarır
, gerisi basit mod / div'dir.

Neil'in cevabının yinelenen bir limanı 108 bayt alır :

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 bayt

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"

Kullanımı:

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 bayt

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

Çevrimiçi deneyin!

Arka fon

Lantanitler ve aktinitler hariç, çıktı, bijektif baz 18'de ifade edilen bir tamsayıdan oluşacaktır. Örneğin, hidrojen, 19 ₁₀ = 11 _b18 , helyum ila 36 ₁₀ = 1 _b18 ve eka-radon / ununoctium / oganesson'a karşılık gelir. 114 ₁₀ = 7I, _b18 .

Lantanitleri ve aktinitleri lantan ( 111 ₁₀ = 63 _b18 ) ve aktinyum ( 129 ₁₀ = 73 _b18 ) ile _eşleşecek olanlara eşlerken, tüm atomik sayıları karşılık gelen tamsayılarla eşleştirerek _başlıyoruz .

Bunu yapmak için, atomları temsil eden tam sayıların ileri farklarını kaydederiz. Örneğin, ilk 1I _B18 - 11 _B18 = H _b18 = 17 ₁₀ , ikinci 1 (gibidir genişletilmemiş periyodik tablonun ardışık elemanları arasındaki tüm farklar), dördüncü ( B için Be ) olan 2 boyutlu _B18 - 22 _B18 = oda _b18 = 11 ₁₀ , ve böyle devam eder. Tüm lantanid'i ve tüm aktinide eşleştirmek için, iki lantanitler arasına ya da aktinidlerdir tüm farklılıkları göz önünde olacak (örn La etmek Ce ) olmak 0 .

Bir atom numarası n için istenen tam sayıyı elde etmek için , tek yapmamız gereken farklılıklara 19 (hidrojen) hazırlamak ve elde edilen vektörün ilk n elemanlarının toplamını hesaplamaktır . Çıktı daha sonra, basitçe 6 3 (lantanitler) veya 7 3 (aktinitler) göstermediği sürece, bijektif baz 18'de gösterilir . İkinci durumda, hesaplanan sonucu L ya da A ile değiştiririz .

Yatay akıl sağlığı için sarılmış, kodlamamız gereken vektör aşağıdaki gibi gözüküyor.

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

Çalışma uzunluğu kodlamasından sonra aşağıdakileri elde ederiz.

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

Vektörü daha fazla kodlamak için gereken boşluğu azaltmak için, hemen hemen 1 'ler (uzunluklar) sıyırır ve koşulara 1 ekleriz .

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

Şimdi bu rakam dizilerini tersine çevirerek 45 tabanından tam sayılara dönüştürebiliriz.

20      18      92     12      97     12      134     59      108     59      105

Bunların hepsi 250'den küçüktür , bu yüzden onları Jelly'in kod sayfasındaki karakterlerle temsil edebiliriz . İle çevrili “(literal başlangıcı) ve ‘(tamsayı dizisi olarak yorumlamak), biz Jelly değişmezi olsun

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

Bu kodda verbatim görünüyor.

Nasıl çalışır

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