Chemia 101 - Wprowadzenie do układu okresowego pierwiastków

24

Pytanie

Given the atomic number of an elementw zakresie [1-118] wyprowadza group and period, tego elementu, jak podano w poniższym układzie okresowym pierwiastków.

Dla elementów w szeregu lantanowców i aktynowców (zakresy [57-71] i [89-103]), należy zamiast wrócić Ldo lantanowców i Adla aktynowców

Możesz napisać program lub funkcję i użyć dowolnej z naszych standardowych metod otrzymywania danych wejściowych i zapewniania danych wyjściowych.

Możesz używać dowolnego języka programowania , ale pamiętaj, że te luki są domyślnie zabronione.

wprowadź opis zdjęcia tutaj

[Źródło]

Przypadki testowe

Ponieważ istnieje tylko 118 możliwych danych wejściowych, poniżej podano pełną listę oczekiwanych danych wejściowych i wyjściowych.

Stworzone ręcznie, daj mi znać, jeśli wystąpi błąd!

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

Punktacja

Prosty . Najkrótsza liczba bajtów wygrywa

James Webster
źródło
5
Wiem tylko, że Mathematica będzie mieć wbudowaną funkcję tego ...
Okx
@Okx, mam nadzieję, że Lanthanides i Actinides zepsują wszelkie wbudowane :)
James Webster
2
Czy możesz zwrócić „6, L” i „7, A” dla Lantanowców i Aktynowców?
Neil,
1
nie mogę komentować (jeszcze), ale czasami wodór jest umieszczany w grupie 17 - ale potwierdzam, że użyłeś obrazu, aby uzasadnić, dlaczego grupa 1 i nie wiem, czy to utrudnia, czy ułatwia?
sjb-2812
1
Ljest w porządku. Właśnie tak zamierzałem. Ale ponieważ CSV wyszedł L,, zaakceptuję oba
James Webster,

Odpowiedzi:

10

CJam , 64 59 58 56 54 bajtów

Dzięki Dennis za oszczędność 2 bajtów.

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

Wypróbuj online!

Pozostawia kropkę i grupę lub pojedynczy znak na stosie.

Wyjaśnienie

Istnieją tutaj dwa główne pomysły:

  • Najpierw mamy do czynienia z Lantanowcami i Aktynowcami. Mamy warunek 56 <x <72 dla lantanowców i 88 <x <104 dla aktynowców. Oba z nich można wyrazić jako pojedyncze porównanie, biorąc absolutną różnicę do środka zakresu: nierówności stają się | x - 64 | <8 i | x - 96 | Odpowiednio <8 . Ale są one nadal bardzo podobne, a wykonanie tych dwóch porównań osobno jest drogie. Dlatego stosujemy ten sam pomysł sprawdzania zakresu symetrycznego, biorąc kolejną absolutną różnicę ze środkiem między dwoma zakresami, 80 , po pierwsze: || x-80 | - 16 | <8. Ten warunek wskazuje, że atom jest albo lantanowcem, albo aktynowcem, ale rozróżnienie między tymi dwoma przypadkami jest wtedy tak proste, jak porównanie z 80 (lub inną wartością między zakresami).
  • Ponieważ dane wyjściowe są tak naprawdę indeksem w tabeli o szerokości 18, oczywistym podejściem jest próba przekształcenia wartości podstawowej w podstawę 18, aby dwie cyfry podały grupę i kropkę. Aby to zrobić, musimy jednak zmienić niektóre wartości. Wszystko, co naprawdę musimy zrobić, to dodać luki w okresach 1, 2 i 3 i zamknąć luki w okresach 6 i 7. Najłatwiej to zrobić od końca, aby nie wpływać na wartości innych luk (i zachowaj swoje wartości).

_            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
źródło
9

05AB1E , 113 102 99 bajtów

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

Wyjaśnienie:

(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

Wypróbuj online!

Okx
źródło
Używanie maski takiej jak 1000000000000000000000000000000001 1100000000000000000000000000111111 1100000000000000000000000000111111 1112222222222222221111111111111111 1113333333333333331111111111111111może zmniejszyć liczbę bajtów, poza tym fajnie!
Magic Octopus Urn
7

Mathematica, 77 bajtów

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

Byłoby również dość łatwe w użyciu, ElementDataaby ustalić, czy wsad jest lantanowcem czy aktynowcem, ale zajmie to około 20 dodatkowych bajtów.

Martin Ender
źródło
3
Poważnie, wbudowane ponownie?
Matthew Roh,
1
@MatthewRoh Jestem pewien, że dobrze zagrane w golfa rozwiązanie arytmetyczne w języku golfowym z łatwością to pokona.
Martin Ender
@MartinEnder Cóż, jestem pewien, że jest dokładnie odwrotnie.
Erik the Outgolfer
@EriktheOutgolfer Cóż, proszę bardzo . Jestem pewien, że Jelly może odciąć kolejne 30-50%.
Martin Ender
@MartinEnder Najprawdopodobniej pozostawię to Dennisowi, nie mogę zrobić czegoś takiego w okresie egzaminacyjnym.
Erik the Outgolfer
6

Python 2 , 205 136 bajtów

-26 bajtów dzięki @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]

