Elektronenkonfigurationen

18

Elektronenkonfigurationen

Ihre Mission ist es, die Ordnungszahl eines Elements als Eingabe zu akzeptieren und seine Elektronenkonfiguration (z 2,8,8,2. B. für Calcium) auszugeben .

Eingang

Eine Ordnungszahl von 1 bis 118. Sie können eine gültige Eingabe annehmen. Das Atom ist nicht geladen (es hat so viele Elektronen wie Protonen). Sie können nicht erwarten, dass die Eingabe in einer Variablen gespeichert wird, und Sie müssen ein vollständiges Programm schreiben.

Ausgabe

Die Anzahl der Elektronen in jeder nicht leeren Elektronenhülle. Ich werde mit dem Ausgabeformat ziemlich nachsichtig sein; Alle der folgenden Angaben sind zulässig, dh Sie können zur Trennung der Zahlen Interpunktions- oder Leerzeichen verwenden. Klammern jeglicher Art sind zulässig. Bitte geben Sie an, welche verwendet wird.

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

Wie Elektronen arbeiten

In Atomen werden Elektronen in "Schalen" geordnet, die Energieniveaus sind. Jede Schale hat eine bestimmte Kapazität, die maximale Anzahl von Elektronen, die sie aufnehmen kann. Die Schalen sind von innen nach außen gefüllt, aber nicht gleichmäßig. Ihre Aufgabe ist es, anhand einer Ordnungszahl zu bestimmen, wie viele Elektronen sich nach dieser Quelle in jeder Schale befinden .

Bis einschließlich Kalzium (Ordnungszahl 20) füllen sich die Schalen gleichmäßig und in der richtigen Reihenfolge. Die innere Hülle wird zuerst mit 2 gefüllt, die zweite mit 8, dann die dritte mit 8 und die letzte mit 2. Die Elektronenkonfiguration von Calcium ist 2,8,8,2.

Nach Kalzium werden die Dinge kompliziert; weitere Elektronen gehen in die dritte Schale, nicht die letzte. Zu allem Überfluss ist Vanadium (23) 2,8,11,2, Chrom (24) 2,8,13,1und Mangan (25) 2,8,13,2.

Es gibt jedoch einige konsistente Muster: Bei einem Edelgas und den sieben Elementen davor steigt die Anzahl der Elektronen in der Außenhülle immer von 1 auf 8. Zum Beispiel:

  • Gold (79): 2,8,18,32,18,1
  • Quecksilber (80): 2,8,18,32,18,2
  • ...
  • Astat (85): 2,8,18,32,18,7
  • Radon (86): 2,8,18,32,18,8

Regeln

  • Standardlücken sind verboten.
  • Bibliotheken, die vor dieser Herausforderung existierten, sind zulässig.
  • Alle eingebauten oder Bibliotheksfunktionen, die sich speziell mit Atomen, Molekülen oder Chemie befassen, sind verboten.
  • Die niedrigste Codelänge in Bytes gewinnt.
  • In der verknüpften Quelle sind die Konfigurationen der Elemente 103 - 118 wie vorhergesagt mit (?) Markiert , und die Elemente sind zu instabil, um dies zu überprüfen. Nehmen Sie für diese Herausforderung an, dass sie korrekt sind.
  • Sie können einen Teil oder alle Ihre Daten fest codieren.
  • [NEUE REGEL] Bitte geben Sie einen base64- oder einen xxd-Speicherauszug Ihrer Dateien an, wenn Sie darin Steuerzeichen verwenden (so viele Antworten wie möglich scheinen).

GEWINNER: Dennis 'CJam-Antwort mit 80 Bytes !

Gemeinschaft
quelle

Antworten:

14

CJam, 87 83 82 80 Bytes

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

Der obige Code enthält nicht druckbare Zeichen.

Probieren Sie es online im CJam-Interpreter aus . Wenn der Link für Sie nicht funktioniert, kopieren Sie ihn aus dieser Paste .

Hintergrund

Um die Elektronenkonfiguration des N-ten Atoms zu erhalten, beginnen wir mit einem Atom ohne Elektronen und wenden N- Transformationen darauf an.

Um die Byteanzahl der Implementierung zu reduzieren, stellen wir die Elektronenkonfiguration eines Atoms als ganze Zahl dar. Jede Ziffer dieser ganzen Zahl in der Basis 33 entspricht der Anzahl der Elektronen in einer bestimmten Schale; Die niedrigstwertige Ziffer steht für die äußere Hülle.

