Chimica 101 - Introduzione alla tavola periodica


24

Domanda

Given the atomic number of an elementnell'intervallo [1-118] emette il group and period, di quell'elemento come dato dalla seguente tavola periodica degli elementi.

Per gli elementi delle serie Lantanide e Actinide (intervalli [57-71] e [89-103]), dovresti invece tornare Lper i Lantanidi e Agli Actinidi

È possibile scrivere un programma o una funzione e utilizzare uno qualsiasi dei nostri metodi standard per ricevere input e fornire output.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

inserisci qui la descrizione dell'immagine

[Fonte]

Casi test

Poiché vi sono solo 118 possibili ingressi, di seguito viene fornito un elenco completo degli ingressi e delle uscite previsti.

Creato a mano, fammi sapere se c'è un errore!

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

punteggio

semplice . Vince il minor numero di byte


5
So solo che Mathematica avrà un built-in per questo ...
Okx,

@Okx, spero che i Lantanidi e gli Attinidi rovinino qualsiasi incorporato :)
James Webster

2
Puoi restituire "6, L" e "7, A" per i lantanidi e gli attinidi?
Neil

1
non posso commentare (ancora) ma a volte l'idrogeno viene inserito nel gruppo 17 - ma riconosco che hai usato un'immagine per giustificare il motivo per cui il gruppo 1 e non so se questo rende le cose più difficili o più facili?
sjb-2812

1
Lè ok. Questo è in realtà quello che intendevo. Ma dal momento che il CSV è uscito L,, accetterò entrambi
James Webster,

Risposte:


10

CJam , 64 59 58 56 54 byte

Grazie a Dennis per aver salvato 2 byte.

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

Provalo online!

Lascia in pila il punto e il gruppo o un singolo personaggio.

Spiegazione

Ci sono due idee principali qui:

  • Innanzitutto, ci occupiamo dei Lantanidi e degli Attinidi. Abbiamo la condizione 56 <x <72 per Lantanidi e 88 <x <104 per Attinidi. Entrambi possono essere espressi come un unico confronto prendendo una differenza assoluta al centro dell'intervallo: le disuguaglianze diventano | x - 64 | <8 e | x - 96 | <8 , rispettivamente. Ma questi sono ancora molto simili e fare i due confronti separatamente è costoso. Quindi applichiamo la stessa idea di controllare un intervallo simmetrico, prendendo un'altra differenza assoluta con il centro tra i due intervalli, 80 , primo: || x-80 | - 16 | <8. Questa condizione indica che l'atomo è o un lantanide o un attinide, ma distinguere tra questi due casi è quindi banale rispetto al confronto con 80 (o qualche altro valore tra gli intervalli).
  • Poiché l'output è in realtà un indice in una tabella di larghezza 18, un approccio ovvio è provare a convertire in base il valore in base 18, in modo che le due cifre indichino gruppo e punto. Per farlo, però, dobbiamo spostare alcuni valori. Tutto ciò che dobbiamo fare è aggiungere gli spazi nei periodi 1, 2 e 3 e colmare gli spazi nei periodi 6 e 7. È più facile farlo alla fine, in modo che i valori degli altri spazi non siano interessati (e mantenere i loro valori).

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

Spiegazione:

(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

Provalo online!


L'uso di una maschera come questa 1000000000000000000000000000000001 1100000000000000000000000000111111 1100000000000000000000000000111111 1112222222222222221111111111111111 1113333333333333331111111111111111può ridurre il conto, altrimenti è bello!
Magic Octopus Urn

7

Mathematica, 77 byte

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

Sarebbe anche abbastanza facile da usare ElementDataper determinare se l'input è un lantanide o un attinide, ma occorrerebbero circa 20 byte in più.


3
Scherzi a parte, builtin di nuovo?
Matthew Roh,

1
@MatthewRoh Sono sicuro che una soluzione aritmetica ben giocata in una lingua da golf lo batterà facilmente.
Martin Ender,

@MartinEnder Bene, in realtà sono sicuro dell'esatto contrario.
Erik the Outgolfer

@EriktheOutgolfer Beh, ci si va . Sono sicuro che Jelly potrebbe tagliare un altro 30-50%.
Martin Ender,

@MartinEnder Molto probabilmente lo lascerò a Dennis, non posso fare una cosa simile durante il periodo degli esami.
Erik the Outgolfer


3

PHP, 144 byte

Nota: utilizza la codifica 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);

