의문

Given the atomic number of an element[1-118] 범위 group and period에서 다음 주기율표에서 주어진 요소 의을 출력합니다 .

Lanthanide 및 Actinide 계열의 요소 (범위 [57-71] 및 [89-103])의 경우 대신 LLanthanide 및 AActinides로 돌아와야 합니다.

당신은 쓸 수 있습니다 프로그램이나 기능을 하고, 우리의 사용 표준 방법 입력을 수신하고 출력을 제공합니다.

모든 프로그래밍 언어를 사용할 수 있지만 이러한 허점 은 기본적으로 금지되어 있습니다.

^[출처]

테스트 사례

가능한 입력은 118 개뿐이므로 예상되는 입력 및 출력의 전체 목록이 아래에 나와 있습니다.

손으로 만든 실수가 있으면 알려주세요!

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,
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

채점

간단한 코드 골프 . 가장 짧은 바이트 수

CJam , 64 59 58 56 54 바이트

2 바이트를 절약 해 준 Dennis에게 감사합니다.

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

온라인으로 사용해보십시오!

스택에 마침표와 그룹 또는 단일 문자를 남깁니다.

설명

여기에는 두 가지 주요 아이디어가 있습니다.

• 먼저, Lanthanides 및 Actinides를 다룹니다. 우리는이 상태를 56 <x <72 란탄 족 및 88 <x <104 악티니드를 들어. 이 두 가지 모두 범위의 중심에 절대 차이를 취하여 단일 비교로 표현할 수 있습니다. 불평등은 | x-64 | <8 및 | x-96 | 각각 <8 . 그러나 이것들은 여전히 ​​매우 유사하며 두 비교를 별도로 수행하는 것은 비용이 많이 듭니다. 따라서 두 범위 ( 80) 사이 의 중심과 또 다른 절대 차이를 취함으로써 대칭 범위를 확인하는 동일한 아이디어를 먼저 적용합니다 . || x-80 | -16 | <8. 이 조건은 원자가 Lanthanide 또는 Actinide임을 나타내지 만,이 두 경우를 구별하는 것은 80 (또는 범위 사이의 다른 값)에 비해 사소한 것입니다.
• 출력은 실제로 너비가 18 인 테이블의 인덱스이므로 두 가지 숫자가 그룹과주기를 제공하도록 값을 밑이 18로 기본 변환하는 것이 명백한 방법입니다. 그렇게하려면 몇 가지 값을 바꿔야합니다. 실제로해야 할 일은 1, 2 및 3 기간에 간격을 추가하고 6 및 7 기간에 간격을 닫는 것입니다. 다른 간격의 값이 영향을받지 않도록 끝에서이 작업을 수행하는 것이 가장 쉽습니다. (그리고 그 가치를 유지하십시오).

_            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 바이트

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

설명:

(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

온라인으로 사용해보십시오!

Mathematica, 77 바이트

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

ElementData입력이 Lanthanide인지 Actinide인지 확인하는 데 사용하기도 쉽지만 약 20 바이트가 더 필요합니다.

파이썬 (2) , 205 (136) 바이트

@Dead Possum 덕분에 -26 바이트

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]

온라인으로 사용해보십시오!

PHP, 144 바이트

참고 : 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);

다음과 같이 실행하십시오.

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

설명

입력이 L또는 의 범위 내에 있는지 확인하십시오 A. "예외"범위. 그런 다음 입력을 수정하여 그리드에서 누락 된 셀을 채우거나 추가 셀을 제거하십시오. 마지막으로 예외를 인쇄하거나 (거짓이 아닌 경우 0) 위치를 그리드 좌표로 변환하십시오.

젤리 , 57 바이트

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

원하는 출력을 인쇄하는 전체 프로그램.

온라인으로 사용해보십시오! (모두 인쇄하는 약간 수정 된 프로그램input : output은 여기에서 볼 수 있습니다 ).

방법?

118 개의 가능한 출력 목록을 작성한 다음 입력 색인에서 항목을 선택합니다.

몇 가지 준비 :

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

제 (치환 단축 프로그램 A, B및 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 바이트

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

루비, 130 바이트

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

먼저 비트 마스크 트릭으로 'A'와 'L'을 얻은 다음 18 * 7 사각형에 맞추고 div / mod를 사용하십시오.

파이썬 2 , 137 바이트

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]

온라인으로 사용해보십시오!

파이썬 2 , 115 바이트

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]

온라인으로 사용해보십시오!

아이디어는 그룹과 기간을 얻기 위해 그리드 위치를 div-mod하는 것입니다. 그리드 위치는 n간격 및 L / A 수축을 설명하기 위해 변위에 의해 조정 된 입력 입니다. 이들은 목록에서 추출됩니다.

