इलेक्ट्रॉन विन्यास

18

इलेक्ट्रॉन विन्यास

आपका मिशन एक तत्व के परमाणु संख्या को इनपुट के रूप में स्वीकार करना है, और इसके इलेक्ट्रॉन कॉन्फ़िगरेशन (उदाहरण के लिए) को आउटपुट करना है2,8,8,2 कैल्शियम के लिए) का उत्पादन करना है।

इनपुट

1 से 118 तक परमाणु संख्या। आप मान्य इनपुट मान सकते हैं। परमाणु को चार्ज नहीं किया जाता है (इसमें प्रोटॉन जितने इलेक्ट्रॉन होते हैं)। आप इनपुट को एक चर में संग्रहीत करने की उम्मीद नहीं कर सकते हैं, और आपको एक पूरा कार्यक्रम लिखना होगा।

उत्पादन

प्रत्येक गैर-खाली इलेक्ट्रॉन शेल में इलेक्ट्रॉनों की संख्या। मैं आउटपुट प्रारूप के साथ काफी उदार होगा; निम्नलिखित में से सभी स्वीकार्य हैं, अर्थात आप संख्याओं को अलग करने के लिए किसी विराम चिह्न या व्हाट्सएप का उपयोग कर सकते हैं, और किसी भी प्रकार के ब्रैकेट की अनुमति है। कृपया निर्दिष्ट करें कि किसका उपयोग किया जाता है।

  • 2,8,8,2
  • 2.8.8.2
  • 2, 8, 8, 2,
  • [2,8,8,2]
  • 2 8 8 2
  • ([2 [8]] [8] 2)

कैसे इलेक्ट्रॉन काम करते हैं

परमाणुओं में, इलेक्ट्रॉनों को "गोले" में क्रमबद्ध किया जाता है, जो ऊर्जा स्तर हैं। प्रत्येक शेल में एक निश्चित क्षमता होती है, इलेक्ट्रॉनों की अधिकतम संख्या जो इसे धारण करने में सक्षम होती है। गोले अंदर से बाहर से भरे हुए हैं, लेकिन समान रूप से नहीं। आपका कार्य निर्धारित करना है, एक परमाणु संख्या दी गई है, प्रत्येक शेल में कितने इलेक्ट्रॉन हैं, इस स्रोत के अनुसार ।

कैल्शियम तक (और परमाणु संख्या 20) सहित, गोले समान रूप से और क्रम में भरते हैं; भीतरी खोल पहले 2 की अपनी क्षमता से भरा होता है, दूसरा 8 से, फिर तीसरा से 8 और आखिरी से 2. कैल्शियम का इलेक्ट्रॉन विन्यास होता है 2,8,8,2।

कैल्शियम के बाद, चीजें जटिल हो जाती हैं; आगे के इलेक्ट्रॉन तीसरे शेल में चले जाते हैं, आखिरी नहीं। चीजों को बदतर बनाने के लिए, वैनेडियम (23) है 2,8,11,2, जबकि क्रोमियम (24) है 2,8,13,1और मैंगनीज (25) है2,8,13,2 ।

कुछ सुसंगत पैटर्न हैं, हालांकि: एक महान गैस और इससे पहले के सात तत्वों में बाहरी शेल में इलेक्ट्रॉनों की संख्या 1 से 8 तक होगी। उदाहरण के लिए:

  • सोना (79): 2,8,18,32,18,1
  • पारा (80): 2,8,18,32,18,2
  • ...
  • एस्टाटाइन (85): 2,8,18,32,18,7
  • राडोण (86): 2,8,18,32,18,8

नियम

  • मानक खामियों को मना किया जाता है।
  • इस चुनौती से पहले मौजूद पुस्तकालयों की अनुमति है।
  • कोई भी अंतर्निहित या पुस्तकालय सुविधाएँ जो विशेष रूप से परमाणुओं, अणुओं या रसायन विज्ञान से संबंधित हैं, पर प्रतिबंध लगा दिया गया है।
  • बाइट्स जीत में सबसे कम कोड की लंबाई।
  • लिंक किए गए स्रोत में, तत्वों की 103-118 के विन्यास को (?) के रूप में चिह्नित किया गया है , जैसा कि वे पूर्वानुमानित हैं, और तत्वों को जांचने के लिए बहुत अस्थिर हैं। इस चुनौती के लिए, उन्हें सही मान लें।
  • आप अपने डेटा के सभी भाग को हार्डकोड कर सकते हैं।
  • [नया नियम] यदि आप उन में नियंत्रण वर्णों का उपयोग करते हैं (जैसा कि बहुत से उत्तर प्रतीत होते हैं) अपनी फ़ाइलों का एक बेस 64 या xxd डंप प्रदान करें

विजेता: 80 बाइट्स पर डेनिस का सीजेएम जवाब !

code-golf  math  kolmogorov-complexity  chemistry 
— समुदाय
स्रोत

जवाबों:

14

सीजेएम, 87 83 82 80 बाइट्स