Esegui in questo modo:

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

Spiegazione

Verificare se l'input rientra negli intervalli per Lo A; l'intervallo "eccezione". Quindi modificare l'input per riempire le celle mancanti nella griglia (o eliminare le celle extra). Infine, stampa l'eccezione (a meno che non sia falsa 0) o converti la posizione in coordinate della griglia.


Seguendo il tuo esempio, l'output che ricevo è 18<t7. È qualcosa che sto sbagliando? (in esecuzione su Mac El Capitan)
James Webster,

1
@JamesWebster è a causa della codifica che ho usato per la virgola. Se non riesci a cambiare la codifica del tuo terminale, puoi sostituire la cosa tra i 2 punti (poco prima ceil) con "," per 1 byte extra
circa il

3

Gelatina , 57 byte

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

Programma completo che stampa l'output desiderato.

Provalo online! (Un programma leggermente modificato che stampa tuttoinput : outputpuò essere visto qui ).

Come?

Crea un elenco dei 118 possibili output e quindi seleziona la voce nell'indice dell'input.

Alcuni prep:

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

Il programma (abbreviato sostituendo A, Be 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 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)

Consiglierei di accorciare la parte '\ 201 \ 202 \ 203 \ ... \ 362' della stringa. Scherzi a parte, è lungo come diamine.
Matthew Roh,

1
Curioso come @MatthewRoh abbia misurato diamine.
hBy2Py

2

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

Per prima cosa prendi la 'A' e la 'L' con il trucco della maschera di bit, quindi prova a inserirti in un rettangolo 18 * 7 e usa un div / mod.


2

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]

Provalo online!


2

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]

Provalo online!

L'idea è di div-mod la posizione della griglia per ottenere il gruppo e il periodo. La posizione della griglia è l'ingresso nregolato da uno spostamento per tenere conto degli spazi vuoti e della contrazione L / A. Questi sono estratti da un elenco.

Il trattamento con Lantanide e Actinide è brutto. A questi sono assegnati grandi spostamenti 200 e 400 che possono essere rilevati con /200. Vorrei mettere i personaggi Le Aqui, ma poi n+=...aggiungerò un carattere a un numero, dando un errore anche se nnon viene utilizzato. Se non fosse per l'indicizzazione 1, divmodpotrebbe essere utilizzato per fare riferimento nuna sola volta, quindi potrebbe essere sostituito con la sua espressione,


2

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>

Spiegazione: Le serie 'L' e 'A' hanno un case speciale, usando una logica bit a bit che mi ha salvato 3 byte rispetto ai confronti diretti. Altrimenti la funzione trova ricorsivamente il periodo pcontenente il numero atomico desiderato, il numero dell'ultimo elemento nel periodo precedente xe il numero dell'ultimo elemento nel periodo yche viene calcolato ogni volta osservando che le differenze sono 2, 2, 8 , 8, 18, 18 cioè ripetuti numeri quadrati raddoppiati. Il gruppo viene quindi trovato sfalsando da sinistra o destra della tabella a seconda che l'elemento si trovi sotto la diagonale berillio-scandio o meno.


1

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)

Test


1

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]

Provalo online!

Troppe parentesi. Sembra più Brain-Flak.


non puoi metterlo whileal di fuori della funzione? risparmierebbe un byte (spazio)
Felipe Nardi Batista

@FelipeNardiBatista - Gestito per sbarazzarsi del whileloop del tutto :)
ElPedro

1

Excel, 192 byte

