सवाल

Given the atomic number of an element[१-११] रेंज में group and period, उस तत्व का उत्पादन , जैसा कि निम्नलिखित आवर्त सारणी के तत्वों द्वारा दिया गया है।

Lanthanide और Actinide श्रृंखला के तत्वों के लिए, (श्रेणियाँ [57-71] और [89-103]), आपको इसके बजाय LLanthanides और AActinides के लिए वापस लौटना चाहिए

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

^{[स्रोत]}

परीक्षण के मामलों

चूंकि केवल 118 संभव इनपुट हैं, इसलिए अपेक्षित इनपुट और आउटपुट की पूरी सूची नीचे दी गई है।

हाथ से बनाया गया है, मुझे पता है अगर वहाँ एक गलती है!

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, एल,
58, एल,
59, एल,
60, एल,
61, एल,
62, एल,
63, एल,
64, एल,
65, एल,
66, एल,
67, एल,
68, एल,
69, एल,
70, एल,
71, एल,
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, ए,
90, ए,
91, ए,
92, ए,
93, ए,
94, ए,
95, ए,
96, ए,
97, ए,
98, ए,
99, ए,
100, ए,
101, ए,
102, ए,
103, ए,
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

स्कोरिंग

सरल कोड-गोल्फ । सबसे कम संख्या में बाइट्स जीतती हैं

code-golf kolmogorov-complexity chemistry

— जेम्स वेबस्टर
स्रोत

5

मुझे सिर्फ इतना पता है कि मैथेमेटिका में इसके लिए बिल्ट-इन होगा ...

— ओकेक्स

@ ओएक्स, मैं उम्मीद कर रहा हूं कि लैंथेनाइड्स और एक्टिनाइड्स किसी भी अंतर्निहित आईएनएस को गड़बड़ करते हैं :)

— जेम्स वेबस्टर

2

क्या आपको "6, एल" और "7, ए" को लैंथेनाइड्स और एक्टिनाइड्स के लिए वापस जाने की अनुमति है?

— नील

1

टिप्पणी नहीं कर सकता (अभी तक) लेकिन कभी-कभी हाइड्रोजन को समूह 17 में रखा जाता है - लेकिन मैं स्वीकार करता हूं कि आपने एक छवि का उपयोग समूह 1 को सही ठहराने के लिए किया है और यह नहीं जानते कि क्या इससे चीजें कठिन या आसान हो जाती हैं?

— sjb-2812

1

Lठीक है। यही वास्तव में मेरा इरादा था। लेकिन CSV के आउटपुट के बाद से L,मैं दोनों को स्वीकार करूँगा

— जेम्स वेबस्टर

10

CJam , 64 59 58 56 54 बाइट्स

2 बाइट बचाने के लिए डेनिस के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

स्टैक पर या तो अवधि और समूह या एकल वर्ण छोड़ता है।

व्याख्या

यहाँ दो मुख्य विचार हैं:

सबसे पहले, हम लैंथेनाइड्स और एक्टिनाइड्स से निपटते हैं। हमारे पास लैंथेनाइड्स के लिए 56 <x <72 है और एक्टिनाइड्स के लिए 88 <x <104 है। इन दोनों को सीमा के केंद्र में पूर्ण अंतर लाकर एकल तुलना के रूप में व्यक्त किया जा सकता है: असमानताएं बन जाती हैं । x - 64 <8 और | x - 96 | <8 , क्रमशः। लेकिन ये अभी भी बहुत समान हैं, और दोनों तुलनाओं को अलग-अलग करना महंगा है। तो हम एक सममित रेंज जाँच, केंद्र के साथ एक और निरपेक्ष अंतर लेकर के एक ही उपाय पर अमल के बीच दो पर्वतमाला, 80 , पहले: || एक्स-80 | - 16 | <8। यह स्थिति बताती है कि परमाणु या तो लैंथेनाइड या एक्टिनाइड है, लेकिन इन दो मामलों के बीच अंतर करना तब उतना ही तुच्छ है जितना कि 80 (या श्रेणियों के बीच कुछ अन्य मूल्य) की तुलना करना।
चूंकि आउटपुट वास्तव में चौड़ाई 18 की तालिका में एक सूचकांक है, इसलिए एक स्पष्ट दृष्टिकोण आधार-मान को आधार 18 में बदलने की कोशिश करना है, ताकि दो अंक समूह और अवधि दें। ऐसा करने के लिए, हमें कुछ मानों को आसपास स्थानांतरित करने की आवश्यकता है। हम सभी को वास्तव में करने की आवश्यकता है 1, 2 और 3 में अंतराल को जोड़ने के लिए और 6 और 7 की अवधि में अंतराल को बंद करें। अंत से ऐसा करना सबसे आसान है, ताकि अन्य अंतराल के मूल्यों को प्रभावित न करें (और उनके मान रखें)।

