Química 101 - Introdução à tabela periódica


24

Questão

Given the atomic number of an elementno intervalo [1-118], emita o group and period, desse elemento, conforme indicado na tabela periódica de elementos a seguir.

Para elementos das séries Lanthanide e Actinide (intervalos [57-71] e [89-103]), você deve retornar Lpara os Lanthanides e Aos Actinides

Você pode escrever um programa ou uma função e usar qualquer um dos nossos métodos padrão de recebimento de entrada e saída.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

insira a descrição da imagem aqui

[Fonte]

Casos de teste

Como existem apenas 118 entradas possíveis, uma lista completa das entradas e saídas esperadas é fornecida abaixo.

Criado à mão, avise-me se houver algum erro!

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

Pontuação

simples . Menor número de bytes ganhos


5
Eu só sei que Mathematica terá um built-in para este ...
Okx

@Okx, eu estou esperando que o lantanídeos e actinídeos atrapalhar qualquer built-ins :)
James Webster

2
Você tem permissão para retornar "6, L" e "7, A" para os lantanídeos e actinídeos?
Neil

11
ainda não posso comentar, mas às vezes o hidrogênio é colocado no grupo 17 - mas reconheço que você usou uma imagem para justificar o porquê do grupo 1 e não sabe se isso dificulta ou facilita as coisas?
SJB-2812

11
Lestá bem. Isso é realmente o que eu pretendia. Mas desde que o CSV emitido L,eu vou aceitar tanto
James Webster

Respostas:


10

CJam , 64 59 58 56 54 bytes

Agradecimentos a Dennis por salvar 2 bytes.

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

Experimente online!

Deixa período e grupo ou um único caractere na pilha.

Explicação

Existem duas idéias principais aqui:

  • Primeiro, lidamos com os lantanídeos e actinídeos. Temos a condição 56 <x <72 para os lantanídeos e 88 <x <104 para os actinídeos. Ambos podem ser expressos como uma comparação única, levando uma diferença absoluta para o centro do intervalo: as desigualdades se tornam | x - 64 | <8 e | x - 96 | <8 , respectivamente. Mas estes ainda são muito semelhantes, e fazer as duas comparações separadamente é caro. Portanto, aplicamos a mesma idéia de verificar um intervalo simétrico, tomando outra diferença absoluta com o centro entre os dois intervalos, 80 , primeiro: || x-80 | 16 | <8. Essa condição indica que o átomo é um lantanídeo ou um actinídeo, mas a distinção entre esses dois casos é tão trivial quanto a comparação com 80 (ou algum outro valor entre os intervalos).
  • Como a saída é realmente um índice em uma tabela de largura 18, uma abordagem óbvia é tentar converter o valor em base 18, para que os dois dígitos forneçam grupo e período. Para fazer isso, precisamos mudar alguns valores. Tudo o que realmente precisamos fazer é adicionar as lacunas nos períodos 1, 2 e 3 e fechar as lacunas nos períodos 6 e 7. É mais fácil fazer isso desde o final, para que os valores das outras lacunas não sejam afetados. (e mantenha seus valores).

_            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.
}?

9

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

Explicação:

(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

Experimente online!


Usar uma máscara como essa 1000000000000000000000000000000001 1100000000000000000000000000111111 1100000000000000000000000000111111 1112222222222222221111111111111111 1113333333333333331111111111111111pode reduzir o número de unidades, caso contrário, é bom!
Urna de polvo mágico

7

Mathematica, 77 bytes

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

Também seria muito fácil de usar ElementDatapara determinar se a entrada é um Lanthanide ou Actinide, mas levaria cerca de 20 bytes a mais.


3
Sério, builtins de novo?
Matthew Roh

11
@MatthewRoh Tenho certeza de que uma solução aritmética bem treinada em um idioma de golfe vencerá facilmente isso.
Martin Ender

@ MartinEnder Bem, eu tenho certeza do exato oposto.
Erik the Outgolfer

@EriktheOutgolfer Bem, lá está você . Tenho certeza que Jelly poderia cortar outros 30-50%.
Martin Ender

@MartinEnder Provavelmente deixarei isso para Dennis, não posso fazer isso no período dos exames.
Erik the Outgolfer


3

PHP, 144 bytes

Nota: usa codificação 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);

Execute assim:

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

Explicação

Verifique se a entrada está dentro dos intervalos para Lou A; a "exceção" varia. Em seguida, modifique a entrada para preencher as células ausentes na grade (ou se livrar das células extras). Por fim, imprima a exceção (a menos que isso seja falso 0) ou converta a posição em coordenadas da grade.


Executando seu exemplo, a saída que recebo é 18<t7. Isso é algo que estou fazendo de errado? (rodando em Mac El Capitan)
James Webster

11
@ JamesWebster, devido à codificação que usei para a vírgula. Se você não pode mudar a codificação do seu terminal, você pode substituir a coisa entre os 2 pontos (um pouco antes ceil) com "" por 1 byte extra
aross

3

Geléia , 57 bytes

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

Programa completo que imprime a saída desejada.

Experimente online! (Um programa ligeiramente modificado que imprime tudoinput : outputpode ser visto aqui ).

Quão?

Cria uma lista das 118 saídas possíveis e escolhe a entrada no índice da entrada.

Alguma preparação:

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

O programa (encurtado substituindo A, B, e 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

2

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)

Eu recomendaria encurtar a parte '\ 201 \ 202 \ 203 \ ... \ 362' da string. Sério, é longo como Parreira.
Matthew Roh

11
Curioso como @MatthewRoh mediu o diabo.
Hby2Py 17/03

2

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