Lungi dall'essere carina. Prende in prestito dalle risposte esistenti di 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)

Lottando per gestire il caso in cui MOD(x,18)=0per valore di gruppo con grazia.


Penso di aver trovato un errore. L'IF per la determinazione di lantanidi e attinidi dovrebbe leggere IF(A1<80?
James Webster,

@JamesWebster, ben notato. Ho corretto.
Wernisch,

0

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

Commentato nel programma di test

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

accetta input da STDIN, esegui con -nR.

un po 'di magia bit a bit per i Lantanidi e gli Attinidi,
la $n-=parte aggiunge e sottrae gli offset per i vuoti e i Lantanidi / Attinidi,
il resto è semplice mod / div.

Una porta iterativa della risposta di Neil richiede 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";

0

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"

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

Gelatina , 49 43 42 41 39 byte

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

Provalo online!

sfondo

Ad eccezione dei lantanidi e degli attinidi, l'output sarà costituito da un numero intero espresso in base biiettiva 18. Ad esempio, l'idrogeno corrisponde a 19 10 = 11 b18 , l'elio a 36 10 = 1I b18 e eka-radon / ununoctium / oganesson a 114 10 = 7I b18 .

Iniziamo mappando tutti i numeri atomici che possiamo sugli interi corrispondenti, mentre mappiamo i lantanidi e gli attinidi con quelli che corrispondono al lantanio ( 111 10 = 63 b18 ) e all'attinio ( 129 10 = 73 b18 ).

Per fare ciò, registriamo le differenze in avanti degli interi che rappresentano gli atomi. Ad esempio, il primo è 1I b18 - 11 b18 = H b18 = 17 10 , il secondo è 1 (come lo sono tutte le differenze tra elementi consecutivi della tavola periodica non espansa), il quarto (da B a Be ) è 2D b18 - 22 b18 = B b18 = 11 10 e così via. Per mappare tutti i lantanidi e tutti gli attinidi, considereremo tutte le differenze tra due lantanidi o gli attinidi (ad es. Da La a Ce ) come 0 .

Per ottenere il numero intero desiderato per un numero atomico n , tutto ciò che dobbiamo fare è anteporre 19 (idrogeno) alle differenze e calcolare la somma dei primi n elementi del vettore risultante. L'output viene quindi semplicemente visualizzato nella base biiettiva 18, a meno che non visualizzi 6 3 (lantanidi) o 7 3 (attinidi). In quest'ultimo caso, è sufficiente sostituire il risultato calcolato con L o A .

Avvolto per sanità mentale orizzontale, il vettore che dobbiamo codificare appare come segue.

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

Dopo la codifica run-length, otteniamo quanto segue.

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

Per ridurre ancora di più lo spazio richiesto per codificare il vettore, eliminiamo gli 1 (lunghezze) più a destra e aggiungiamo 1 alle corse.

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

Ora possiamo convertire in modo reversibile questi array di cifre dalla base 45 agli interi.

20      18      92     12      97     12      134     59      108     59      105

Tutti questi sono inferiori a 250 , quindi possiamo rappresentarli con i caratteri della tabella codici di Jelly . Circondato da (inizio letterale) e (interpretare come array intero), otteniamo il Jelly letterale

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

che appare testualmente nel codice.

Come funziona

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

Sebbene questa sia una risposta interessante, temo che cada sull'output. Invece di emettere il gruppo e il periodo per l'input, sembra emettere il numero atomico, il gruppo e il periodo per la tabella completa. Considera se ti avevo chiesto una definizione del dizionario di una parola e hai appena emesso un dizionario.
James Webster,

Il piè di pagina fornisce una suite di test per una facile verifica. Se lo rimuovi e fornisci l'input come argomento, stamperà solo le informazioni richieste dalla specifica. tio.run/nexus/jelly#@29i@qhhzuF5h2fEPGpakwjEjxq3WedYZz5qmJFUoQ/…
Dennis
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.