Zum Beispiel ist die Elektronenkonfiguration von Molybdän (42) [2 8 18 13 1] . Dies entspricht der ganzen Zahl 2 × 33 4 + 8 × 33 3 + 18 × 33 2 + 13 × 33 + 1 = 26,79,370 .

Palladium (48) ist ein Sonderfall, den wir als [2 8 18 18 0] anstelle von [2 8 18 18] behandeln .

Diese bequeme Darstellung reduziert die oben erwähnten Transformationen auf einfache Arithmetik:

  • R += 1 (füge ein Elektron zur äußeren Hülle hinzu)
  • R += 33 (füge ein Elektron zur zweiten äußeren Hülle hinzu)
  • R += 65 (füge zwei Elektronen zur zweiten äußeren Hülle hinzu; entferne eines von der ersten)
  • R += 1089 (füge ein Elektron zur dritten äußeren Hülle hinzu)
  • R += 2145 (Addiere zwei Elektronen zu der dritten äußeren Hülle; entferne eines von der zweiten)
  • R *= 33, R += 1 (füge eine neue Hülle hinzu, die ein einzelnes Elektron enthält)

Alles, was übrig bleibt, ist, irgendwie zu kodieren, welche Transformation angewendet werden muss, um von einem bestimmten Atom zum nächsten zu gelangen. Die Unterschiede der ganzzahligen Darstellungen zweier aufeinanderfolgender Atome sind wie folgt:

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

Die einzigartigen Unterschiede in diesem Array sind die folgenden:

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

Alle bis auf die ersten 5 entsprechen Instanzen, in denen eine neue Shell hinzugefügt wird. Diese können weggelassen werden, da das Multiplizieren mit 33 und Addieren von 1 dasselbe Ergebnis wie das Addieren der Differenz ergibt.

Da wir nur dann eine neue Hülle hinzufügen müssen, wenn das aktuelle Atom genau acht Elektronen in seiner äußeren Hülle hat (mit Ausnahme von He (2) ↦ Li (3) , das als add 65 kodiert werden kann ), können wir kodieren Diese Transformationen addieren sich zu 1 und bestimmen die Notwendigkeit einer spontanen Multiplikation.

Also, wenn wir definieren

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]

Die Elektronenkonfiguration des N-ten Atoms kann wie folgt berechnet werden:

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

Wie es funktioniert

" 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-`

Beispiellauf

$ 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]
Dennis
quelle
1
Eine Gegenstimme für die enorme Anstrengung, Sir. ;)
COTO
6

GolfScript (96 Bytes)

Die Ausgabe erfolgt in der Form

[2 8 18 18]

Hierfür wird eine magische Zeichenfolge verwendet, die nicht druckbare Zeichen enthält. Daher gebe ich das Skript im xxd-Format aus:

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  [email protected]...'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/=~}/]`

Zum Online-Testen schreibe ich die magische Zeichenfolge mit Escapezeichen:

"\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"

Dies ist jedoch äquivalent, wenn Sie keine Probleme beim Einfügen von Zeichen in Browsertextbereiche haben.

Der Ansatz besteht darin, eine virtuelle Maschine mit 7 Befehlen zu erstellen, von denen jeder eine Liste von Elektronenzahlen manipuliert. Dann nbeginnen wir für das Element mit einer Elektronenzählungsliste von 0und führen die ersten nAnweisungen aus der Liste aus, die von der magischen Kette codiert wird.

