Chimie 101 - Introduction au tableau périodique

24

Question

Given the atomic number of an elementdans la plage [1-118] sortent le group and period, de cet élément comme indiqué par le tableau périodique des éléments suivant.

Pour les éléments des séries Lanthanide et Actinide (gammes [57-71] et [89-103]), vous devriez plutôt retourner Lpour les Lanthanides et Apour les Actinides

Vous pouvez écrire un programme ou une fonction et utiliser l'une de nos méthodes standard de réception d'entrée et de sortie.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

entrez la description de l'image ici

[La source]

Cas de test

Puisqu'il n'y a que 118 entrées possibles, une liste complète des entrées et sorties attendues est donnée ci-dessous.

Créé à la main, faites-moi savoir s'il y a une erreur!

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

Notation

simple . Plus petit nombre d'octets gagne

James Webster
la source
5
Je sais juste que Mathematica aura une fonction intégrée pour cela ...
Okx
@Okx, j'espère que les Lanthanides et les Actinides gâcheront tous les intégrés :)
James Webster
2
Êtes-vous autorisé à retourner "6, L" et "7, A" pour les lanthanides et les actinides?
Neil
1
Je ne peux pas (encore) commenter mais parfois l'hydrogène est placé dans le groupe 17 - mais je reconnais que vous avez utilisé une image pour justifier pourquoi le groupe 1 et vous ne savez pas si cela rend les choses plus difficiles ou plus faciles?
sjb-2812
1
Lc'est bien. C'est en fait ce que je voulais. Mais depuis la sortie du CSV, L,j'accepterai les deux
James Webster

Réponses:

10

CJam , 64 59 58 56 54 octets

Merci à Dennis d'avoir économisé 2 octets.

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

Essayez-le en ligne!

Laisse soit période et groupe ou un seul caractère sur la pile.

Explication

Il y a deux idées principales ici:

  • Premièrement, nous traitons des Lanthanides et des Actinides. Nous avons la condition 56 <x <72 pour les lanthanides et 88 <x <104 pour les actinides. Les deux peuvent être exprimés comme une comparaison unique en prenant une différence absolue au centre de la plage: les inégalités deviennent | x - 64 | <8 et | x - 96 | <8 , respectivement. Mais ceux-ci sont toujours très similaires, et faire les deux comparaisons séparément coûte cher. Nous appliquons donc la même idée de vérifier une plage symétrique, en prenant une autre différence absolue avec le centre entre les deux plages, 80 , d'abord: || x-80 | - 16 | <8. Cette condition indique que l'atome est soit un lanthanide soit un actinide, mais la distinction entre ces deux cas est alors aussi triviale que la comparaison avec 80 (ou une autre valeur entre les gammes).
  • Puisque la sortie est vraiment un index dans une table de largeur 18, une approche évidente consiste à essayer de convertir la valeur en base 18, de sorte que les deux chiffres donnent le groupe et la période. Pour ce faire, nous devons cependant déplacer certaines valeurs. Tout ce que nous devons vraiment faire est d'ajouter les écarts dans les périodes 1, 2 et 3 et de combler les écarts dans les périodes 6 et 7. Il est plus facile de le faire depuis la fin, afin que les valeurs des autres écarts ne soient pas affectées (et garder leurs valeurs).

_            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.
}?
Martin Ender
la source
9

05AB1E , 113 102 99 octets

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

Explication:

(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

Essayez-le en ligne!

Okx
la source
L'utilisation d'un masque comme 1000000000000000000000000000000001 1100000000000000000000000000111111 1100000000000000000000000000111111 1112222222222222221111111111111111 1113333333333333331111111111111111peut réduire les bytecount, sinon c'est bien!
Magic Octopus Urn
7

Mathematica, 77 octets

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

Il serait également assez facile à utiliser ElementDatapour déterminer si l'entrée est un lanthanide ou un actinide, mais cela prendrait environ 20 octets supplémentaires.

Martin Ender
la source
3
Sérieusement, intégré à nouveau?
Matthew Roh
1
@MatthewRoh Je suis sûr qu'une solution arithmétique bien golfée dans une langue de golf battra facilement cela.
Martin Ender
@MartinEnder Eh bien, je suis sûr de l'exact opposé.
Erik the Outgolfer
@EriktheOutgolfer Eh bien, là vous allez . Je suis sûr que Jelly pourrait couper 30 à 50% supplémentaires.
Martin Ender
@MartinEnder Je laisserai très probablement ça à Dennis, je ne peux pas faire une telle chose en période d'examen.
Erik the Outgolfer
6

Python 2 , 205 136 octets

-26 octets grâce à @Dead Possum

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]