0"hTHøìð¼Ä¿håêÛ¾ªÔ¼"256b6b5a/4a8**li<{[33:B_B*65_B*1]=\_B%8=B\#*+}/Bb0-`

उपरोक्त कोड में अनपेक्षित वर्ण हैं।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं । यदि लिंक आपके लिए काम नहीं करता है, तो इस पेस्ट से कॉपी करें ।

पृष्ठभूमि

Nth परमाणु के इलेक्ट्रॉन विन्यास को प्राप्त करने के लिए , हम इलेक्ट्रॉनों के बिना एक परमाणु से शुरू करते हैं और उस पर N रूपांतरण लागू करते हैं।

कार्यान्वयन की बाइट गिनती को कम करने के लिए, हम एक पूर्णांक के रूप में एक परमाणु के इलेक्ट्रॉन विन्यास का प्रतिनिधित्व करते हैं। आधार 33 में उस पूर्णांक का प्रत्येक अंक एक निश्चित गोले में इलेक्ट्रॉनों की संख्या से मेल खाता है; सबसे कम महत्वपूर्ण अंक बाहरी शेल का प्रतिनिधित्व करता है।

उदाहरण के लिए, मोलिब्डेनम (42) का इलेक्ट्रॉन विन्यास [2 8 18 13 1] है । यह पूर्णांक 2 × 33 4 + 8 × 33 3 + 18 × 33 2 + 13 × 33 + 1 = 26,79270 से मेल खाता है ।

पैलेडियम (48) एक विशेष मामला है, जो हम के रूप में इलाज है [2 8 18 18 0] के बजाय [2 8 18 18] ।

यह सुविधाजनक प्रतिनिधित्व सरल अंकगणित के लिए उपरोक्त परिवर्तनों को कम करता है:

  • R += 1 (बाहरी आवरण में एक इलेक्ट्रॉन जोड़ें)
  • R += 33 (दूसरे बाहरी शेल में एक इलेक्ट्रॉन जोड़ें)
  • R += 65 (दूसरे बाहरी शेल में दो इलेक्ट्रॉनों को जोड़ें; एक को पहले से हटाएं)
  • R += 1089 (तीसरे बाहरी आवरण में एक इलेक्ट्रॉन जोड़ें)
  • R += 2145 (तीसरे बाहरी शेल में दो इलेक्ट्रॉनों को जोड़ें; एक को दूसरे से निकालें)
  • R *= 33, R += 1 (एकल इलेक्ट्रॉन युक्त एक नया शेल जोड़ें)

जो कुछ बचा है वह किसी भी तरह से एनकोड करना है कि किसी विशेष परमाणु से अगले में जाने के लिए किस परिवर्तन को लागू किया जाना है। दो लगातार परमाणुओं के पूर्णांक निरूपण के अंतर इस प्रकार हैं:

[1 1 65 1 1 1 1 1 1 1 2369 1 1 1 1 1 1 1 78401 1 33 33 33 65 1 33 33 33 65 1 1 1 1 1 1 1 2598017 1 33 33 65 33 1 65 33 65 1 1 1 1 1 1 1 1 85745345 1 33 1089 2145 1089 1089 1089 1089 33 2145 1089 1089 1089 1089 1089 33 33 33 33 33 33 33 65 33 1 1 1 1 1 1 1 2830095041 1 33 33 2145 1089 1089 2145 1089 33 2145 1089 1089 1089 1089 1089 65 1 33 33 33 33 33 33 65 1 1 1 1 1 1 1]

इस सरणी में अद्वितीय अंतर निम्नलिखित हैं:

[1 33 65 1089 2145 2369 78401 2598017 85745345 2830095041]

जब नया शेल जोड़ा जाता है तो सभी पहले 5 उदाहरणों के अनुरूप होते हैं; 33 से गुणा करने और 1 पैदावार जोड़ने के बाद से इनका लोप किया जा सकता है और अंतर को जोड़ने के समान परिणाम मिलते हैं।

चूँकि हमें एक नया शेल जोड़ना है, यदि और केवल अगर वर्तमान परमाणु में इसके बाहरी शेल में ठीक आठ इलेक्ट्रॉनों हैं ( वह (2) (Li (3) के अपवाद के साथ , जिसे 65 के रूप में एन्कोड किया जा सकता है ), हम एन्कोड कर सकते हैं 1 के रूप में उन परिवर्तनों और मक्खी पर गुणा की आवश्यकता का निर्धारण करते हैं।

इस प्रकार, यदि हम परिभाषित करते हैं

X := 0
I := 0
L := [33 1089 65 2145 1]
T := [1 1 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 3 1 0 0 0 3 1 1 1 1 1 1 1 1 1 0 0 3 0 1 3 0 3 1 1 1 1 1 1 1 1 1 1 0 2 4 2 2 2 2 0 4 2 2 2 2 2 0 0 0 0 0 0 0 3 0 1 1 1 1 1 1 1 1 1 0 0 4 2 2 4 2 0 4 2 2 2 2 2 3 1 0 0 0 0 0 0 3 1 1 1 1 1 1 1]

Nth परमाणु के इलेक्ट्रॉन विन्यास की गणना निम्नानुसार की जा सकती है:

while(X < N):
    R *= (33 ** (R % 33 == 8))
    R += L[T[X]]
    X += 1

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

" Push 0, the initial value of R; convert the following array into an integer by
  considering it a base 256 number, then back to the array of its digits in base 6.       ";

0"hTHøìð¼Ä¿håêÛ¾ªÔ¼"256b6b

" Replace each 5 in the resulting array by [4 4 4 4 4 4 4 4]. This yields the array T
  from the above section.                                                                 ";

5a/4a8**

" Read an integer N from STDIN and discard all but the first N elements of T.             ";

li<

" For each element Y of the remainder of T, do the following:                             ";

{
    [33:B_B*65_B*1]=\   " Define B := 33, push L, retrieve L[Y] and swap it with R.       ";

    _B%8=B\#*           " Execute R *= 33 ** (R % 33 == 8).                               ";

    +                   " Execute R += L[Y].                                              ";
}/

" Convert R into the array of its digits in base 33, remove eventual zeros (Palladium)
  and replace the resulting array with its string representation.                         ";

Bb0-`

उदाहरण चलाते हैं

$ base64 -d > electrons.cjam <<< MCJoVEgM+OzwErzEGL9o5erbvqrUB4YZhrwRIjI1NmI2YjVhLzRhOCoqbGk8e1szMzpCX0IqNjVfQioxXT1cX0IlOD1CXCMqK30vQmIwLWA=
$ cksum electrons.cjam
3709391992 80 electrons.cjam
$ for i in {1..118}; do LANG=en_US cjam electrons.cjam <<< $i; echo; done
[1]
[2]
[2 1]
[2 2]
[2 3]
[2 4]
[2 5]
[2 6]
[2 7]
[2 8]
[2 8 1]
[2 8 2]
[2 8 3]
[2 8 4]
[2 8 5]
[2 8 6]
[2 8 7]
[2 8 8]
[2 8 8 1]
[2 8 8 2]
[2 8 9 2]
[2 8 10 2]
[2 8 11 2]
[2 8 13 1]
[2 8 13 2]
[2 8 14 2]
[2 8 15 2]
[2 8 16 2]
[2 8 18 1]
[2 8 18 2]
[2 8 18 3]
[2 8 18 4]
[2 8 18 5]
[2 8 18 6]
[2 8 18 7]
[2 8 18 8]
[2 8 18 8 1]
[2 8 18 8 2]
[2 8 18 9 2]
[2 8 18 10 2]
[2 8 18 12 1]
[2 8 18 13 1]
[2 8 18 13 2]
[2 8 18 15 1]
[2 8 18 16 1]
[2 8 18 18]
[2 8 18 18 1]
[2 8 18 18 2]
[2 8 18 18 3]
[2 8 18 18 4]
[2 8 18 18 5]
[2 8 18 18 6]
[2 8 18 18 7]
[2 8 18 18 8]
[2 8 18 18 8 1]
[2 8 18 18 8 2]
[2 8 18 18 9 2]
[2 8 18 19 9 2]
[2 8 18 21 8 2]
[2 8 18 22 8 2]
[2 8 18 23 8 2]
[2 8 18 24 8 2]
[2 8 18 25 8 2]
[2 8 18 25 9 2]
[2 8 18 27 8 2]
[2 8 18 28 8 2]
[2 8 18 29 8 2]
[2 8 18 30 8 2]
[2 8 18 31 8 2]
[2 8 18 32 8 2]
[2 8 18 32 9 2]
[2 8 18 32 10 2]
[2 8 18 32 11 2]
[2 8 18 32 12 2]
[2 8 18 32 13 2]
[2 8 18 32 14 2]
[2 8 18 32 15 2]
[2 8 18 32 17 1]
[2 8 18 32 18 1]
[2 8 18 32 18 2]
[2 8 18 32 18 3]
[2 8 18 32 18 4]
[2 8 18 32 18 5]
[2 8 18 32 18 6]
[2 8 18 32 18 7]
[2 8 18 32 18 8]
[2 8 18 32 18 8 1]
[2 8 18 32 18 8 2]
[2 8 18 32 18 9 2]
[2 8 18 32 18 10 2]
[2 8 18 32 20 9 2]
[2 8 18 32 21 9 2]
[2 8 18 32 22 9 2]
[2 8 18 32 24 8 2]
[2 8 18 32 25 8 2]
[2 8 18 32 25 9 2]
[2 8 18 32 27 8 2]
[2 8 18 32 28 8 2]
[2 8 18 32 29 8 2]
[2 8 18 32 30 8 2]
[2 8 18 32 31 8 2]
[2 8 18 32 32 8 2]
[2 8 18 32 32 10 1]
[2 8 18 32 32 10 2]
[2 8 18 32 32 11 2]
[2 8 18 32 32 12 2]
[2 8 18 32 32 13 2]
[2 8 18 32 32 14 2]
[2 8 18 32 32 15 2]
[2 8 18 32 32 16 2]
[2 8 18 32 32 18 1]
[2 8 18 32 32 18 2]
[2 8 18 32 32 18 3]
[2 8 18 32 32 18 4]
[2 8 18 32 32 18 5]
[2 8 18 32 32 18 6]
[2 8 18 32 32 18 7]
[2 8 18 32 32 18 8]
— डेनिस
स्रोत
1
प्रयास की सरासर राशि के लिए एक उत्थान, श्रीमान। ;)
— सीओटीओ
6

GolfScript (96 बाइट्स)

आउटपुट फॉर्म में है

[2 8 18 18]

यह एक जादुई स्ट्रिंग का उपयोग करता है जिसमें गैर-मुद्रण योग्य वर्ण होते हैं, इसलिए मैं xxd प्रारूप में स्क्रिप्ट दे रहा हूं:

0000000: 7e30 5c27 0193 ca05 528e 6b25 e461 4d12  ~0\'....R.k%.aM.
0000010: 3195 9abf c9a4 bfad 588b d876 5e72 c82a  1.......X..v^r.*
0000020: 2dd3 6e92 4940 e00b 80dc 71f6 fc97 2732  -.n.I@....q...'2
0000030: 3536 6261 7365 2037 6261 7365 3c7b 2731  56base 7base<{'1
0000040: 0a29 0a5c 295c 0a2b 310a 2b29 0a40 2940  .).\)\.+1.+).@)@
0000050: 400a 402b 5c28 3227 6e2f 3d7e 7d2f 5d60  @.@+\(2'n/=~}/]`

के लिए ऑनलाइन परीक्षण मैं पलायन के साथ जादू स्ट्रिंग लिख रहा हूँ:

"\x01\x93\xCA\x05R\x8Ek%\xE4aM\x121\x95\x9A\xBF\xC9\xA4\xBF\xADX\x8B\xD8v^r\xC8*-\xD3n\x92I@\xE0\v\x80\xDCq\xF6\xFC\x97"

लेकिन यह तब समतुल्य है जब आप पात्रों को ब्राउज़र टेक्स्टारैस में चिपकाने की समस्या में नहीं चल रहे हैं।

दृष्टिकोण 7 निर्देशों के साथ एक आभासी मशीन का निर्माण करना है, जिनमें से प्रत्येक इलेक्ट्रॉन की सूची में हेरफेर करता है। फिर तत्व के लिए nहम एक इलेक्ट्रॉनिक गणना सूची के साथ शुरू करते हैं 0और nजादू स्ट्रिंग द्वारा एन्कोड की गई सूची से पहला निर्देश चलाते हैं ।

निर्देश हैं:

  1. 1 इलेक्ट्रॉन के साथ एक नया शेल जोड़ें: 1
  2. बाहरी आवरण में एक इलेक्ट्रॉन जोड़ें: )
  3. अगले-से-बाहरी शेल में एक इलेक्ट्रॉन जोड़ें: \)\
  4. दो बाहरी गोले को मिलाएं और एक इलेक्ट्रॉन जोड़ें +):। (यह केवल पैलेडियम के लिए उपयोग किया जाता है)।
  5. दो बाहरी गोले को मिलाएं और 1 इलेक्ट्रॉन के साथ एक नया शेल बनाएं: +1
  6. तीसरे शेल में एक इलेक्ट्रॉन जोड़ें: @)@@
  7. तीसरे शेल में एक इलेक्ट्रॉन जोड़ें और एक को दूसरे शेल से तीसरे शेल में स्थानांतरित करें। यह केवल तब होता है जब बाहरी शेल में 2 इलेक्ट्रॉन होते हैं, इसलिए इसे @+\(2लंबे समय तक लागू किया जाता है@2+@(@
— पीटर टेलर
स्रोत
आपके 7 निर्देश क्या हैं?
— COTO
आह। धन्यवाद। मुझे लगता है कि मुझे इन दिनों एक गोल्फ चुनौती जीतने के लिए इन गूढ़ गोल्फिंग भाषाओं में से एक को चुनने की आवश्यकता है। मेरे पास एक समय था कॉम्पैक्ट कोड लिखने की जो दो निर्देशों की व्याख्या कर सकता था, अकेले सात। : पी
— सीओटीओ
क्या मैं एसटीडीआईएन पर इनपुट प्रदान करता हूं? (और फिर यह स्टैक पर दिखाई देता है)?
@professorfish: हाँ। GolfScript स्वचालित रूप से स्टैक पर STDIN से इनपुट रखता है।
— डेनिस
5

पायथन 2 (46 + 271 = 327)

कोड:

print open('f').read().decode('zip').split(';')[input()]

फ़ाइल f, जिसमें बाइनरी कचरा है (ये चार कोड हैं)

120, 156, 101, 146, 219, 21, 195, 32, 12, 67, 87, 233, 8, 193, 188, 204, 201, 254, 123, 21, 40, 46, 146, 253, 65, 163, 171, 10, 98, 199, 188, 233, 149, 87, 62, 243, 247, 179, 158, 121, 174, 50, 87, 157, 171, 205, 213, 231, 210, 181, 118, 66, 119, 70, 119, 74, 119, 78, 119, 82, 119, 86, 127, 233, 147, 183, 29, 182, 103, 156, 103, 122, 76, 36, 19, 249, 68, 167, 56, 78, 49, 81, 77, 52, 19, 118, 110, 210, 235, 100, 19, 197, 68, 53, 209, 76, 116, 19, 250, 23, 247, 36, 56, 107, 192, 139, 30, 208, 114, 211, 183, 96, 172, 121, 87, 123, 253, 6, 90, 175, 66, 23, 118, 66, 15, 216, 6, 118, 130, 205, 96, 63, 216, 18, 119, 197, 141, 185, 222, 6, 146, 36, 76, 138, 16, 101, 162, 66, 84, 29, 225, 153, 157, 254, 163, 90, 100, 32, 229, 135, 136, 106, 201, 226, 104, 16, 225, 136, 22, 38, 70, 97, 204, 140, 133, 177, 50, 246, 251, 33, 23, 170, 71, 97, 204, 140, 133, 177, 50, 54, 198, 206, 168, 14, 253, 155, 195, 187, 135, 55, 220, 103, 145, 199, 69, 230, 188, 157, 225, 63, 44, 207, 121, 25, 53, 26, 110, 75, 247, 9, 95, 170, 27, 187, 248, 201, 75, 28, 126, 152, 255, 111, 232, 41, 56, 62, 147, 130, 35, 193, 201, 193, 41, 193, 169, 193, 105, 193, 209, 80, 79, 172, 153, 111, 72, 188, 36, 241, 158, 196, 171, 18, 111, 203, 185, 16, 95, 151, 67, 8, 97

Base64: 

eJxlktsVwyAMQ1fpCMG8zMn+exUoLpL9QaOrCmLHvOmVVz7z97Oeea4yV52rzdXn0rV2QndGd0p3
TndSd1Z/6ZO3HbZnnGd6TCQT+USnOE4xUU00E3Zu0utkE8VENdFMdBP6F/ckOGvAix7QctO3YKx5
V3v9BlqvQhd2Qg/YBnaCzWA/2BJ3xY253gaSJEyKEGWiQlQd4Zmd/qNaZCDlh4hqyeJoEOGIFiZG
YcyMhbEy9vshF6pHYcyMhbEyNsbOqA79m8O7hzfcZ5HHRea8neE/LM95GTUabkv3CV+qG7v4yUsc
fpj/b+gpOD6TgiPBycEpwanBacHRUE+smW9IvCTxnsSrEm/LuRBfl0MIYQ==

अनुरोध पर, यह अब फ़ंक्शन के बजाय एक पूर्ण कार्यक्रम है।

पुराना उत्तर: अजगर (Naive baseline, 422):

f=lambda n:'eJxlktsVwyAMQ1fpCMG8zMn+exUoLpL9QaOrCmLHvOmVVz7z97Oeea4yV52rzdXn0rV2QndGd0p3TndSd1Z/6ZO3HbZnnGd6TCQT+USnOE4xUU00E3Zu0utkE8VENdFMdBP6F/ckOGvAix7QctO3YKx5V3v9BlqvQhd2Qg/YBnaCzWA/2BJ3xY253gaSJEyKEGWiQlQd4Zmd/qNaZCDlh4hqyeJoEOGIFiZGYcyMhbEy9vshF6pHYcyMhbEyNsbOqA79m8O7hzfcZ5HHRea8neE/LM95GTUabkv3CV+qG7v4yUscfpj/b+gpOD6TgiPBycEpwanBacHRUE+smW9IvCTxnsSrEm/LuRBfl0MIYQ=='.decode('base64').decode('zip').split(';')[n]

ज़िप की सामग्री:

>>>'eJxlktsVwyAMQ1fpCMG8zMn+exUoLpL9QaOrCmLHvOmVVz7z97Oeea4yV52rzdXn0rV2QndGd0p3TndSd1Z/6ZO3HbZnnGd6TCQT+USnOE4xUU00E3Zu0utkE8VENdFMdBP6F/ckOGvAix7QctO3YKx5V3v9BlqvQhd2Qg/YBnaCzWA/2BJ3xY253gaSJEyKEGWiQlQd4Zmd/qNaZCDlh4hqyeJoEOGIFiZGYcyMhbEy9vshF6pHYcyMhbEyNsbOqA79m8O7hzfcZ5HHRea8neE/LM95GTUabkv3CV+qG7v4yUscfpj/b+gpOD6TgiPBycEpwanBacHRUE+smW9IvCTxnsSrEm/LuRBfl0MIYQ=='.decode('base64').decode('zip')
';1;2;2 1;2 2;2 3;2 4;2 5;2 6;2 7;2 8;2 8 1;2 8 2;2 8 3;2 8 4;2 8 5;2 8 6;2 8 7;2 8 8;2 8 8 1;2 8 8 2;2 8 9 2;2 8 10 2;2 8 11 2;2 8 13 1;2 8 13 2;2 8 14 2;2 8 15 2;2 8 16 2;2 8 18 1;2 8 18 2;2 8 18 3;2 8 18 4;2 8 18 5;2 8 18 6;2 8 18 7;2 8 18 8;2 8 18 8 1;2 8 18 8 2;2 8 18 9 2;2 8 18 10 2;2 8 18 12 1;2 8 18 13 1;2 8 18 13 2;2 8 18 15 1;2 8 18 16 1;2 8 18 18;2 8 18 18 1;2 8 18 18 2;2 8 18 18 3;2 8 18 18 4;2 8 18 18 5;2 8 18 18 6;2 8 18 18 7;2 8 18 18 8;2 8 18 18 8 1;2 8 18 18 8 2;2 8 18 18 9 2;2 8 18 19 9 2;2 8 18 21 8 2;2 8 18 22 8 2;2 8 18 23 8 2;2 8 18 24 8 2;2 8 18 25 8 2;2 8 18 25 9 2;2 8 18 27 8 2;2 8 18 28 8 2;2 8 18 29 8 2;2 8 18 30 8 2;2 8 18 31 8 2;2 8 18 32 8 2;2 8 18 32 9 2;2 8 18 32 10 2;2 8 18 32 11 2;2 8 18 32 12 2;2 8 18 32 13 2;2 8 18 32 14 2;2 8 18 32 15 2;2 8 18 32 17 1;2 8 18 32 18 1;2 8 18 32 18 2;2 8 18 32 18 3;2 8 18 32 18 4;2 8 18 32 18 5;2 8 18 32 18 6;2 8 18 32 18 7;2 8 18 32 18 8;2 8 18 32 18 8 1;2 8 18 32 18 8 2;2 8 18 32 18 9 2;2 8 18 32 18 10 2;2 8 18 32 20 9 2;2 8 18 32 21 9 2;2 8 18 32 22 9 2;2 8 18 32 24 8 2;2 8 18 32 25 8 2;2 8 18 32 25 9 2;2 8 18 32 27 8 2;2 8 18 32 28 8 2;2 8 18 32 29 8 2;2 8 18 32 30 8 2;2 8 18 32 31 8 2;2 8 18 32 32 8 2;2 8 18 32 32 10 1;2 8 18 32 32 10 2;2 8 18 32 32 11 2;2 8 18 32 32 12 2;2 8 18 32 32 13 2;2 8 18 32 32 14 2;2 8 18 32 32 15 2;2 8 18 32 32 16 2;2 8 18 32 32 18 1;2 8 18 32 32 18 2;2 8 18 32 32 18 3;2 8 18 32 32 18 4;2 8 18 32 32 18 5;2 8 18 32 32 18 6;2 8 18 32 32 18 7;2 8 18 32 32 18 8'
>>>len(_)
1478

और एक त्वरित परीक्षण:

map(f, range(119))
Out[48]: 
['',
 '1',
 '2',
 '2 1',
 '2 2',
 '2 3',
 '2 4',
 '2 5',
 '2 6',
 '2 7',
 '2 8',
 '2 8 1',
 '2 8 2',
 '2 8 3',
 '2 8 4',
 '2 8 5',
 '2 8 6',
 '2 8 7',
 '2 8 8',
 '2 8 8 1',
 '2 8 8 2',
 '2 8 9 2',
 '2 8 10 2',
 '2 8 11 2',
 '2 8 13 1',
 '2 8 13 2',
 '2 8 14 2',
 '2 8 15 2',
 '2 8 16 2',
 '2 8 18 1',
 '2 8 18 2',
 '2 8 18 3',
 '2 8 18 4',
 '2 8 18 5',
 '2 8 18 6',
 '2 8 18 7',
 '2 8 18 8',
 '2 8 18 8 1',
 '2 8 18 8 2',
 '2 8 18 9 2',
 '2 8 18 10 2',
 '2 8 18 12 1',
 '2 8 18 13 1',
 '2 8 18 13 2',
 '2 8 18 15 1',
 '2 8 18 16 1',
 '2 8 18 18',
 '2 8 18 18 1',
 '2 8 18 18 2',
 '2 8 18 18 3',
 '2 8 18 18 4',
 '2 8 18 18 5',
 '2 8 18 18 6',
 '2 8 18 18 7',
 '2 8 18 18 8',
 '2 8 18 18 8 1',
 '2 8 18 18 8 2',
 '2 8 18 18 9 2',
 '2 8 18 19 9 2',
 '2 8 18 21 8 2',
 '2 8 18 22 8 2',
 '2 8 18 23 8 2',
 '2 8 18 24 8 2',
 '2 8 18 25 8 2',
 '2 8 18 25 9 2',
 '2 8 18 27 8 2',
 '2 8 18 28 8 2',
 '2 8 18 29 8 2',
 '2 8 18 30 8 2',
 '2 8 18 31 8 2',
 '2 8 18 32 8 2',
 '2 8 18 32 9 2',
 '2 8 18 32 10 2',
 '2 8 18 32 11 2',
 '2 8 18 32 12 2',
 '2 8 18 32 13 2',
 '2 8 18 32 14 2',
 '2 8 18 32 15 2',
 '2 8 18 32 17 1',
 '2 8 18 32 18 1',
 '2 8 18 32 18 2',
 '2 8 18 32 18 3',
 '2 8 18 32 18 4',
 '2 8 18 32 18 5',
 '2 8 18 32 18 6',
 '2 8 18 32 18 7',
 '2 8 18 32 18 8',
 '2 8 18 32 18 8 1',
 '2 8 18 32 18 8 2',
 '2 8 18 32 18 9 2',
 '2 8 18 32 18 10 2',
 '2 8 18 32 20 9 2',
 '2 8 18 32 21 9 2',
 '2 8 18 32 22 9 2',
 '2 8 18 32 24 8 2',
 '2 8 18 32 25 8 2',
 '2 8 18 32 25 9 2',
 '2 8 18 32 27 8 2',
 '2 8 18 32 28 8 2',
 '2 8 18 32 29 8 2',
 '2 8 18 32 30 8 2',
 '2 8 18 32 31 8 2',
 '2 8 18 32 32 8 2',
 '2 8 18 32 32 10 1',
 '2 8 18 32 32 10 2',
 '2 8 18 32 32 11 2',
 '2 8 18 32 32 12 2',
 '2 8 18 32 32 13 2',
 '2 8 18 32 32 14 2',
 '2 8 18 32 32 15 2',
 '2 8 18 32 32 16 2',
 '2 8 18 32 32 18 1',
 '2 8 18 32 32 18 2',
 '2 8 18 32 32 18 3',
 '2 8 18 32 32 18 4',
 '2 8 18 32 32 18 5',
 '2 8 18 32 32 18 6',
 '2 8 18 32 32 18 7',
 '2 8 18 32 32 18 8']
— ɐɔıʇǝɥʇuʎs
स्रोत
यह अच्छा है, लेकिन कृपया इसे एक पूर्ण कार्यक्रम बनाएं (जो स्टड या तर्कों से इनपुट में पढ़ता है); इसके अलावा, आप बेस 64 से बचने के लिए एक बाहरी फ़ाइल का उपयोग कर सकते हैं (लेकिन कोड लंबाई की ओर फ़ाइल और उसका नाम गिना जाता है)
जब तक आप सवाल के साथ शुरू करने के लिए लिंक का जवाब एक स्पष्ट अपवाद है (प्राथमिक अपवाद उन kolmogorov-complexity टैग किया जा रहा है) , जो यहाँ मामला है। कोल्मोगोरोव-जटिलता के सवालों का पूरा विचार आउटपुट को सबसे कुशल तरीके से हार्डकोड करना है।
— डेनिस
मुझे कोलमोगोरोव-जटिलता टैग याद आया। और यहाँ मैं विभिन्न घाटी उपधाराओं के ऊर्जा स्तर को समझने की कोशिश कर रहा हूँ, और मैं भौतिक विज्ञानी भी नहीं हूँ। :I
— सेमिच
"पुराना उत्तर" केवल पायथन 2 में काम करता है। मैंने नया चेक नहीं किया है - क्या आपको फ़ाइल का एक आधार 64 मिल गया है fतो मैं इसे पुन: पेश कर सकता हूं?
@professorfish सबसे निश्चित रूप से। नया भी केवल अजगर 2 है ( printएक फ़ंक्शन के बजाय एक कीवर्ड के रूप में)।
— atı 19:uʎs
3

MATLAB - 248 244 241 178 + 44 = 222 बाइट्स

न्यूनतम किया गया:

i=1;a=fread(fopen('a'));b=fix(a/7);a=a-7*b+1;d=0*a;for n=1:input(''),A=a(i);if b(i),m=1;i=i+(d(A)+2>b(i));else A=A-[1;0];m=[2;-1];i=i+1;end;d(A)=d(A)+m;end;fprintf('%d ',d(~~d));

विस्तारित:

i = 1;
a = fread( fopen( 'a' ) );
b = fix( a/7 );
a = a-7*b+1;
d = 0*a;
for n = 1:input('')
    A = a(i);
    if b(i)
        m = 1;
        i = i + (d(A)+2 > b(i));
    else
        A = A - [1; 0];
        m = [2; -1];
        i = i + 1;
    end
    d(A) = d(A) + m;
end
fprintf( '%d ', d(~~d) );

बाइनरी फ़ाइल निर्भरता (फ़ाइलनाम ' a '):

0e 39 3a 11  4f 03 72 03  3b 12 49 04  5e 12 04 73
04 3c 13 43  88 04 b2 43  04 e3 6d 05  82 3d 14 4b
05 9e 05 b3  44 05 e4 06  14 75 06 3e

मुझे विश्वास है कि यह एक "पूर्ण कार्यक्रम" है, जिसमें इसे कमांडलाइन से लागू किया जा सकता है, यह इससे stdinऔर आउटपुट से पढ़ता हैstdout ।

यह इलेक्ट्रॉन विन्यास के निर्माण के लिए एक तरह के दो-अनुदेश बायटेकोड का उपयोग करता है। दो निर्देश हैं

inc D until N      (i.e. increment valence D by 1; advance to next instruction when D = N)

तथा

pulldown D         (i.e. pull down one electron from valence D, thereby decrementing it by 1
                         and incrementing valence D-1 by 2)

निर्देश दो सरणियों में एन्कोड किए गए हैं। पहले Dसभी मामलों में तर्क संग्रहीत करता है। दूसरा स्टोर करता हैN तर्क देता है या निर्देश 0को इंगित करता है pulldown, क्योंकिN = 0 तर्क के रूप में इसका उपयोग कभी नहीं किया जाता है।

निर्देशों का पूरा क्रम है:

inc 1 until 2
inc 2 until 8
inc 3 until 8
inc 4 until 2
inc 3 until 11
pulldown 4

inc 3 until 16
pulldown 4

inc 4 until 8
inc 5 until 2
inc 4 until 10
pulldown 5

inc 4 until 13
inc 5 until 2
pulldown 5

inc 4 until 16
pulldown 5

inc 5 until 8
inc 6 until 2
inc 5 until 9
inc 4 until 19
pulldown 5

inc 4 until 25
inc 5 until 9
pulldown 5

inc 4 until 32
inc 5 until 15
pulldown 6

inc 5 until 18
inc 6 until 8
inc 7 until 2
inc 6 until 10
pulldown 6

inc 5 until 22
pulldown 6

inc 5 until 25
inc 6 until 9
pulldown 6

inc 5 until 32
pulldown 7

inc 7 until 2
inc 6 until 16
pulldown 7

inc 7 until 8

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

बाहरी फ़ाइल संदर्भ यह है।

नमूना आउटपुट

39: 2 8 18 9 2

78: 2 8 18 32 17 1

117: 2 8 18 32 32 18 7

5: 2 3

— COTO
स्रोत
मैं "बाइनरी फ़ाइल निर्भरता" का पुनर्निर्माण कैसे करूं?
फ़ाइल 44 बाइट कोड है जो मैंने सामान्य क्रम में बाएं से दाएं, ऊपर से नीचे सूचीबद्ध किए हैं। विस्तार के बिना फ़ाइलनाम बस "ए" है। स्क्रिप्ट चलने पर इसे कार्यशील निर्देशिका में होना चाहिए। मैंने syonidv.hodginsmedia.com/misc/a
— COTO
2

पर्ल 5, 235 (234 + 1 फॉर ई)

golfed:

@a=unpack'C*','ABR3S4sT5tU6';if(($-=<>)~~[unpack'C*',')*,-./9:@NOYZ[\]`g']){$.+=($-~~[46,90]);$p=2+$-/33;$->87|$-~~[57..64]&&($.*=-1);$o[$p]+=$.,$o[$p+1]-=$.}$%=($%=$a[$q]/8)>$-?$-:$%,$o[$a[$q++]&7]+=$%while($--=$%);$,=$";say@o

नोट: इस पोस्ट के नीचे एक हेक्स डंप दिया गया है, क्योंकि कुछ स्ट्रिंग शाब्दिकों में नियंत्रण वर्ण होते हैं (जो एक हेक्स संपादक के माध्यम से दर्ज किए गए थे)।

टिप्पणियों के साथ अपुष्ट: 

$_=<>;
# For each byte, the first 5 bits are the number of spaces to fill at a time, the next 3 bits represent the shell number, minus 1.
# Values: 10 41 42 13 52 33 14 53 34 15 73 54 35 16 74 55 36
# The 1st shell takes 2 electrons
# Then the 2nd shell take 8, then the third takes 8...
@a=unpack'C*','ABR3S4sT5tU6';
# Contains the atomic numbers of abnormal elements
# Values: 18 1d 29 2a 2c 2d 2e 2f 39 3a 40 4e 4f 59 5a 5b 5c 5d 60 67
@b=unpack'C*',')*,-./9:@NOYZ[\]`g';
# if abnormal
if($_~~@b){
    # All abnormals, except element 46 and 90, only displace 1 electron
    $y=1+($_~~[46,90]);
    # Abnormals with atomic number less than 33 involve switches between shells 3 and 4
    # 33-65: 4 and 5
    # 66-98: 5 and 6
    # 99+ : 6 and 7
    $p = (3 + ~~($_/33)) - 1;
    # abnormals in these ranges move electrons from lower to higher
    # abnormals elsewhere do higher to lower
    if($_ >= 88 || $_ ~~ [57..64]){
        $y *= -1;
    }
    # move electrons
    $o[$p] += $y;
    $o[$p+1] -= $y;
}

    # extract max number of electrons to fill shell with
    # >> 3 is equivalent to /8 for integers; $% is always an integer.
    $% = $a[$q] / 8,
    # do not overfill
    $% = $% > $_ ? $_ : $%,
    # add electrons to shell
    $o[ $a[$q++] & 7 ] += $%
# reduce number of electrons left to fill shells with
while($_ -= $%);
# set list separator to space
$, = $";
# print list representing shells
say @o

हेक्स डंप:

0000000: 4061 3d75 6e70 6163 6b27 432a 272c 2710  @a=unpack'C*','.
0000010: 4142 1352 3314 5334 1573 5435 1674 5536  AB.R3.S4.sT5.tU6
0000020: 273b 6966 2828 242d 3d3c 3e29 7e7e 5b75  ';if(($-=<>)~~[u
0000030: 6e70 6163 6b27 432a 272c 2718 1d29 2a2c  npack'C*','..)*,
0000040: 2d2e 2f39 3a40 4e4f 595a 5b5c 5d60 6727  -./9:@NOYZ[\]`g'
0000050: 5d29 7b24 2e2b 3d28 242d 7e7e 5b34 362c  ]){$.+=($-~~[46,
0000060: 3930 5d29 3b24 703d 322b 242d 2f33 333b  90]);$p=2+$-/33;
0000070: 242d 3e38 377c 242d 7e7e 5b35 372e 2e36  $->87|$-~~[57..6
0000080: 345d 2626 2824 2e2a 3d2d 3129 3b24 6f5b  4]&&($.*=-1);$o[
0000090: 2470 5d2b 3d24 2e2c 246f 5b24 702b 315d  $p]+=$.,$o[$p+1]
00000a0: 2d3d 242e 7d24 253d 2824 253d 2461 5b24  -=$.}$%=($%=$a[$
00000b0: 715d 2f38 293e 242d 3f24 2d3a 2425 2c24  q]/8)>$-?$-:$%,$
00000c0: 6f5b 2461 5b24 712b 2b5d 2637 5d2b 3d24  o[$a[$q++]&7]+=$
00000d0: 2577 6869 6c65 2824 2d2d 3d24 2529 3b24  %while($--=$%);$
00000e0: 2c3d 2422 3b73 6179 406f                 ,=$";say@o
— es1024
स्रोत
मैं हेक्सडंप कैसे उलट सकता हूं? (यह संभव है कि या तो एक प्रतिवर्ती xxd डंप या एक बेस 64 करें)
@professorfish प्रतिवर्ती xxd डंप जोड़ा गया
— es1024
2

सीजेएम, 309 289 बाइट्स

0000000: 22 cc b5 a3 1a f7 bd 07 1b 26 ce 73 16 55 87 08  "........&.s.U..
0000010: 27 d2 65 54 66 ac c1 38 ff de 95 d8 8a 77 6d 4e  '.eTf..8.....wmN
0000020: 0d 13 df bb b7 c6 8c ae 6b 32 4d b9 f1 7c b9 f1  ........k2M..|..
0000030: bc 68 2d 8a 5c 22 e6 5c 22 e1 d7 c9 80 ba a5 5d  .h-.\".\"......]
0000040: 64 24 47 0b aa 78 c9 13 a5 0a 65 41 08 f3 ee e3  d$G..x....eA....
0000050: 2e 58 92 19 5f 1a 80 fc d9 30 3b 51 99 c7 1b 51  .X.._....0;Q...Q
0000060: ba 0c 8a 3c 7d f0 60 1e d5 1c e7 2f 33 16 c8 1f  ...<}.`..../3...
0000070: e6 df 24 75 d1 51 e6 af 38 b4 f7 b1 63 77 14 8d  ..$u.Q..8...cw..
0000080: d3 69 bc 99 9e a5 98 56 53 e7 71 f7 48 76 7a 24  .i.....VS.q.Hvz$
0000090: a7 dc 5c 22 fc a6 55 05 30 e2 03 d6 a8 ef 1a 9f  ..\"..U.0.......
00000a0: e4 03 c6 a0 5e 60 be 01 2b ca 12 83 d4 64 69 3d  ....^`..+....di=
00000b0: a7 2e cc 59 5e 0c bb 69 b0 19 1d e1 f2 53 e4 1b  ...Y^..i.....S..
00000c0: 6e 6d cc 45 d3 1f cc 3c b7 1b 5f ca c8 d0 94 fe  nm.E...<.._.....
00000d0: 05 ea ae dc 98 9e 9a 47 a6 fa 3a 0e c3 45 ef 31  .......G..:..E.1
00000e0: 61 a0 7c 80 55 9a 5d 7a af 8e 51 e8 5c 79 c4 22  a.|.U.]z..Q.\y."
00000f0: 32 35 36 62 33 38 62 22 24 12 23 20 5c 22 12 21  256b38b"$.# \".!
0000100: 08 00 02 22 3a 69 32 2f 7b 5f 30 3d 5f 29 33 33  ...":i2/{_0=_)33
0000110: 3f 61 40 5c 2f 5c 2a 7d 2f 30 61 2f 6c 69 28 3d  ?a@\/\*}/0a/li(=
0000120: 60                                               <

2 8 18 3232 से अधिक पूर्णांकों के साथ सामान्य रन (जैसे ) के स्थान पर काम करता है और सभी विन्यासों के आधार पर एक आधार संख्या 38 पर विचार करता है, जो बाइनरी में एन्कोडेड है।

उदाहरण चलाते हैं

$ base64 -d > electrons.cjam <<< Isy1oxr3vQcbJs5zFlWHCCfSZVRmrME4/96V2Ip3bU4NE9+7t8aMrmsyTbnxfLnxvGgtilwi5lwi4dfJgLqlXWQkRwuqeMkTpQplQQjz7uMuWJIZXxqA/NkwO1GZxxtRugyKPH3wYB7VHOcvMxbIH+bfJHXRUeavOLT3sWN3FI3TabyZnqWYVlPncfdIdnokp9xcIvymVQUw4gPWqO8an+QDxqBeYL4BK8oSg9RkaT2nLsxZXgy7abAZHeHyU+Qbbm3MRdMfzDy3G1/KyNCU/gXqrtyYnppHpvo6DsNF7zFhoHyAVZpdeq+OUehcecQiMjU2YjM4YiIkEiMgXCISIQgAAiI6aTIve18wPV8pMzM/YUBcL1wqfS8wYS9saSg9YA==
$ cksum electrons.cjam 
3109698089 289 electrons.cjam
$ LANG=en_US cjam electrons.cjam <<< 42; echo
[2 8 18 13 1]
$ for i in {1..118}; do LANG=en_US cjam electrons.cjam <<< $i; echo; done | md5sum
d09cb34c282ee52c2466a6b80aa30d22  -
— डेनिस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.