_            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 बाइट्स

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

स्पष्टीकरण:

(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

इसे ऑनलाइन आज़माएं!

— Okx
स्रोत

जैसे मास्क का उपयोग करके

1000000000000000000000000000000001 1100000000000000000000000000111111 1100000000000000000000000000111111 1112222222222222221111111111111111 1113333333333333331111111111111111

बायटेकाउंट को कम किया जा सकता है, अन्यथा अच्छा!

— मैजिक ऑक्टोपस Urn

7

गणितज्ञ, 77 बाइट्स

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

यह ElementDataनिर्धारित करना भी काफी आसान होगा कि इनपुट लैंथेनाइड है या एक्टिनाइड, लेकिन यह लगभग 20 और बाइट्स लेगा।

— मार्टिन एंडर
स्रोत

3

गंभीरता से, फिर से बनाया?

— मैथ्यू रो

1

@MatthewRoh मुझे यकीन है कि एक गोल्फिंग भाषा में एक अच्छी तरह से गोल्फ अंकगणित समाधान आसानी से इसे हरा देगा।

— मार्टिन एंडर

@MartinEnder खैर, मैं वास्तव में सटीक विपरीत के बारे में निश्चित हूं।

— एरिक आउटोलॉफ़र

@EriktheOutgolfer ठीक है, वहाँ तुम जाओ । मुझे यकीन है कि जेली एक और 30-50% काट सकता है।

— मार्टिन एंडर

@MartinEnder मैं शायद सबसे ज्यादा डेनिस को छोड़ दूंगा, मैं परीक्षा अवधि में ऐसा काम नहीं कर सकता।

— को एर्गेल्फ़र से एरिक

6

पायथन 2 , 205 136 बाइट्स

-26 बाइट्स @ डेड पॉसम का धन्यवाद

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]

इसे ऑनलाइन आज़माएं!

— फेलिप नारदी बतिस्ता
स्रोत

3

PHP, 144 बाइट्स

नोट: 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);

इस तरह से चलाएं:

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

व्याख्या

जाँच करें कि इनपुट सीमा के भीतर है Lया नहीं A; "अपवाद" पर्वतमाला। फिर ग्रिड में लापता कोशिकाओं को भरने के लिए इनपुट को संशोधित करें (या अतिरिक्त कोशिकाओं से छुटकारा पाएं)। अंत में, अपवाद को प्रिंट करें (जब तक कि गलत न हो 0) या ग्रिड निर्देशांक में स्थिति को बदल दें।

— aross
स्रोत

आपका उदाहरण, मुझे प्राप्त आउटपुट चल रहा है 18<t7। क्या यह कुछ मैं गलत कर रहा हूँ? (Mac El Capitan पर चल रहा है)

— जेम्स वेबस्टर

1

@JamesWebster कि एन्कोडिंग के कारण मैंने कॉमा के लिए उपयोग किया है। आप अपने टर्मिनल के कूट परिवर्तन नहीं कर सकते हैं, तो आप 2 डॉट्स के बीच बात (बस से पहले जगह ले सकता है ceilके साथ) "," 1 अतिरिक्त बाइट के लिए