Wypróbuj online!

Felipe Nardi Batista
źródło
3

PHP, 144 bajty

Uwaga: używa kodowania 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);

Uruchom tak:

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

Wyjaśnienie

Sprawdź, czy dane wejściowe mieszczą się w zakresie dla Llub A; zakresy „wyjątków”. Następnie zmodyfikuj dane wejściowe, aby wypełnić brakujące komórki w siatce (lub pozbyć się dodatkowych komórek). Na koniec wydrukuj wyjątek (chyba że jest to fałsz 0) lub przekonwertuj pozycję na współrzędne siatki.

aross
źródło
W twoim przykładzie otrzymałem wynik 18<t7. Czy to coś, co robię źle? (działa na Mac El Capitan)
James Webster
1
@JamesWebster ze względu na kodowanie użyte w przecinku. Jeśli nie możesz zmienić kodowania terminala, możesz zastąpić rzecz między 2 kropkami (tuż przed ceil) przez „,” dla 1 dodatkowego bajtu
aross
3

Galaretka , 57 bajtów

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

Pełny program, który drukuje żądane wyjście.

Wypróbuj online! (Nieco zmodyfikowany program, który drukuje wszystkoinput : outputmożna zobaczyć tutaj ).

W jaki sposób?

Tworzy listę 118 możliwych wyników, a następnie wybiera wpis na podstawie indeksu wejścia.

Niektóre 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)

Program (skrócony przez podstawienie A, Bi 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
źródło
2

Perl5, 202 bajtów

$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
źródło
Poleciłbym skrócenie części „\ 201 \ 202 \ 203 \ ... \ 362” ciągu. Poważnie, to długo, jak do cholery.
Matthew Roh,
1
Ciekawe, jak @MatthewRoh mierzył cholera.
hBy2Py
2

Rubinowy, 130 bajtów

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

Najpierw zdobądź „A” i „L” za pomocą sztuczki z maską bitową, a następnie spróbuj dopasować się do prostokąta 18 * 7 i użyj div / mod.

GB
źródło
2

Python 2 , 137 bajtów

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]

Wypróbuj online!

ovs
źródło
2

Python 2 , 115 bajtów

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]

Wypróbuj online!

Chodzi o div-mod pozycji siatki, aby uzyskać grupę i kropkę. Pozycja siatki jest wejściemn korygowane przez przesunięcie uwzględniające luki i skurcz L / A. Są one wyodrębniane z listy.

Obsługa lantanowców i aktynowców jest brzydka. Są one przypisywane dużym przemieszczeniom 200 i 400, które można wykryć za pomocą /200. Chciałbym wstawić znaki Li Atutaj, ale następnie n+=...doda znak do liczby, dając błąd, nawet jeśli nnie zostanie użyty. Gdyby nie indeksowanie 1, divmodmożna by go użyć ntylko raz, a następnie zastąpić jego wyrażeniem,

xnor
źródło
2

JavaScript (ES7), 100 98 bajtów

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>

Objaśnienie: Serie „L” i „A” są specjalnie zaprojektowane, przy użyciu logiki bitowej, która pozwoliła mi zaoszczędzić 3 bajty w porównaniu z bezpośrednimi porównaniami. W przeciwnym razie funkcja rekurencyjnie znajdzie okres pzawierający pożądaną liczbę atomową, liczbę ostatniego elementu w poprzednim okresie xoraz liczbę ostatniego elementu w okresie, yktóry jest obliczany za każdym razem, zwracając uwagę, że różnice wynoszą 2, 2, 8 , 8, 18, 18 tzn. Powtarzane podwójne liczby kwadratowe. Grupę można następnie znaleźć poprzez przesunięcie z lewej lub prawej strony stołu w zależności od tego, czy element leży pod przekątną Beryl-Scandium, czy nie.

Neil
źródło
1

JavaScript (ES6), 136 bajtów

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

Arnauld
źródło
1

Python 2 , 264 227 217 bajtów

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]

Wypróbuj online!

O wiele za dużo nawiasów. Wygląda bardziej jak Brain-Flak.