Lanthanide 및 Actinide 취급은 추악합니다. 이것으로로 탐지 할 수있는 큰 변위 200과 400이 할당됩니다 /200. 문자 L를 A여기 에 넣고 싶지만 n+=...문자를 숫자에 추가하여 n사용하지 않더라도 오류가 발생 합니다. 1- 인덱싱이 아닌 경우 한 번만 divmod참조하는 데 사용할 n수 있으며 표현식으로 대체 될 수 있습니다.

자바 스크립트 (ES7), 100 98 바이트

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>

설명 : 'L'및 'A'시리즈는 직접 비교할 때 3 바이트를 절약 한 비트 논리를 사용하여 특수한 경우입니다. 그렇지 않으면 함수 p는 원하는 원자 번호를 포함하는 기간 x, 이전 기간 의 마지막 요소 수 및 y차이가 2, 2, 8임을 인식하여 매번 계산 된 기간의 마지막 요소 수를 반복적으로 찾습니다. , 8, 18, 18, 즉 2 배의 정사각형 반복. 그런 다음 요소가 베릴륨-스칸듐 대각선 아래에 있는지 여부에 따라 테이블의 왼쪽 또는 오른쪽에서 오프셋하여 그룹을 찾습니다.

자바 스크립트 (ES6), 136 바이트

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)

테스트

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>

파이썬 2 , (264) 227 217 바이트

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]

온라인으로 사용해보십시오!

너무 많은 괄호. Brain-Flak과 비슷합니다.

엑셀, 192 바이트

예쁘지 않습니다. 기존 파이썬 답변에서 차용

=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)=0그룹 가치가 우아하게 작용 하는 경우를 처리하는 데 어려움을 겪고 있습니다 .

루비, 116 바이트

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

테스트 프로그램에서 언급

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 바이트

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에서 입력을 받고로 실행합니다 -nR.

란탄 족과 악티늄에 대한 몇 가지 비트 마술,
$n-= 부분은 간격 및 Lanthanides / Actinides에 대한 오프셋을 더하고 뺍니다.
. 나머지는 간단한 mod / div입니다.

Neil의 답변 의 반복 포트 에는 108 바이트 가 필요 합니다 .

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

펄, 169 바이트

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"

사용 :

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

젤리 , 49 43 42 41 39 바이트

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

온라인으로 사용해보십시오!

배경

란타나 이드 및 악티늄 족을 제외하고, 출력은 bijective base 18로 표현 된 정수로 구성됩니다. 예를 들어, 수소는 19 ₁₀ = 11 _b18 , 헬륨은 36 ₁₀ = 1I _b18 에 해당하고 114 ₁₀ = 7I _b18 .

란타나 이드와 악티늄 족을 란타늄 ( 111 ₁₀ = 63 _b18 )과 악티늄 ( 129 ₁₀ = 73 _b18 )에 해당하는 원자로 매핑 할 수 있습니다 .

이를 위해 원자를 나타내는 정수의 순차를 기록합니다. 예를 들어, 첫 번째 1I의 _B18 - 11 _B18 = H _B18 = 17 ₍₁₀₎ , 두 번째는 1 (AS있는 팽창 주기율표의 연속 된 요소들 사이의 모든 차이) 상기 제 ( B 할 수 )는 2 차원 _B18은 - 22 _B18 = B _b18 = 11 ₁₀ 등. 모든 란타나 이드 및 모든 악티늄 족을 맵핑하기 위해, 두 란탄 족 또는 악티늄 족 (예를 들어, La 에서 Ce로 )의 모든 차이를 0 으로 간주합니다 .

원자 번호 n에 대해 원하는 정수를 얻으려면 차이 앞에 19 (수소)를 붙이고 결과 벡터 의 첫 번째 n 요소의 합계를 계산하면 됩니다. 6 3 (란타나 이드) 또는 7 3 (액티 나이드) 가 표시되지 않는 한, 출력은 단순히 bijective base 18에 표시됩니다 . 후자의 경우 단순히 계산 결과를 L 또는 A로 바꿉니다 .

우리가 인코딩해야하는 벡터는 수평으로 생겼습니다.

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

실행 길이 인코딩 후 다음을 얻습니다.

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

더욱 벡터를 인코딩하는 데 필요한 공간을 줄이기 위해, 우리는 오른쪽 스트립 (1) 의 (길이)와 추가 1 런들에.

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

이제이 자릿수 배열을 기본 45에서 정수로 가역적으로 변환 할 수 있습니다.

20      18      92     12      97     12      134     59      108     59      105

이것들은 모두 250 보다 작으므로 Jelly의 코드 페이지 에서 문자로 나타낼 수 있습니다 . “(literal start)와 ‘(integer array로 해석 )으로 둘러싸인 Jelly 리터럴

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

코드에서 그대로 나타납니다.

작동 원리

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