— aross

3

जेली , 57 बाइट्स

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

पूर्ण कार्यक्रम जो वांछित आउटपुट प्रिंट करता है।

इसे ऑनलाइन आज़माएं! (थोड़ा संशोधित कार्यक्रम जो सभी प्रिंट करताinput : outputहै यहां देखा जा सकता है )।

कैसे?

118 संभावित आउटपुट की एक सूची बनाता है और फिर इनपुट के सूचकांक में प्रविष्टि को चुनता है।

कुछ प्रस्तुत करने का:

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

कार्यक्रम (प्रतिस्थापन छोटा A, Bऔर 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

पर्ल 5, 202 बाइट्स

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

— माइकल व्हीलर
स्रोत

मैं स्ट्रिंग के '\ 201 \ 202 \ 203 \ ... \ 362' भाग को छोटा करने की सलाह दूंगा। गंभीरता से, इसकी लंबी बिल्ली के रूप में।

— मैथ्यू रो

1

जिज्ञासु कैसे @MatthewRoh ने हेक को मापा।

— hBy2Py

2

रूबी, 130 बाइट्स

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

पहले बिटमास्क चाल के साथ 'ए' और 'एल' प्राप्त करें, फिर 18 * 7 आयत में फिट होने की कोशिश करें और div / mod का उपयोग करें।

— जीबी
स्रोत

2

पायथन 2 , 137 बाइट्स

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]

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

2

पायथन 2 , 115 बाइट्स

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]

इसे ऑनलाइन आज़माएं!

समूह और अवधि प्राप्त करने के लिए ग्रिड स्थिति को विभाजित करने का विचार है। ग्रिड की स्थिति nअंतराल और एल / ए संकुचन के लिए एक विस्थापन द्वारा समायोजित इनपुट है। इन्हें एक सूची से निकाला जाता है।

Lanthanide और Actinide हैंडलिंग बदसूरत है। इन्हें बड़े विस्थापन 200 और 400 दिए गए हैं जिनका पता लगाया जा सकता है /200। मैं पात्रों Lऔर Aयहाँ रखना चाहता हूँ , लेकिन फिर n+=...एक नंबर के लिए एक चार जोड़ देगा, भले ही nउपयोग नहीं किया गया हो। यदि 1-इंडेक्सिंग के लिए नहीं, केवल एक बार divmodसंदर्भित करने के लिए इस्तेमाल किया जा सकता है n, और फिर इसे अपनी अभिव्यक्ति से बदला जा सकता है,

— XNOR
स्रोत

2

जावास्क्रिप्ट (ईएस 7), 100 98 बाइट्स

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>

स्निपेट का विस्तार करें

स्पष्टीकरण: 'एल' और 'ए' श्रृंखला विशेष-आवरण हैं, जिन्होंने कुछ बिटवाइज़ लॉजिक का उपयोग करके मुझे 3 बाइट्स को सीधी तुलना में बचाया। अन्यथा फ़ंक्शन पुनरावर्ती रूप pसे वांछित परमाणु संख्या, पिछली अवधि में अंतिम तत्व xकी संख्या, और उस अवधि में अंतिम तत्व की संख्या yको सम्‍मिलित करता है, जिसकी गणना हर बार यह देखते हुए की जाती है कि अंतर 2, 2, 8 हैं , 8, 18, 18 अर्थात दोहराए गए वर्ग संख्याएँ। तब समूह तालिका के बाईं या दाईं ओर से ऑफसेट करके पाया जाता है जो इस बात पर निर्भर करता है कि तत्व बेरिलियम-स्कैंडियम विकर्ण के नीचे है या नहीं।

— नील
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 136 बाइट्स

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)

परीक्षा

कोड स्निपेट दिखाएं

let f =

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)

<input oninput="o.innerHTML=f(+value)" type="number" min=1 max=118/>
<pre id="o"></pre>

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

पायथन 2 , 264 227 217 बाइट्स

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]