Primeiro, pegue o 'A' e o 'L' com o truque da máscara de bit e tente encaixar-se em um retângulo 18 * 7 e use um div / mod.


2

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]

Experimente online!


2

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]

Experimente online!

A idéia é modificar a posição da grade para obter o grupo e o período. A posição da grade é a entrada najustada por um deslocamento para levar em conta as lacunas e a contração L / A. Estes são extraídos de uma lista.

O manejo do Lantanídeo e do Actinídeo é feio. A eles são atribuídos grandes deslocamentos 200 e 400 que podem ser detectados /200. Gostaria de colocar os caracteres Le Aaqui, mas depois n+=...adicionarei um caractere a um número, dando um erro mesmo que nnão seja usado. Se não fosse a indexação 1, divmodpoderia ser usado para se referir napenas uma vez e, em seguida, poderia ser substituído por sua expressão,


2

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>

Explicação: As séries 'L' e 'A' são especiais, usando alguma lógica bit a bit que me salvou 3 bytes em comparação direta. Caso contrário, a função encontrará recursivamente o período que pcontém o número atômico desejado, o número do último elemento no período anterior xe o número do último elemento no período yque é calculado cada vez, observando que as diferenças são 2, 2, 8 , 8, 18, 18 ou seja, números quadrados duplicados repetidos. O grupo é encontrado deslocando-se da esquerda ou da direita da tabela, dependendo se o elemento está na diagonal de berílio-escândio ou não.


1

JavaScript (ES6), 136 bytes

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)

Teste


1

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]

Experimente online!

Suportes demais. Parece mais com Brain-Flak.


você não pode colocar isso whilefora da função? ele iria salvar um byte (espaço)
Felipe Nardi Batista

@FelipeNardiBatista - Conseguiu se livrar do whilecircuito completamente :)
ElPedro

1

Excel, 192 bytes

Longe de ser bonita. Empresta as respostas existentes em Python

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

Lutando para lidar com o caso em MOD(x,18)=0que o valor do Grupo é gracioso.


Eu acho que encontrei um erro. O FI para determinar lantanídeos e actinídeos deve ler IF(A1<80?
James Webster

@JamesWebster, bem localizado. Ter corrigido.
Wernisch 12/09

0

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

Comentado no programa de teste

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],$/}

0

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

recebe entrada de STDIN, execute com -nR.

alguma mágica bit a bit para os lantanídeos e actinídeos,
o$n-= parte adiciona e subtrai deslocamentos para as lacunas e lantanídeos / actinídeos,
o resto é simples mod / div.

Uma porta iterativa da resposta de Neil leva 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";

0

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"

Usando:

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

0

Geléia , 49 43 42 41 39 bytes

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

Experimente online!

fundo

Com exceção dos lantanídeos e actinídeos, a saída consistirá em um número inteiro expresso na base bijetiva 18. Por exemplo, o hidrogênio corresponde a 19 10 = 11 b18 , o hélio a 36 10 = 1I b18 e o eka-radon / ununoctium / oganesson a 114 10 = 7I b18 .

Começamos mapeando todos os números atômicos que podemos para os números inteiros correspondentes, enquanto mapeamos lantanídeos e actinídeos para aqueles que correspondem ao lantânio ( 111 10 = 63 b18 ) e actínio ( 129 10 = 73 b18 ).

Para fazer isso, registramos as diferenças diretas dos números inteiros que representam os átomos. Por exemplo, o primeiro é 1I b18 - 11 b18 = H b18 = 17 10 , o segundo é 1 (como todas as diferenças entre elementos consecutivos da tabela periódica não expandida), o quarto ( B a Ser ) é 2D b18 - 22 b18 = B b18 = 11 10 e assim por diante. Para mapear todos os lantanídeos e todos os actinídeos, consideraremos todas as diferenças entre dois lantanídeos ou actinídeos (por exemplo, La a Ce ) como 0 .

Para obter o número inteiro desejado para um número atômico n , basta anexar 19 (hidrogênio) às diferenças e calcular a soma dos primeiros n elementos do vetor resultante. A saída é então simplesmente exibida na base bijetiva 18, a menos que isso exiba 6 3 (lantanídeos) ou 7 3 (actinídeos). Neste último caso, simplesmente substituímos o resultado calculado por L ou A .

Embrulhado para sanidade horizontal, o vetor que precisamos codificar tem a seguinte aparência.

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

Após a codificação de execução, obtemos o seguinte.

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

Para reduzir ainda mais o espaço necessário para codificar o vetor, removemos 1 ' à direita (comprimentos) e adicionamos 1 às execuções.

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

Agora podemos converter reversivelmente essas matrizes de dígitos da base 45 para números inteiros.

20      18      92     12      97     12      134     59      108     59      105

Todos esses são menores que 250 , para que possamos representá-los com caracteres da página de código de Jelly . Cercado por (literal start) e (interpretar como array inteiro), obtemos o literal Jelly

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

que aparece literalmente no código.

Como funciona

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

Embora essa seja uma resposta interessante, receio que caia na saída. Em vez de emitir o grupo e o período para a entrada, ele parece gerar o número atômico, o grupo e o período para a tabela completa. Considere se eu lhe pedi uma definição de uma palavra no dicionário e você acabou de produzir um dicionário.
James Webster

O rodapé fornece um conjunto de testes para fácil verificação. Se você removê-lo e fornecer a entrada como argumento, ele imprimirá as informações solicitadas pelas especificações. tio.run/nexus/jelly#@29i@qhhzuF5h2fEPGpakwjEjxq3WedYZz5qmJFUoQ/...
Dennis
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.