Química 101 - Introducción a la tabla periódica


24

Pregunta

Given the atomic number of an elementen el rango [1-118] genera el group and period, de ese elemento como se indica en la siguiente tabla periódica de elementos.

Para los elementos de las series Lanthanide y Actinide, (rangos [57-71] y [89-103]), en su lugar, debe regresar Lpara los Lanthanides y Apara los Actinides

Puede escribir un programa o una función y utilizar cualquiera de nuestros métodos estándar para recibir entradas y proporcionar salidas.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

ingrese la descripción de la imagen aquí

[Fuente]

Casos de prueba

Como solo hay 118 posibles entradas, a continuación se proporciona una lista completa de las entradas y salidas esperadas.

Creado a mano, ¡avíseme si hay un error!

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

Tanteo

simple . El menor número de bytes gana


55
Solo sé que Mathematica tendrá una función incorporada para esto ...
Okx

@Okx, espero que los Lanthanides y Actinides estropeen cualquier incorporado :)
James Webster

2
¿Está permitido devolver "6, L" y "7, A" para los Lantánidos y Actínidos?
Neil

1
no puedo comentar (todavía) pero a veces Hydrogen se coloca en el grupo 17, pero reconozco que has usado una imagen para justificar por qué el grupo 1 y no sé si esto hace las cosas más difíciles o más fáciles.
sjb-2812

1
Lestá bien. Eso es realmente lo que pretendía. Pero desde que salió el CSV L,, aceptaré ambos
James Webster el

Respuestas:


10

CJam , 64 59 58 56 54 bytes

Gracias a Dennis por guardar 2 bytes.

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

Pruébalo en línea!

Deja período y grupo o un solo personaje en la pila.

Explicación

Aquí hay dos ideas principales:

  • Primero, tratamos con los lantánidos y los actínidos. Tenemos la condición 56 <x <72 para los lantánidos y 88 <x <104 para los actínidos. Ambos pueden expresarse como una comparación única al tomar una diferencia absoluta en el centro del rango: las desigualdades se convierten en | x - 64 | <8 y | x - 96 | <8 , respectivamente. Pero estos siguen siendo muy similares, y hacer las dos comparaciones por separado es costoso. Entonces aplicamos la misma idea de verificar un rango simétrico, tomando otra diferencia absoluta con el centro entre los dos rangos, 80 , primero: || x-80 | - 16 | <8. Esta condición indica que el átomo es un lantánido o un actínido, pero distinguir entre estos dos casos es tan trivial como compararlo con 80 (o algún otro valor entre los rangos).
  • Dado que la salida es realmente un índice en una tabla de ancho 18, un enfoque obvio es intentar convertir el valor en base 18 a base, de modo que los dos dígitos den grupo y punto. Para hacer eso, necesitamos cambiar algunos valores. Todo lo que realmente necesitamos hacer es agregar los espacios en los períodos 1, 2 y 3 y cerrar los espacios en los períodos 6 y 7. Es más fácil hacer esto desde el final, para que los valores de los otros espacios no se vean afectados. (y mantener sus 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)˜¹<è,

Explicación:

(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

Pruébalo en línea!


Usar una máscara como 1000000000000000000000000000000001 1100000000000000000000000000111111 1100000000000000000000000000111111 1112222222222222221111111111111111 1113333333333333331111111111111111puede reducir el bytecount, ¡de lo contrario es bueno!
Magic Octopus Urn

7

Mathematica, 77 bytes

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

También sería bastante fácil de usar ElementDatapara determinar si la entrada es un lantánido o actínido, pero tomaría unos 20 bytes más.


3
En serio, ¿otra vez construido?
Matthew Roh

1
@MatthewRoh Estoy seguro de que una solución aritmética bien desarrollada en un lenguaje de golf superará fácilmente esto.
Martin Ender

@ MartinEnder Bueno, en realidad estoy seguro de todo lo contrario.
Erik the Outgolfer

@EriktheOutgolfer Bueno, ahí lo tienes . Estoy seguro de que Jelly podría cortar otro 30-50%.
Martin Ender

@MartinEnder Probablemente dejaré eso en manos de Dennis, no puedo hacer tal cosa en el período de examen.
Erik the Outgolfer


3

PHP, 144 bytes

Nota: utiliza la codificación 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);

Corre así:

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

Explicación

Compruebe si la entrada está dentro de los rangos para Lo A; los rangos de "excepción". Luego, modifique la entrada para llenar las celdas que faltan en la cuadrícula (o elimine las celdas adicionales). Finalmente, imprima la excepción (a menos que sea falsa 0) o convierta la posición en coordenadas de cuadrícula.


Ejecutando su ejemplo, el resultado que recibo es 18<t7. ¿Es algo que estoy haciendo mal? (corriendo en Mac El Capitan)
James Webster

1
@JamesWebster es por la codificación que usé para la coma. Si no puede cambiar la codificación de su terminal, puede reemplazar la cosa entre los 2 puntos (justo antes ceil) con "," por 1 byte adicional
aross

3

Jalea , 57 bytes

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

Programa completo que imprime la salida deseada.

Pruébalo en línea! (Un programa ligeramente modificado que imprime todoinput : outputse puede ver aquí ).

¿Cómo?

Crea una lista de las 118 salidas posibles y luego selecciona la entrada en el índice de la entrada.

Alguna preparación:

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

El programa (se ha reducido mediante la sustitución A, By 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)

Recomendaría acortar la parte '\ 201 \ 202 \ 203 \ ... \ 362' de la cadena. En serio, es largo como diablos.
Matthew Roh

1
Curioso de cómo @MatthewRoh midió diablos.
hBy2Py

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