इसे ऑनलाइन आज़माएं!

बहुत से कोष्ठक। यह ब्रेन-फ्लैक की तरह अधिक दिखता है।

— ElPedro
स्रोत

आप whileसमारोह के बाहर जगह नहीं कर सकते ? यह एक बाइट (स्थान) को बचाएगा

— फेलिप नारदी बतिस्ता

@FelipeNardiBatista - whileपाश से पूरी तरह छुटकारा पाने के लिए प्रबंधित :) :)

— ElPedro

1

एक्सेल, 192 बाइट्स

बहुत दूर से। मौजूदा पायथन जवाब से उधार

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

MOD(x,18)=0समूह मान के लिए मामले को बेहतर तरीके से संभालने के लिए संघर्ष करना ।

— Wernisch
स्रोत

मुझे लगता है कि मुझसे गलती हो गई है। लेफ्टिनेंट और एक्टिनाइड को निर्धारित करने के लिए आईएफ को पढ़ना चाहिए IF(A1<80?

— जेम्स वेबस्टर

@JamesWebster, अच्छी तरह से देखा। सही किया है।

— वेर्निस्क

0

रूबी, 116 बाइट्स

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

परीक्षण कार्यक्रम में टिप्पणी की

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 बाइट्स

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

STDIN से इनपुट लेता है, साथ चलता है -nR।

lanthanides और एक्टिनाइड्स के लिए कुछ बिटवाइज़ जादू, हिस्सा जोड़ता है और अंतराल और lanthanides / एक्टिनाइड्स के लिए घटाता ऑफसेट, बाकी सरल आधुनिक / div है।
$n-=

नील के उत्तर का एक पुनरावृत्त बंदरगाह 108 बाइट्स लेता है :

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

पर्ल, 169 बाइट्स

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"

का उपयोग करते हुए:

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

जेली , ४ ९ ४३ ४२ ४१ ३ ९ बाइट्स

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

इसे ऑनलाइन आज़माएं!

पृष्ठभूमि

लैंथेनाइड्स और एक्टिनाइड्स के अपवाद के साथ, आउटपुट में एक पूर्णांक शामिल होगा जो कि विशेषण आधार 18 में व्यक्त किया गया है। उदाहरण के लिए, हाइड्रोजन 19 ₁₀ = 11 _b18 , हीलियम से 36 ₁₀ = _{1I b18} , और eka-radon / ununoctium / oganesson से मेल खाती है 114 ₁₀ = ₇_{आई बी 18} ।

हम उन सभी परमाणु संख्याओं की मैपिंग करके शुरू करते हैं जिन्हें हम संबंधित पूर्णांकों तक ले जा सकते हैं, जबकि _{लैंथेनाइड्स} और _{एक्टिनायड्स की} मैपिंग करते हैं जो _{लैंथेनम} ( 111 ₁₀ = 63 _b18 ) और एक्टिनियम ( 129 ₁₀ = 73 _{b18) के अनुरूप होते हैं।} ) के ।

ऐसा करने के लिए, हम पूर्णांक के आगे के अंतरों को रिकॉर्ड करते हैं जो परमाणुओं का प्रतिनिधित्व करते हैं। उदाहरण के लिए, पहला है 1 मैं _B18 11 - _B18 = एच _B18 = 17 ₁₀ , दूसरे स्थान पर है 1 (के रूप में कर रहे हैं अविस्तारित आवर्त सारणी की लगातार तत्वों के बीच सभी मतभेदों को), चौथे ( बी करने के लिए हो सकता है ) है 2 डी _B18 - 22_B18 = बी _b18 = 11 ₁₀ , और इसी तरह। सभी लैंथेनाइड्स और सभी एक्टिनाइड्स को मैप करने के लिए, हम दो लैंथेनाइड्स या एक्टिनाइड्स (जैसे, ला से सीई ) केबीच सभी अंतरोंको 0 मानेंगे ।