Essayez-le en ligne!

Felipe Nardi Batista
la source
3

PHP, 144 octets

Remarque: utilise le codage 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);

Courez comme ceci:

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

Explication

Vérifiez si l'entrée se situe dans les plages de Lou A; les plages "d'exception". Modifiez ensuite l'entrée pour remplir les cellules manquantes dans la grille (ou supprimez les cellules supplémentaires). Enfin, imprimez l'exception (sauf si c'est faux 0) ou convertissez la position en coordonnées de grille.

aross
la source
En exécutant votre exemple, la sortie que je reçois est 18<t7. Est-ce quelque chose que je fais mal? (fonctionnant sur Mac El Capitan)
James Webster
1
@JamesWebster c'est à cause de l'encodage que j'ai utilisé pour la virgule. Si vous ne pouvez pas changer l'encodage de votre terminal, vous pouvez remplacer la chose entre les 2 points (juste avant ceil) par "," pour 1 octet supplémentaire
autour du
3

Gelée , 57 octets

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

Programme complet qui imprime la sortie souhaitée.

Essayez-le en ligne! (Un programme légèrement modifié qui imprime toutinput : outputpeut être vu ici ).

Comment?

Construit une liste des 118 sorties possibles, puis sélectionne l'entrée à l'index de l'entrée.

Quelques préparations:

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

Le programme (abrégée par la substitution A, Bet 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
Jonathan Allan
la source
2

Perl5, 202 octets

$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)
Michael Vehrs
la source
Je recommanderais de raccourcir la partie '\ 201 \ 202 \ 203 \ ... \ 362' de la chaîne. Sérieusement, c'est aussi diable.
Matthew Roh
1
Curieux de savoir comment @MatthewRoh a mesuré diable.
hBy2Py
2

Rubis, 130 octets

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

Obtenez d'abord le 'A' et le 'L' avec le truc du masque de bits, puis essayez de vous adapter à un rectangle 18 * 7 et utilisez un div / mod.

GB
la source
2

Python 2 , 137 octets

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]

Essayez-le en ligne!

ovs
la source
2

Python 2 , 115 octets

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]

Essayez-le en ligne!

L'idée est de diviser la position de la grille pour obtenir le groupe et la période. La position de la grille est l'entrée najustée par un déplacement pour tenir compte des écarts et de la contraction L / A. Ceux-ci sont extraits d'une liste.

La manipulation des lanthanides et des actinides est moche. Ceux-ci sont affectés de grands déplacements 200 et 400 qui peuvent être détectés avec /200. Je voudrais mettre les caractères Let Aici, mais ensuite n+=...j'ajouterai un caractère à un nombre, donnant une erreur même s'il nn'est pas utilisé. Sinon pour l'indexation 1, divmodpourrait être utilisé pour faire référence à nune seule fois, puis il pourrait être remplacé par son expression,

xnor
la source
2

JavaScript (ES7), 100 98 octets

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>

Explication: Les séries «L» et «A» sont à boîtier spécial, utilisant une logique au niveau du bit qui m'a fait économiser 3 octets par rapport aux comparaisons directes. Sinon, la fonction trouve récursivement la période pcontenant le numéro atomique souhaité, le numéro du dernier élément de la période précédente xet le numéro du dernier élément de la période yqui est calculé à chaque fois en notant que les différences sont 2, 2, 8 , 8, 18, 18 c.-à-d. Nombres répétés de carrés doubles. Le groupe est ensuite trouvé en décalant à gauche ou à droite du tableau selon que l'élément se trouve sous la diagonale Béryllium-Scandium ou non.

Neil
la source
1

JavaScript (ES6), 136 octets

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)

Tester

Arnauld
la source
1

Python 2 , 264 227 217 octets

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]

Essayez-le en ligne!

Beaucoup trop de crochets. Cela ressemble plus à Brain-Flak.

ElPedro
la source
ne pouvez-vous pas placer cela en whiledehors de la fonction? cela économiserait un octet (espace)
Felipe Nardi Batista
@FelipeNardiBatista - A réussi à se débarrasser whilecomplètement de la boucle :)
ElPedro
1