Primero obtenga la 'A' y la 'L' con el truco de la máscara de bits, luego intente encajar en un rectángulo de 18 * 7 y use un 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]

Pruébalo en línea!


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]

Pruébalo en línea!

La idea es dividir la posición de la cuadrícula para obtener el grupo y el período. La posición de la cuadrícula es la entrada najustada por un desplazamiento para tener en cuenta los huecos y la contracción L / A. Estos se extraen de una lista.

El manejo de lantánidos y actínidos es feo. A estos se les asignan grandes desplazamientos 200 y 400 que se pueden detectar con /200. Me gustaría poner los caracteres Ly Aaquí, pero luego n+=...agregaré un carácter a un número, dando un error incluso si nno se usa. Si no fuera por la indexación 1, divmodpodría usarse para referirse nsolo una vez, y luego podría reemplazarse con su expresión,


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>

Explicación: Las series 'L' y 'A' están en mayúsculas especiales, utilizando una lógica bit a bit que me ahorró 3 bytes en comparación directa. De lo contrario, la función encuentra recursivamente el período que pcontiene el número atómico deseado, el número del último elemento en el período anterior xy el número del último elemento en el período yque se calcula cada vez al observar que las diferencias son 2, 2, 8 , 8, 18, 18 es decir, números cuadrados duplicados repetidos. Luego, el grupo se encuentra desplazándolo desde la izquierda o la derecha de la tabla, dependiendo de si el elemento se encuentra debajo de la diagonal Berilio-Escandio o no.


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)

Prueba


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]

Pruébalo en línea!

Demasiados soportes. Se parece más a Brain-Flak.


¿No puedes colocar eso whilefuera de la función? ahorraría un byte (espacio)
Felipe Nardi Batista

@FelipeNardiBatista - Se las arregló para deshacerse del whilebucle por completo :)
ElPedro

1

Excel, 192 bytes

Lejos de ser bonita. Toma prestado de las respuestas existentes de 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)

Luchando para manejar el caso donde el MOD(x,18)=0valor del grupo con gracia.


Creo que he encontrado un error. ¿Debería leerse el IF para determinar lantánidos y actínidos IF(A1<80?
James Webster el

@JamesWebster, bien visto. Han corregido
Wernisch

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

Comentó en el programa de prueba

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

toma la entrada de STDIN, ejecuta con -nR.

algo de magia bit a bit para los Lanthanides y Actinides,
la $n-=parte agrega y resta compensaciones para los huecos y Lanthanides / Actinides,
el resto es simple mod / div.

Un puerto iterativo de la respuesta de Neil toma 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"

Utilizando:

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

Gelatina , 49 43 42 41 39 bytes

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

Pruébalo en línea!

Fondo

Con la excepción de los lantánidos y los actínidos, la salida consistirá en un número entero expresado en la base biyectiva 18. Por ejemplo, el hidrógeno corresponde a 19 10 = 11 b18 , el helio a 36 10 = 1I b18 y eka-radón / ununoctio / oganesson a 114 10 = 7I b18 .

Comenzamos mapeando todos los números atómicos que podamos con los enteros correspondientes, mientras mapeamos los lantánidos y los actínidos con los que corresponden al lantano ( 111 10 = 63 b18 ) y al actinio ( 129 10 = 73 b18 ).

Para hacer esto, registramos las diferencias directas de los enteros que representan los átomos. Por ejemplo, el primero es 1I b18 - 11 b18 = H b18 = 17 10 , el segundo es 1 (como lo son todas las diferencias entre los elementos consecutivos de la tabla periódica no expandida), el cuarto ( B to Be ) es 2D b18 - 22 b18 = B b18 = 11 10 , y así sucesivamente. Para mapear todos los lantánidos y todos los actínidos, consideraremos que todas las diferencias entre dos lantánidos o actínidos (p. Ej., De La a Ce ) son 0 .

Para obtener el número entero deseado para un número atómico n , todo lo que tenemos que hacer es anteponer 19 (hidrógeno) a las diferencias y calcular la suma de los primeros n elementos del vector resultante. La salida se muestra simplemente en la base biyectiva 18, a menos que esto muestre 6 3 (lantánidos) o 7 3 (actínidos). En este último caso, simplemente reemplazamos el resultado calculado con L o A .

Envuelto para la cordura horizontal, el vector que tenemos que codificar se ve de la siguiente manera.

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

Después de la codificación de longitud de ejecución, obtenemos lo siguiente.

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

Para reducir aún más el espacio requerido para codificar el vector, eliminamos los 1 '(longitudes) de la derecha y agregamos 1 a las corridas.

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

Ahora podemos convertir de manera reversible estas matrices de dígitos de la base 45 a enteros.

20      18      92     12      97     12      134     59      108     59      105

Todos estos son más pequeños que 250 , por lo que podemos representarlos con caracteres de la página de códigos de Jelly . Rodeado de (inicio literal) e (interpretar como matriz de enteros), obtenemos el literal Jelly

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

que aparece literalmente en el código.

Cómo 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].

Si bien esta es una respuesta interesante, me temo que creo que se cae en la salida. En lugar de generar el grupo y el período para la entrada, parece que genera el número atómico, el grupo y el período para la tabla completa. Considere si le he pedido una definición de diccionario de una palabra y usted acaba de generar un diccionario.
James Webster el

El pie de página proporciona un conjunto de pruebas para una fácil verificación. Si lo elimina y proporciona la entrada como argumento, solo imprimirá la información que solicite la especificación. tio.run/nexus/jelly#@29i@qhhzuF5h2fEPGpakwjEjxq3WedYZz5qmJFUoQ/…
Dennis
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.