ElPedro
źródło
nie możesz umieścić tego whilepoza funkcją? zaoszczędziłby bajt (spację)
Felipe Nardi Batista
@FelipeNardiBatista - Udało się whilecałkowicie pozbyć się pętli :)
ElPedro
1

Excel, 192 bajty

Daleko od ładnego. Pożyczki z istniejących odpowiedzi w języku 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)

Walczy, aby poradzić sobie z przypadkiem, w którym MOD(x,18)=0dla Grupy wartość wdzięku.

Wernisch
źródło
Myślę, że znalazłem błąd. Czy IF powinien oznaczać lantanowce i aktynowce IF(A1<80?
James Webster,
@JamesWebster, dobrze zauważony. Poprawione.
Wernisch
0

Rubin, 116 bajtów

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

Skomentowane w programie testowym

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
źródło
0

PHP, 120 bajtów

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

pobiera dane wejściowe ze STDIN, uruchom z -nR .

niektóre bitowe magia dla lantanowców i aktynowców, część dodaje i odejmuje offsety dla luk i lantanowców / aktynowców,
$n-=
reszta jest prosta mod / div.

Iteracyjny port odpowiedzi Neila zajmuje 108 bajtów :

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";
Tytus
źródło
0

Perl, 169 bajtów

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"

Za pomocą:

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
źródło
0

Galaretka , 49 43 42 41 39 bajtów

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

Wypróbuj online!

tło

Z wyjątkiem lantanowców i aktynowców, wynik będzie składał się z liczby całkowitej wyrażonej w zasadzie bijective 18. Na przykład wodór odpowiada 19 10 = 11 b18 , hel - 36 10 = 1 I b18 i eka-radon / ununoctium / oganesson to 114 10 = 7 I b18 .

Zaczynamy od mapowania wszystkich liczb atomowych, jakie możemy, do odpowiednich liczb całkowitych, a mapowania lantanowców i aktynowców na te, które odpowiadają lantanowi ( 111 10 = 63 b18 ) i aktynowi ( 129 10 = 73 b18 ).

Aby to zrobić, rejestrujemy różnice w przód liczb całkowitych reprezentujących atomy. Na przykład pierwszy to 1I b18 - 11 b18 = Hb18 = 17 10 , drugi to 1 (podobnie jak wszystkie różnice między kolejnymi elementami nierozwiniętego układu okresowego), czwarty (od B do Be ) to 2D b18 - 22 b18 = B b18 = 11 10 i tak dalej. Aby zmapować wszystkie lantanowce i wszystkie aktynowce, rozważymy wszystkie różnice między dwoma lantanowcami lub aktynowcami (np. La do Ce ) za 0 .

Aby uzyskać pożądaną liczbę całkowitą dla liczby atomowej n , wystarczy, że dodamy 19 (wodór) do różnic i obliczymy sumę pierwszych n elementów uzyskanego wektora. Dane wyjściowe są następnie wyświetlane po prostu w bazie bijective 18, chyba że wyświetlałoby to 6 3 (lantanowce) lub 7 3 (aktynowce). W tym drugim przypadku po prostu zamieniamy obliczony wynik na L lub A. .

Wektor, który musimy zakodować dla poziomego zdrowia psychicznego, wygląda następująco.

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

Po kodowaniu długości przebiegu otrzymujemy następujące informacje.

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

Aby jeszcze bardziej zmniejszyć przestrzeń wymaganą do zakodowania wektora, usuwamy skrajne wartości 1 (długości) i dodajemy 1 do przebiegów.

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

Teraz możemy odwracalnie przekształcić te tablice cyfr z bazy 45 na liczby całkowite.

20      18      92     12      97     12      134     59      108     59      105

Wszystkie są mniejsze niż 250 , więc możemy je reprezentować znakami ze strony kodowej Jelly . Otoczony (literał start) i (interpretowany jako tablica liczb całkowitych), otrzymujemy literał Jelly

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

który pojawia się dosłownie w kodzie.

Jak to działa

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
źródło
Chociaż jest to interesująca odpowiedź, obawiam się, że myślę, że spada na wynik. Zamiast wypisywać grupę i okres na dane wejściowe, wydaje się, że wypisuje liczbę atomową, grupę i okres dla pełnej tabeli. Zastanów się, czy poprosiłem cię o definicję słownika w słowie, a ty właśnie wypisałeś słownik.
James Webster,
Stopka zawiera zestaw testów do łatwej weryfikacji. Jeśli go usuniesz i podasz dane jako argument, po prostu wydrukuje informacje, o które prosi specyfikacja. tio.run/nexus/jelly#@29i@qhhzuF5h2fEPGpakwjEjxq3WedYZz5qmJFUoQ/…
Dennis