Excel, 192 octets

Loin d'être jolie. Emprunts des réponses Python existantes

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

Luttant pour gérer le cas où la MOD(x,18)=0valeur de groupe gracieusement.

Wernisch
la source
Je pense avoir trouvé une erreur. Le FI pour déterminer les lanthanides et les actinides doit-il être lu IF(A1<80?
James Webster
@JamesWebster, bien repéré. Ont corrigé.
Wernisch
0

Rubis, 116 octets

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

Commenté dans le programme de 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],$/}
Level River St
la source
0

PHP, 120 octets

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

prend l'entrée de STDIN, exécutez avec -nR.

un peu de magie au niveau du bit pour les Lanthanides et Actinides,
la $n-=partie ajoute et soustrait des décalages pour les lacunes et Lanthanides / Actinides,
le reste est simple mod / div.

Un port itératif de la réponse de Neil prend 108 octets :

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";
Titus
la source
0

Perl, 169 octets

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"

En utilisant:

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
Denis Ibaev
la source
0

Gelée , 49 43 42 41 39 octets

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

Essayez-le en ligne!

Contexte

À l'exception des lanthanides et des actinides, la sortie consistera en un entier exprimé en base bijective 18. Par exemple, l'hydrogène correspond à 19 10 = 11 b18 , l'hélium à 36 10 = 1I b18 et eka-radon / ununoctium / oganesson à 114 10 = 7I b18 .

Nous commençons par cartographier tous les numéros atomiques que nous pouvons sur les entiers correspondants, tout en cartographiant les lanthanides et les actinides sur ceux qui correspondent au lanthane ( 111 10 = 63 b18 ) et à l'actinium ( 129 10 = 73 b18 ).

Pour ce faire, nous enregistrons les différences directes des entiers qui représentent les atomes. Par exemple, le premier est 1I b18 - 11 b18 = H b18 = 17 10 , le second est 1 (comme le sont toutes les différences entre les éléments consécutifs du tableau périodique non développé), le quatrième ( B to Be ) est 2D b18 - 22 b18 = B b18 = 11 10 , etc. Pour cartographier tous les lanthanides et tous les actinides, nous considérerons que toutes les différences entre deux lanthanides ou les actinides (par exemple, La à Ce ) sont égales à 0 .

Pour obtenir l'entier souhaité pour un numéro atomique n , il suffit d'ajouter 19 (hydrogène) aux différences et de calculer la somme des n premiers éléments du vecteur résultant. Le résultat est alors simplement affiché dans la base bijective 18, à moins que cela ne montre 6 3 (lanthanides) ou 7 3 (actinides). Dans ce dernier cas, on remplace simplement le résultat calculé avec L ou A .

Enveloppé pour la raison horizontale, le vecteur que nous devons coder ressemble à ceci.

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

Après l'encodage de la longueur d'exécution, nous obtenons ce qui suit.

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

Pour réduire encore plus l'espace requis pour coder le vecteur, nous supprimons les 1 (longueurs) les plus à droite et ajoutons 1 aux pistes.

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

Maintenant, nous pouvons convertir de manière réversible ces tableaux de chiffres de la base 45 en entiers.

20      18      92     12      97     12      134     59      108     59      105

Tous ces éléments sont plus petits que 250 , nous pouvons donc les représenter avec des caractères de la page de codes de Jelly . Entouré de (début littéral) et (interpréter comme un tableau entier), nous obtenons le littéral Jelly

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

qui apparaît textuellement dans le code.

Comment ça marche

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].
Dennis
la source
Bien que ce soit une réponse intéressante, je crains que je pense qu'elle tombe sur la sortie. Au lieu de sortir le groupe et la période pour l'entrée, il semble sortir le numéro atomique, le groupe et la période pour la table complète. Considérez si je vous avais demandé une définition de dictionnaire d'un mot et que vous veniez de sortir un dictionnaire.
James Webster
Le pied de page fournit une suite de tests pour une vérification facile. Si vous le supprimez et fournissez l'entrée comme argument, il imprimera simplement les informations demandées. tio.run/nexus/jelly#@29i@qhhzuF5h2fEPGpakwjEjxq3WedYZz5qmJFUoQ/…
Dennis