Die Anweisungen sind:

  1. Füge eine neue Schale mit 1 Elektron hinzu: 1
  2. Füge ein Elektron zur äußeren Hülle hinzu: )
  3. Füge ein Elektron zur nächstäußeren Schale hinzu: \)\
  4. Kombinieren Sie die beiden äußeren Schalen und fügen Sie ein Elektron: +). (Dies wird nur für Palladium verwendet).
  5. Kombiniere die beiden äußeren Hüllen und erstelle eine neue Hülle mit 1 Elektron: +1
  6. Addiere ein Elektron zur dritten Schale in: @)@@
  7. Fügen Sie der dritten Schale ein Elektron hinzu und bewegen Sie eines von der zweiten zur dritten Schale. Dies tritt nur auf, wenn die äußere Hülle 2 Elektronen hat, so dass sie @+\(2eher als die längere ausgeführt wird@2+@(@
Peter Taylor
quelle
Was sind deine 7 Anweisungen?
COTO
Ah. Vielen Dank. Ich denke, ich muss eine dieser esoterischen Golfsprachen lernen, um eines Tages eine Golfherausforderung zu gewinnen. Ich hatte verdammt viel Zeit damit, kompakten Code zu schreiben, der zwei Anweisungen interpretieren konnte, geschweige denn sieben. : P
COTO
Mache ich Eingaben zu STDIN? (und dann erscheint es auf dem Stapel)?
@professorfish: Ja. GolfScript legt die Eingabe von STDIN automatisch auf dem Stapel ab.
Dennis
5

Python 2 (46 + 271 = 327)

Code:

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

Datei f, die den folgenden binären Müll enthält (das sind die Zeichencodes)

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

Auf Anfrage ist dies nun ein vollständiges Programm und keine Funktion.

Alte Antwort: Python (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]

Inhalt der Zip:

>>>'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

Und ein kurzer Test:

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
quelle
Dies ist gut, aber bitte machen Sie ein vollständiges Programm (das Eingaben von stdin oder Argumenten einliest); Sie können auch eine externe Datei verwenden, um base64 zu umgehen (aber die Datei und ihr Name werden zur Codelänge
Die Antwort, auf die Sie verlinken, beginnt mit Es sei denn, die Frage ist eine offensichtliche Ausnahme (die primäre Ausnahme ist die mit kolmogorov-complexität gekennzeichnete) , was hier der Fall ist. Die ganze Idee von Kolmogorov-Komplexitätsfragen besteht darin, die Ausgabe auf die effizienteste Weise fest zu codieren.
Dennis
Ich habe das Kolmogorov-Komplexitäts-Tag verpasst. Und hier versuche ich, die Energieniveaus der verschiedenen Valenzunterschalen zu entschlüsseln, und ich bin nicht einmal ein Physiker. :I
Sammitch
Die "alte Antwort" funktioniert nur in Python2. Ich habe die neue Datei nicht überprüft. Haben Sie eine Base64 der Datei, fdamit ich sie reproduzieren kann?
@professorfish Mit Sicherheit. Das neue ist auch nur Python 2 ( printals Schlüsselwort und nicht als Funktion).
ɐɔıɐɔuʇǝɥʇs
3

MATLAB - 248 244 241 178 + 44 = 222 Bytes

Minimiert:

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

Erweitert:

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

Abhängigkeit von Binärdateien (Dateiname ' 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

Ich vertraue darauf, dass dies ein "vollständiges Programm" ist, da es von der Kommandozeile aufgerufen werden kann, von der es liest stdinund an die es ausgibt stdout.

Es verwendet eine Art Bytecode mit zwei Befehlen, um die Elektronenkonfigurationen aufzubauen. Die beiden Anweisungen sind

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

und

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

Die Anweisungen sind in zwei Arrays codiert. Das erste speichert das DArgument in allen Fällen. Der zweite speichert das NArgument oder 0eine pulldownAnweisung, da N = 0es nie als Argument verwendet wird.

Die vollständige Abfolge der Anweisungen lautet:

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

Es ist erwähnenswert, dass 28 Zeichen gelöscht werden können, wenn wir den MATLAB-spezifischen Zeichensatz verwenden, aber ich wollte, dass meine Lösung in Stack Exchange als Klartext ohne externe Dateiverweise darstellbar ist.

Externe Dateiverweise sind es.

Beispielausgaben

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
quelle
Wie rekonstruiere ich die "Abhängigkeit von Binärdateien"?
Die Datei enthält die von mir aufgelisteten 44-Byte-Codes von links nach rechts und von oben nach unten in der üblichen Reihenfolge. Der Dateiname ist einfach "a" ohne Erweiterung. Es muss sich im Arbeitsverzeichnis befinden, wenn das Skript ausgeführt wird. Ich habe eine herunterladbare Kopie auf syonidv.hodginsmedia.com/misc/a
COTO hochgeladen
2

Perl 5, 235 (234 + 1 für -E)

Golf gespielt:

@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

Hinweis: Am Ende dieses Beitrags befindet sich ein Hex-Dump, da einige der String-Literale Steuerzeichen enthalten (die über einen Hex-Editor eingegeben wurden).

Ungolfed mit Kommentaren:

$_=<>;
# 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 

Hex Dump:

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
quelle
Wie kehre ich den Hexdump um? (Es ist wahrscheinlich besser, entweder einen reversiblen xxd-Dump oder einen base64 zu machen)
@professorfish reversible xxd dump hinzugefügt
es1024
2

CJam, 309 289 Bytes

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                                               <

Ersetzt gängige Läufe (z. B. 2 8 18 32) durch Ganzzahlen größer als 32 und betrachtet das Array aller Konfigurationen als Basis-38-Zahl, die binär codiert ist.

Beispiellauf

$ 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  -
Dennis
quelle