परमाणु संख्या n के लिए वांछित पूर्णांक प्राप्त करने के लिए , हमें केवल 19 करना होगा (हाइड्रोजन) अंतरों के लिए पूर्ववर्ती करें और परिणामी वेक्टर के पहले n तत्वों के योग की गणना करें । तब आउटपुट को केवल जीवनी आधार 18 में प्रदर्शित किया जाता है, जब तक कि यह 6 3 (लैंथेनाइड्स) या 7 3 (एक्टाइडसाइड्स) प्रदर्शित नहीं करेगा । बाद के मामले में, हम बस गणना परिणाम को एल या ए के साथ बदलते हैं ।

क्षैतिज पवित्रता के लिए लिपटे, जिस वेक्टर को हमें एनकोड करना है वह निम्न प्रकार से दिखता है।

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

रन-लंबाई एन्कोडिंग के बाद, हम निम्नलिखित प्राप्त करते हैं।

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

वेक्टर को और अधिक एन्कोड करने के लिए आवश्यक स्थान को कम करने के लिए, हम सबसे दाहिनी ओर 1 (लंबाई) स्ट्रिप करते हैं और 1 रन जोड़ते हैं ।

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

अब हम इन अंकों के सारणी को आधार 45 से पूर्णांक में बदल सकते हैं।

20      18      92     12      97     12      134     59      108     59      105

ये सभी 250 से छोटे हैं , इसलिए हम जेली के कोड पेज के पात्रों के साथ उनका प्रतिनिधित्व कर सकते हैं । साथ घिरा “(शाब्दिक शुरू) और ‘(पूर्णांक सरणी के रूप में व्याख्या), हम जेली शाब्दिक मिल

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

जो कोड में शब्दशः दिखाई देता है।

यह काम किस प्रकार करता है

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

— डेनिस
स्रोत

हालांकि यह एक दिलचस्प जवाब है, मुझे डर है कि मुझे लगता है कि यह आउटपुट पर गिरता है। इनपुट के लिए समूह और अवधि के आउटपुट के बजाय, यह पूर्ण तालिका के लिए परमाणु संख्या, समूह और अवधि को आउटपुट करता है। विचार करें कि क्या मैंने आपसे किसी शब्द की डिक्शनरी की परिभाषा पूछी है और आपने सिर्फ एक डिक्शनरी लिखी है।

— जेम्स वेबस्टर

पाद लेख आसान सत्यापन के लिए एक परीक्षण सूट प्रदान करता है। यदि आप इसे हटा देते हैं और इनपुट को एक तर्क के रूप में प्रदान करते हैं, तो यह केवल उस जानकारी को प्रिंट करेगा, जो युक्ति पूछती है। tio.run/nexus/jelly#@29i@qhhzuF5h2fEPGpakwjEjxq3WedYZz5qmJFUoQ/…

— डेनिस

रसायन विज्ञान 101 - आवर्त सारणी का परिचय

सवाल

परीक्षण के मामलों

स्कोरिंग

CJam , 64 59 58 56 54 बाइट्स

व्याख्या

05AB1E , 113 102 99 बाइट्स

गणितज्ञ, 77 बाइट्स

पायथन 2 , 205 136 बाइट्स

PHP, 144 बाइट्स

व्याख्या

जेली , 57 बाइट्स

कैसे?

पर्ल 5, 202 बाइट्स

रूबी, 130 बाइट्स

पायथन 2 , 137 बाइट्स

पायथन 2 , 115 बाइट्स

जावास्क्रिप्ट (ईएस 7), 100 98 बाइट्स

जावास्क्रिप्ट (ईएस 6), 136 बाइट्स

परीक्षा

पायथन 2 , 264 227 217 बाइट्स

एक्सेल, 192 बाइट्स

रूबी, 116 बाइट्स

PHP, 120 बाइट्स

पर्ल, 169 बाइट्स

जेली , ४ ९ ४३ ४२ ४१ ३ ९ बाइट्स

पृष्ठभूमि

यह काम किस प्रकार करता है