Periodensystem der Elemente - Code Golf

47

Basierend auf Practical Golf - US-Bundesstaaten

Ihre Aufgabe ist es, die Abkürzung (Symbol) eines Elements mit dem angegebenen Elementnamen bis einschließlich Ununoctium (118) zu finden. Verwenden Sie das Periodensystem auf Wikipedia .

Dank Squeamish Ossifrage finden Sie eine vollständige Liste der Elemente zu Abkürzungen unter http://pastebin.com/DNZMWmuf .

Sie dürfen keine externen Ressourcen verwenden. Darüber hinaus dürfen Sie keine eingebauten Daten speziell zu den Elementen des Periodensystems verwenden. Es gelten Standardlücken.

Eingang

Eingang kann von stdin, eine Datei sein prompt, inputusw.

Eingabeformat:

Bei allen folgenden Angaben handelt es sich um gültige Eingaben:

Carbon
carbon
CARBON
cArBOn

Im Wesentlichen wird beim Elementnamen die Groß- / Kleinschreibung nicht berücksichtigt.

Sie müssen keine Rechtschreibfehler oder ungültige Elementnamen verarbeiten. Ungültige Eingabe ist undefiniertes Verhalten.

Ausgabe :

Das Symbol für das Element. Das erste Zeichen muss aktiviert sein und der Rest muss klein geschrieben werden.

Beispielausgabe: C

Testfälle:

Carbon -> C
NiTROGen -> N
Sodium -> Na
Gold -> Au
Silver -> Ag
Tin -> Sn

Es gibt viel mehr Elemente als Staaten, daher denke ich, dass es schwieriger sein wird, eine allgemeine Regel für diese zu finden.

Das ist Code Golf. Kürzester Code gewinnt!

soktinpk
quelle
4
@squeamishossifrage Danke. Beide Versionen ("Schwefel" und "Schwefel") sind akzeptabel. Ihr Programm muss jedoch nicht beide, sondern nur einen verarbeiten.
Soktinpk
1
... unmöglich mit Regexen zu tun. Du hast uns gut gemacht.
Josiah Winslow
2
@Xrylite Versuchen Sie , die Regeln zu lesen : " Eingabe ... der Elementname - Groß- und Kleinschreibung wird nicht berücksichtigt ... Ausgabe ... Das erste Zeichen muss in Groß- und Kleinschreibung geschrieben werden".
Jim Balter
2
Was ist mit der richtigen Schreibweise (Aluminium) im Vergleich zur US-Rechtschreibung (Aluminium)?
Paul R
4
@codebreaker Ja, wenn die Eingabe nicht gültig ist, kann Ihr Programm abstürzen, hängen bleiben, drucken Auoder was immer Sie wollen. @Paul R Wenn es viele Möglichkeiten gibt, ein Element zu buchstabieren (z. B. Schwefel gegen Schwefel oder Aluminium gegen Aluminium), verwenden Sie, was auch immer Ihr Programm kürzer macht. Sie müssen nicht beide Fälle behandeln.
Soktinpk

Antworten:

27

CJam, 337 297 293 232 220 201 200 Bytes

leu:E2f^3b2+4%_"53N5903CVCT4":i3/=~Ef+b\%]53b"gØâ^ÃP·^À4ξ^ß^E5^W^Ma{áª^B¤±´oòæ»^XÊQÑ»4žDÙÝòÙ 0^ÝþKa6^Ó£,Ûkû¥¡ùh^E"256b7b6a/0a3**<)5md@5a/,(" ¬^GH/N¿·%^U^RU1²Bd
òë^м~í^ÌéáU"256b25b'Af+2/='J-'Q/"UU"*\)_5=)*E%2<?(\el

Der obige Code verwendet die Caret-Notation, da er Steuerzeichen enthält.

Auf Kosten von 24 zusätzlichen Bytes (für insgesamt 224) können diese Zeichen vermieden werden.

leu:E2f^3b2+4%_"53N5903CVCT4":i3/=~Ef+b\%]53b
"' NwEvKv6e8@]jO4G)=b{L!v@hFQ/oCN)*|BRxvNRL+LO7NI(pLs4[d87$Q%8R\t+' M5JU"
{32f-95b}:B~7b6a/0a3**<)5md@5a/,(
"&y.$h*z^t\rQPUc]l8F h$=18C^r|vD~S"
B25b'Af+2/='J-'Q/"UU"*\)_5=)*E%2<?(\el

Sie können diesen Code im CJam-Interpreter ausprobieren .

Testfälle

$ base64 -d > elements.cjam <<< bGV1OkUyZl4zYjIrNCVfIjUzTjU5MDNDVkNUNCI6aTMvPX5FZitiXCVdNTNiImfY4oNQt4A0zr6fBTUXDWF74aoCpLG0b/LmuxjKUdG7NMW+RNnd8tmgMJ3+S2E2k6Ms22v7paH5aAUiMjU2YjdiNmEvMGEzKio8KTVtZEA1YS8sKCIgrAdIL06/tyUVElUxskJkCvLrkLx+7Yzp4VUiMjU2YjI1YidBZisyLz0nSi0nUS8iVVUiKlwpXzU9KSpFJTI8PyhcZWw=
$ cksum elements.cjam 
952664534 200 elements.cjam
$ for e in Carbon NiTROGen Sodium Gold Silver Tin; do LANG=en_US cjam elements.cjam <<< $e; echo; done
C                                                                                                       
N                                                                                                       
Na                                                                                                      
Au                                                                                                      
Ag                                                                                                      
Sn

Wie es funktioniert

Der erste Schritt besteht darin, den Elementnamen aus STDIN zu lesen und eine ziemlich ausgefeilte Hash-Funktion anzuwenden, die alle Elementnamen im Bereich [0, 225] abbildet :

l eu :E          " Read a line from STDIN, convert to uppercase and save in E.            ";
2 f^             " XOR each character code with 2.                                        ";
3 b              " Convert to integer; consider the resulting array a base 3 number.      ";
2 + 4 %          " Add 2 and take the result modulo 4. Result: R                          ";
"53N5903CVCT4":i " Push [53 51 78 53 57 48 51 67 86 67 84 52].                            ";
3 / =            " Retrieve the chunk of length 3 that corresponds to R. Result: C        ";
~ E f+           " Add C[2] to all character codes of E.                                  ";
b                " Convert to integer; consider the resulting array a base C[1] number.   ";
\ %              " Take the integer modulo C[0]. Result: M                                ";
] 53 b           " Push H := 53 * R + M.                                                  ";

Viele Elementsymbole werden durch das erste und zweite, erste und dritte, erste und vierte, erste und fünfte oder erste und zehnte (nur das erste) Zeichen des englischen Namens des Elements gebildet. Wir werden diese Elemente durch Zahlen von 0 bis 4 darstellen. Alle verbleibenden Elemente (dargestellt durch 5) erfordern eine Nachschlagetabelle.

Die resultierende Tabelle kann wie folgt verschoben werden:

"gØâ^ÃP·^À4ξ^ß^E5^W^Ma{áª^B¤±´oòæ»^XÊQÑ»4žDÙÝòÙ 0^ÝþKa6^Ó£,Ûkû¥¡ùh^E"256b7b6a/0a3**

Das Array von Zeichencodes wird von der Basis 256 in die Basis 7 konvertiert, und die 6 werden durch Reihen von drei Nullen ersetzt.

Dies ist die Entscheidungstabelle D:

[4 0 0 0 1 0 0 0 0 0 0 3 0 2 0 1 0 0 0 0 0 0 0 0 4 1 1 0 0 0 0 2 0 4 0 5 2 0 0 3 4 0 0 0 0 4 0 1 0 0 3 1 0 0 2 1 1 1 0 0 0 1 0 5 5 0 0 2 0 0 0 5 5 0 0 0 5 0 3 0 0 0 0 5 0 0 0 0 0 0 0 0 5 2 3 0 1 0 5 0 4 0 0 0 0 4 0 5 0 0 0 0 0 5 0 0 0 2 5 1 4 1 5 0 0 0 5 0 0 5 1 1 0 0 0 0 0 0 2 0 5 0 0 0 3 1 0 2 0 0 0 2 0 0 0 5 0 0 0 0 1 0 0 0 0 0 4 0 2 2 5 2 0 0 5 1 0 0 0 0 4 0 5 0 0 3 5 0 0 5 0 1 0 0 0 2 0 0 0 0 0 5 0 4 0 0 0 0 0 0 0 0 3 0 4 0 0 1 2 2 0 0 0 0 0]

Die notwendige Aktion für das Element mit Hash 1 entspricht zB dem ersten Element dieses Arrays. Array-Elemente, die keinem Element-Hash entsprechen, sind ebenfalls Null, was die (0 0 0) ↦ 6- Komprimierung ermöglicht.

Nun interpretieren wir D für Hash H.

< ) 5 md     " Push D[:H-1] (D[H-1] / 5) (D[H-1] % 5).                                    ";
@ 5a / , (   " Count the number of 5's in D[:H-1] (by splitting at [5]). Result: I        ";

Als nächstes verschieben wir die Nachschlagetabelle. Wenn wir j an Einzelzeichensymbole anhängen und Uu durch Q ersetzen , ist jedes Symbol genau zwei Zeichen lang. Es kann wie folgt verschoben werden:

" ¬^GH/N¿·%^U^RU1²Bd
òë^м~í^ÌéáU"256b25b'Af+2/

Das Array von Zeichencodes wird von der Basis 256 in die Basis 25 konvertiert, der Zeichencode von A wird zu allen Ziffern hinzugefügt (dabei wird auf Zeichen gewandelt ) und das Ergebnis wird in Abschnitte der Länge zwei aufgeteilt.

Dies ist die Nachschlagetabelle L:

["QP" "YB" "PD" "SN" "QO" "QT" "QS" "SB" "KJ" "TM" "FE" "PB" "AU" "WJ" "CN" "SG" "RF" "CM" "CU" "HG" "NA" "RG" "AG"]

Nun werden mögliche Elementnamen berechnet.

=                " Push L[I].                                                             ";
'J - 'Q / "UU" * " Remove J's and replace Q's with runs of two U's.                       ";
\ ) _ 5 = ) *    " Push S := (D[H-1] % 5 + 1) * ((D[H-1] % 5 + 1 == 5) + 1).              ";
E %              " Push every Sth character of E.                                         ";
2 <              " Discard all but the first two characters.                              ";

Der Stapel enthält jetzt

B M N

wobei B der Boolesche Wert D [H-1] / 5 ist , M der aus der Nachschlagetabelle abgerufene Name ist und N der Elementname ist, der durch Auswahl von Zeichen aus E gebildet wird.

Wir sind fast fertig:

?                " If B, push M; else, push N.                                            ";
( \              " Extract the first character from the string.                           ";
el               " Convert the rest to lowercase.                                         ";
Dennis
quelle
Aber wie geht das?
Claudiu
2
@Claudiu: Ich habe eine Erklärung hinzugefügt.
Dennis
3
Ich habe das erste Drittel der Erklärung gelesen und bisher habe ich "Magic". Unglaublich
Mooing Duck
7
"AcAlAmSbArAsAtBaBkBeBiBhBBrCdCsCaCfCCeClCrCoCnCuCmDsDbDyEsErEuFmFlFFrGdGaGeAuHf HsHeHoHInIIrFeKrLaLrPbLiLvLuMgMnMtMdHgMoNdNeNpNiNbNNoOsOPdPPtPuPoKPrPmPaRaRnReRh RgRbRuRfSmScSgSeSiAgNaSrSTaTcTeTbTlThTmSnTiWUuoUupUusUutUVXeYbYZnZr" = 226 Zeichen. Ihre Lösung = 200 Zeichen. Hier ist ordentliches Voodoo los.
Squeamish Ossifrage
Ich habe diese Antwort akzeptiert, da sie anscheinend die kürzeste ist. Sie können jedoch weitere Antworten veröffentlichen.
Soktinpk
43

C 452

Eine gute Hash-Funktion hilft. Es kann bessere geben. (Verbesserungen vorgeschlagen von @ugoren et al.)

h;main(c){char*p="Sn)Cu&V$U#Mo#Rf#Sg&Cs#Y+FTa%Rb)S'Nd#GaK&Mg'Zr$PtPm%ReUuo#SmDy(Ac$Lu%W&CaRa(Cf)EuB#Ds%Md$Uus*NpIn$H&YbIr*BeEs*Tc#I(FlRuC#ThSrBh/NaCoLrKr&Nb$CePb$Ne'Am)At*PdLa#Tl%HgMt,CrTbBk$Rh&Rn4TeZn$HfAg%Fm)Xe$AlScFePo$As'HeO#LvN&DbGe#Ho&Mn$Cd+Ni$Rg$HsBr$AuSi#Pr&Uup#Se*Ti#Tm$Er$Sb&PPu&Cm$GdBa'Cn&UutLiFr#Ar#Bi#NoOs%Pa4Cl";while((c=getchar())>64)h=(h+c%32+74)*311%441;while(h)if(*p<65?h-=*p++-34,0:1)for(h--;*++p>96;);do putchar(*p++);while(*p>96);}

Ungolfed mit Kommentaren:

int h;
main(c) {

  /* Hashed element symbols. Characters #$% etc. are used as padding: */
  char *p="Sn)Cu&V$U#Mo#Rf#Sg&Cs#Y+FTa%Rb)S'Nd#GaK&Mg'Zr$PtPm%ReUuo#SmDy(Ac$Lu%W&C"
          "aRa(Cf)EuB#Ds%Md$Uus*NpIn$H&YbIr*BeEs*Tc#I(FlRuC#ThSrBh/NaCoLrKr&Nb$CeP"
          "b$Ne'Am)At*PdLa#Tl%HgMt,CrTbBk$Rh&Rn4TeZn$HfAg%Fm)Xe$AlScFePo$As'HeO#Lv"
          "N&DbGe#Ho&Mn$Cd+Ni$Rg$HsBr$AuSi#Pr&Uup#Se*Ti#Tm$Er$Sb&PPu&Cm$GdBa'Cn&Uu"
          "tLiFr#Ar#Bi#NoOs%Pa4Cl";

  /* This hash function gives a unique result for each element: */
  while((c=getchar())>64) h=(h+c%32+74)*311%441;

  /* Find the corresponding position in the hashed data */
  while(h) {
    if(*p<65?h-=*p++-34,0:1) {      /* Step over an abbreviation */
      for(h--;*++p>96;);            /* Skip padding */
    }
  }

  /* Output first uppercase character and all following lowercase characters: */
  do {
    putchar(*p++);
  } while(*p>96);
}

Ich habe rohe Gewalt angewendet, um diesen Hash zu finden. Dies war die einzige mit einer Hash-Größe von ≤512, die keine Kollisionen aufwies. Ich habe jedoch keine alternativen Schreibweisen überprüft, und es gibt möglicherweise bessere Funktionen mit unterschiedlichen Algorithmen (z. B. Verwendung von XOR anstelle von Addition).

Die Hash-Funktion ordnet Textzeichenfolgen Werten von 0 bis 440 zu. "Tin" hascht auf Null, sodass "Sn" am Anfang der Tabelle steht. Die nächsten 7 Positionen sind leer. Um den Code kompakt zu halten, wird dies durch den ASCII-Wert 34 + 7 = 41 (")") angezeigt. Als nächstes folgen "Kupfer" (8), vier leere Zellen (34 + 4 = 38 = "&") und "Vanadium" (13). Nach der Berechnung eines Hashs durchläuft das Programm die Tabelle, subtrahiert 1 für jeden Großbuchstaben, gefolgt von 0 oder mehr Kleinbuchstaben, und subtrahiert (ASCII-WERT) -34 für jedes Nicht-Alphabet-Zeichen. Wenn der Wert Null erreicht, haben wir das richtige Ergebnis gefunden.

zimperliches Ossifrage
quelle
3
@soktinpk Brute hat es erzwungen :-) Dies war der einzige mit einer Hash-Größe von ≤512, der keine Kollisionen hatte. Ich habe jedoch keine alternativen Schreibweisen überprüft, und es gibt möglicherweise bessere Funktionen mit unterschiedlichen Algorithmen (z. B. Verwendung von XOR anstelle von Addition).
Squeamish Ossifrage
2
Stellen Sie sicher, dass 464 ... Sie ein unnötiges Paar Zahnspangen haben.
Jim Balter
1
Wenn Sie an die Grammatik denken, ist sie eindeutig und muss erlaubt sein ... sie sieht für uns nur mehrdeutig aus . Oh, und du hast noch einen gefangen, den ich nicht habe! Herzlichen Glückwunsch dazu ... Ich habe mich sehr bemüht, den Algorithmus zu verfeinern, aber Sie haben alles richtig gemacht.
Jim Balter
5
@Harshdeep - Die Hash-Funktion ordnet Textzeichenfolgen Werten von 0 bis 440 zu. "Tin" hasht auf Null, sodass "Sn" am Anfang der Tabelle steht. Die nächsten 7 Positionen sind leer. Um den Code kompakt zu halten, wird dies durch den ASCII-Wert 34 + 7 = 41 (")") angezeigt. Als nächstes folgen "Kupfer" (8), vier leere Zellen (34 + 4 = 38 = "&") und "Vanadium" (13). Nach der Berechnung eines Hashs durchläuft das Programm die Tabelle, subtrahiert 1 für jeden Großbuchstaben, gefolgt von 0 oder mehr Kleinbuchstaben, und subtrahiert (ASCII-WERT) -34 für jedes Nicht-Alphabet-Zeichen. Wenn der Wert Null erreicht, haben wir das richtige Ergebnis gefunden.
Squeamish Ossifrage
2
Schön. Speichern Sie einige Zeichen mit: 1. (h+c%32+74)*311%441. 2. Tropfen pund verwenden s. 3. main(c)speichert ein Komma.
Ugoren
13

JavaScript ES6, 690 708 Bytes

for(n=prompt()[l='toLowerCase'](i=0);!(c='HHeLiBeBCNFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnUutFlUupLvUusUuo'.match(x=/[A-Z][a-z]*/g)['HyHeLitBeryBorCarNitFluNeonSoMagAlSiliPhSuChlArgPotCalcScTitVChrManIroCobNicCoppZinGalGeArsSelBrKRubStYttrZirNioMoTecRuthenRhoPaSilvCadInTinAnTelIoXCaeBaLanCePraNeodPromSaEuGadTerDyHoErThuYtteLuHafTaTuRheOsIriPlaGoMerThaLeBiPolAsRadoFrRadiAcThoProtUrNepPluAmCuBerkCaliEiFeMenNoLawRutherDuSeaBohHasMeiDaRoCopeUnuntFleUnunpLivUnunsUnuno'.match(x).map(a=>a[l]()).indexOf(n.slice(0,i++))]);)
alert(c)

Das erste Array enthält die Symbole, und das zweite Array enthält die Mindestbuchstaben, die erforderlich sind, um anzugeben, auf welches Element verwiesen wird. Vielen Dank an core1024 und edc65 für die Hilfe bei der Verkürzung. Test unter http://jsfiddle.net/xjdev4m6/2/ . Etwas besser lesbar:

n=prompt().toLowerCase()
e='HyHeLitBeryBorCarNitFluNeonSoMagAlSiliPhSuChlArgPotCalcScTitVChrManIroCobNicCoppZinGalGeArsSelBrKRubStYttrZirNioMoTecRuthenRhoPaSilvCadInTinAnTelIoXCaeBaLanCePraNeodPromSaEuGadTerDyHoErThuYtteLuHafTaTuRheOsIriPlaGoMerThaLeBiPolAsRadoFrRadiAcThoProtUrNepPluAmCuBerkCaliEiFeMenNoLawRutherDuSeaBohHasMeiDaRoCopeUnuntFleUnunpLivUnunsUnuno'.match(x=/[A-Z][a-z]*/g).map(a=>a.toLowerCase())
s='HHeLiBeBCNFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnUutFlUupLvUusUuo'.match(x)
for(i=0;i<7;i++){
  if(c=s[e.indexOf(n.slice(0,i))]){
    alert(c,i=8) // i=8 breaks out of the loop so the result is only alerted once
  }
}
NinjaBearMonkey
quelle
Können Sie einige Bytes reduzieren, indem Sie die Tatsache verwenden, dass Neo mit Neodym übereinstimmt, da Neon in der Liste übergeben wurde?
Dancrumb
1
@Dancrumb Leider nicht. Die Schleife beginnt mit der kürzesten Teilzeichenfolge. Sie trifft also, Neobevor sie trifft, Neonweil sie weniger Buchstaben enthält.
NinjaBearMonkey
1
+1 für die kürzeste JS bis jetzt. Obwohl Sie diese ifAnweisung loswerden können (es ist eine perfekte forBedingung) und auch die Positionen einiger Variablen inline oder verschieben können, um den Code zu verkürzen;)
core1024
2
am ).toLowerCase()[L='toLowerCase'](a.toLowerCase(a[L](
anfang
10

Ruby 1.9+, 565 471 447 444

Ein Einzeiler. Weil nichts "unmöglich ist, mit regulären Ausdrücken zu tun" ...
(Nur 94 Zeichen durch Hinzufügen eines weiteren regulären Ausdrucks gespeichert) ((und 24 durch Vereinfachung))

p"VAlAmA.sArAcAnt|SbA.tBaB..kBeBiB.hBrBDyD.+sD.bE..sErEuF..mFrFlu|[email protected]|AuH.fH.sHeHoHInIro|FeIrIKrL.vL.+rLaLiLuL|PbM.gMoM.+dM.nM.+tM|HgC.+sC.dC.+fCeCar|[email protected]|CmCop|CuCoC.rC.lN.+dN.+pNeN..bNit|[email protected]|PdP...aPrP.uP..tPot|KPoPR.*n$RaR.+gR.eRhR.+bR.+fRuS.mScS.+gSeS..v|AgSiSo|NaS.rSTaT.cT.+bTeThu|TmT..lThTin|SnTiTu|WU.u.oU.u.pU.u.sU.u.tUXeY.+bYZ.nZ.r"
.split(/(?<!\|)(?=[A-Z])/).find{|r|/^#{r}/i.match *$*}.gsub /.*\||\W/,''

(Neue Zeile nach der Zeichenfolge für "Lesbarkeit" hinzugefügt, zum Testen entfernen)

Verwendung: ruby periodic.rb aluminum$>

Erläuterung: Durch
Aufteilen der Zeichenfolge auf führende Großbuchstaben wird ein Regex-Array zurückgegeben, das mit Elementnamen übereinstimmt. Zulässig sind jeweils nur die Buchstaben aus der Abkürzung *. Sie sind so angeordnet, dass die erste Übereinstimmung, die beim Vergleich mit dem Befehlszeilenargument gefunden *$*wird, die richtige ist. Das nachfolgende gsub entfernt die Nicht-Alpha-Zeichen vor dem Drucken.

* Ungerade Abkürzungen wie "Fe" für "Iron" werden von einem |Element behandelt: "Iro | Fe". Die erste Wahl ist, was wirklich zusammengebracht wird; Das Gsub entfernt dann alle Zeichen bis zum '|', wobei die eigentliche Abkürzung erhalten bleibt.

Testframework (erfordert die Liste von @ squeamish: heruntergeladen als 'table.txt' im Arbeitsverzeichnis).

def testfunc(name) 
  #replace with however you call your code
  return `ruby1.9.3 periodic2.rb #{name}`.chomp()
end

elements= File.new('table.txt').readlines.map{|s|s.chomp}

elements.each{|l|
  a,n=l.split(' ')
  r = testfunc(n)
  print "#{n} => #{a} "
  if r!=a then
    print ("FAIL: gave #{r}\n")
    exit
  else 
    print("\tOK\n")
  end
}
print("PASS: #{elements.size} elements matched\n")
Ahelly
quelle
1
Standing Ovation, wenn es für alle über 100 Fälle
funktioniert
Natürlich funktioniert es: ideone.com/7FZlAt
AShelly
Man hat die Kühnheit zu behaupten, dass man mit Regex nichts anfangen kann. Vielen Dank für den Beweis, dass sie (einer sagte, viele dachten) falsch sind :)
Mast
4

Ruby, 1068 Bytes

require"zlib"
require"base64"
$><<eval(Zlib::Inflate.inflate(Base64.decode64"eJwlU8tu2zAQ/Bee+QW6CLYTx0FiR7CdtsmNkmhJCEUKfKQViv57Z9YnE+vd2ZnZ0d+1j2Go6oO2bipzpQ5W6SmPU6nU66S0jatzldqiGmLwVb3VJrZ87NAmoyf9Zx0sKm/alRCnqt5riw514lAvqCejtBm8TZU6Dgp984SGjcMuN3WhUhfsGkNaxqpudHG3Eqv6okdHPLVDXxwIuYmAzCalqn7RxnWkuQN2Z3yPxktH8sbjeQWg8QbV+oceY5iJE1kbDICOHpBE3JNka1zG3wHT3ZeF3hOmw7LYiGpB1XeV+sSIcY4rnwydmQn0hPmYLFduEqpOnhdWg4jcYmlclwyRL3iWdiLTc6s07PNYe0E15wjc+kNPsSOrT9Sm0HLXCZ3BrW0P0iBou9FbyIPSkkfYrs6F1vXsPY9C0aC36entNxVs4LjpZ/EKVX8/ybOnLqzHr8/TzCO0FODgvbreb4dV9bO2npx+oWSTzO6g1ER5bnlZn0eDvIgr9wbqN8kCtIEUG/qVKejFFQvRzYyx2fC6FzxLDAuej4VMg8PzqSeYOHAFrTUtEWAPK80QKQeYwf+B+4gVY5HLXGeaicFKfbS0yGaAvRL35mXsJnwNjnwF3+KHlKv6p4aV4iCIp1lQ3yAyTuLrMxY4k2lXk8kABm8KCXY06wCDR0YDmIiqFf+xfUpzgdYtw+QCc9GAdMqGnDZZtPKAzKLxHYp7JvR+nzNjjZVs7XjhKPpGWpgN8tgYGWNu3rVdcuEnt/DjykRtwG/GOdC5EYfvh5nJWjK+/WJYphts3d2YhZQRrMck0eauPXt9z95jz6/EUuEJEszvyOS9xnsIYcH5xmiLhQ9MkWkDqhcYE0YhvmU0U5ITcMWUGeMjTYgzTqAeUA3W5wFgHMPHhxU7prP4DLD3gmZnY/gGNSflxbIMzROCDnWv31JOUk7yDh3fQf37D7D/kWs="))[gets.downcase[1..5].to_sym]

Eingabe über STDIN.

Die kürzesten eindeutigen Teilzeichenfolgen der Elementnamen sind das zweite bis sechste Zeichen (oder das Ende des Namens, wenn es zu kurz ist). Also hole ich diese einfach und suche sie in einem Hash nach. Ich habe den Hash auch komprimiert, weil das weitere 200 Bytes spart. So sieht der Hash selbst aus:

{ydrog:?H,elium:"He",ithiu:"Li",eryll:"Be",oron:?B,arbon:?C,itrog:?N,xygen:?O,luori:?F,eon:"Ne",
 odium:"Na",agnes:"Mg",lumin:"Al",ilico:"Si",hosph:?P,ulfur:?S,hlori:"Cl",rgon:"Ar",otass:?K,
 alciu:"Ca",candi:"Sc",itani:"Ti",anadi:?V,hromi:"Cr",angan:"Mn",ron:"Fe",obalt:"Co",ickel:"Ni",
 opper:"Cu",inc:"Zn",alliu:"Ga",erman:"Ge",rseni:"As",eleni:"Se",romin:"Br",rypto:"Kr",ubidi:"Rb",
 tront:"Sr",ttriu:?Y,ircon:"Zr",iobiu:"Nb",olybd:"Mo",echne:"Tc",uthen:"Ru",hodiu:"Rh",allad:"Pd",
 ilver:"Ag",admiu:"Cd",ndium:"In",in:"Sn",ntimo:"Sb",ellur:"Te",odine:?I,enon:"Xe",esium:"Cs",
 arium:"Ba",antha:"La",erium:"Ce",raseo:"Pr",eodym:"Nd",romet:"Pm",amari:"Sm",uropi:"Eu",
 adoli:"Gd",erbiu:"Tb",yspro:"Dy",olmiu:"Ho",rbium:"Er",huliu:"Tm",tterb:"Yb",uteti:"Lu",
 afniu:"Hf",antal:"Ta",ungst:?W,heniu:"Re",smium:"Os",ridiu:"Ir",latin:"Pt",old:"Au",ercur:"Hg",
 halli:"Tl",ead:"Pb",ismut:"Bi",oloni:"Po",stati:"At",adon:"Rn",ranci:"Fr",adium:"Ra",ctini:"Ac",
 horiu:"Th",rotac:"Pa",raniu:?U,eptun:"Np",luton:"Pu",meric:"Am",urium:"Cm",erkel:"Bk",alifo:"Cf",
 inste:"Es",ermiu:"Fm",endel:"Md",obeli:"No",awren:"Lr",uther:"Rf",ubniu:"Db",eabor:"Sg",
 ohriu:"Bh",assiu:"Hs",eitne:"Mt",armst:"Ds",oentg:"Rg",opern:"Cn",nuntr:"Uut",lerov:"Fl",
 nunpe:"Uup",iverm:"Lv",nunse:"Uus",nunoc:"Uuo"}
Martin Ender
quelle
3

CJam, 462 449 434 401 391 384 382

Mit Hilfe von Dennis.

Code

Geschachtelte ternäre ifs sind wahrscheinlich nicht der richtige Weg, um dies in CJam zu tun.

rel_"ruthen"#!"Ru"{_"tel"#!"Te"{__5{\_ceu\@=+_}:U~"PdYbRgCmCn"{\#)!}:X~{;__4U"RnPaCfDs"X{;_3U"NbCsNdPmTbPtTlBkEsFmMdLrMt"X{;2U"MgClCrMnZnAsRbSrZrTcCdSmGdHfReAtNpPuDbBhHsLv"X{;__"sili"#{;__ceu\1=@2=++"SodIroCopSilTinAntThuGolMerLeaTunPotRutSeaHydBorCarNitOxyFluPhoSulVanYttIodUra"\#3d/m[)"_NaFeCuAgSnSbTmAuHgPbWKRfSgHBCNOFPSVYIU"S%\=_"_"={;_1U"Un"={;4="Uu"\+}*}*}"Si"?}*}*}*}*}?}?]W=

Mit Einrückungen:

rel
_"ruthen"#!"Ru"
{
_"tel"#!"Te"
{
  __5{\_ceu\@=+_}:U~
  "PdYbRgCmCn"{\#)!}:X~
  {
   ;__4U
   "RnPaCfDs"X
   {
    ;_3U
    "NbCsNdPmTbPtTlBkEsFmMdLrMt"X
    {
     ;2U
     "MgClCrMnZnAsRbSrZrTcCdSmGdHfReAtNpPuDbBhHsLv"X
     {

       ;__"sili"#
       {
        ;__ceu\1=@2=++"SodIroCopSilTinAntThuGolMerLeaTunPotRutSeaHydBorCarNitOxyFluPhoSulVanYttIodUra"\#3d/m[)"_ Na Fe Cu Ag Sn Sb Tm Au Hg Pb W K Rf Sg H B C N O F P S V Y I U"S%\=_"_"=
        {;_1U"Un"={;4="Uu"\+}*}*
       }
      "Si"?

     }*
    }*
   }*
  }*
 }?
}?
]W=

Viele der Symbole sind nur die ersten beiden Buchstaben des Elementnamens. Diese werden in der zweittiefsten Schicht verschachtelter if-Anweisungen behandelt. Viele andere sind der erste und dritte Buchstabe oder der erste und vierte Buchstabe - diese werden in aufeinanderfolgenden äußeren Schichten behandelt. Symbole, bei denen nur der erste Buchstabe erscheint, und vollständige Unregelmäßigkeiten werden in der fünften bzw. dritttiefsten Ebene behandelt.

Es gibt einige, bei denen es verwirrt wird ( TelLuriumvs ThaLlium, orSILicon vs SILveroder RUTheniumvs RUTherfordium). Diese werden separat behandelt.

Hier könnte viel Golf gespielt werden, hauptsächlich durch die Wiederverwendung von Codeblöcken und die Verbesserung des Umgangs mit Unregelmäßigkeiten.


quelle
1
Einige Tipps: 1. Das Verhalten für ungültige Elementnamen ist möglicherweise undefiniert und "RUTHENIUM"=kann nicht verwendet werden "RUTHEN"#!. 2. Sie müssen ovor dem eigentlichen Elementnamen ( ) weder explizit drucken ( ) noch etwas entfernen ( ;"Si"). Hänge einfach ]W=an das Ende deines Codes an, um alles außer dem obersten Stack-Element zu entfernen. 3. Das macht ein paar Blocks leer. If Bist ein Boolescher Wert, B{...}{}?und B{...}*erreichen Sie dasselbe. 4. Die ternäre wenn nimmt Blöcke oder Stapelelemente, so dass Sie verkürzen {"Si"}zu "Si".
Dennis
@Dennis Ich glaube, ich habe das alles hinzugefügt. Die Stapelverwaltung benötigt Arbeit, obwohl - zu viele _und ;überall
@ Tennis Und ich habe ein paar Zeichen durch Ändern der Standard-Groß- / Kleinschreibung und durch Verwenden der Alias-Code-Blöcke mehr
3

PHP, 507 485 476 466 Zeichen

Verwendung: Geben Sie den Elementnamen als GET-Parameter '0' ein - elements.php? 0 = carbon

Algorithmus: Durchlaufen Sie die Datenzeichenfolge und ziehen Sie Teilzeichenfolge- und Abkürzungscodepaare heraus. Wenn die Teilzeichenfolge mit dem Anfang des übergebenen Elements übereinstimmt, bestimmen Sie anhand des Abkürzungscodes, was ausgegeben werden soll: Wenn der Code mit einem Buchstaben beginnt, geben Sie ihn als Zeichenfolge aus. Wenn es sich um eine Zahl N handelt, geben Sie den ersten Buchstaben des Elements + den N-ten Buchstaben aus. Die Unun-Elemente sind mit dem Code '|' Wenn keine Unterzeichenfolge gefunden wird, die mit dem übergebenen Namen übereinstimmt, geben Sie die ersten beiden Zeichen des Namens als Abkürzung aus.

Lesbarer Code:

<?
$l=ucfirst(strtolower($_GET[0]));
for(
  $m[3]="AnSbArs2As2Berk3Boh2BoBCad2Cae3Cali4CarCChl2Ch2Cope5CopCuCu5Da4Du2Ei3Fe3FluFGad2GoAuHaf2Ha2HyHIo0IroFeLaw3LePbLiv2Mag2Man2Mei3Men3MeHgNeod3Nep2Nio3NiNOxOPa5PhPPla3Plu2PotKProm3Pro4Rado4Rhe2Roe5Rub2Ruther6Sa2Sea6SilvAgSoNaSt2SuSTec2Ter3Tha3Thu6TinSnTuWUn|UUVVYtte5YYZin2Z2";
  preg_match('/(.[a-z]*)(.[a-z]*)(.*)/',$m[3],$m)
;)
    if(strstr($l,$m[1]))
        echo($x=$m[2][0])>'@'?$x>'{'?"Uu$l[4]":$m[2]:$l[0].$l[$x],die;
echo$l[0],$l[1];

Kondensiert:

<?$l=ucfirst(strtolower($_GET[0]));for($m[3]="AnSbArs2As2Berk3Boh2BoBCad2Cae3Cali4CarCChl2Ch2Cope5CopCuCu5Da4Du2Ei3Fe3FluFGad2GoAuHaf2Ha2HyHIo0IroFeLaw3LePbLiv2Mag2Man2Mei3Men3MeHgNeod3Nep2Nio3NiNOxOPa5PhPPla3Plu2PotKProm3Pro4Rado4Rhe2Roe5Rub2Ruther6Sa2Sea6SilvAgSoNaSt2SuSTec2Ter3Tha3Thu6TinSnTuWUn|UUVVYtte5YYZin2Z2";preg_match('/(.[a-z]*)(.[a-z]*)(.*)/',$m[3],$m);)if(strstr($l,$m[1]))echo($x=$m[2][0])>'@'?$x>'{'?"Uu$l[4]":$m[2]:$l[0].$l[$x],die;echo$l[0],$l[1];
Sir_Lagsalot
quelle
2

JavaScript (1100)

Naive Umsetzung strahlt in ihrer Einfachheit. Eine eindeutige Unterzeichenfolge ab dem Beginn des Namens wird einfach dem Symbol zugeordnet.

e={hy:"H",he:"He",lit:"Li",bery:"Be",bor:"B",car:"C",nit:"N",ox:"O",flu:"F",neon:"Ne",so:"Na",mag:"Mg",al:"Al",sili:"Si",ph:"P",su:"S",chl:"Cl",arg:"Ar",pot:"K",calc:"Ca",sc:"Sc",tit:"Ti",v:"V",chr:"Cr",man:"Mn",iro:"Fe",cob:"Co",nic:"Ni",copp:"Cu",zin:"Zn",gal:"Ga",ge:"Ge",ars:"As",sel:"Se",br:"Br",k:"Kr",rub:"Rb",st:"Sr",yttr:"Y",zir:"Zr",nio:"Nb",mo:"Mo",tec:"Tc",ruthen:"Ru",rho:"Rh",pa:"Pd",silv:"Ag",cad:"Cd",in:"In",tin:"Sn",an:"Sb",tel:"Te",io:"I",x:"Xe",cae:"Cs",ba:"Ba",lan:"La",ce:"Ce",pra:"Pr",neod:"Nd",prom:"Pm",sa:"Sm",eu:"Eu",gad:"Gd",ter:"Tb",dy:"Dy",ho:"Ho",er:"Er",thu:"Tm",ytte:"Yb",lu:"Lu",haf:"Hf",ta:"Ta",tu:"W",rhe:"Re",os:"Os",iri:"Ir",pla:"Pt",go:"Au",mer:"Hg",tha:"Tl",le:"Pb",bi:"Bi",pol:"Po",as:"At",rado:"Rn",fr:"Fr",radi:"Ra",ac:"Ac",tho:"Th",prot:"Pa",ur:"U",nep:"Np",plu:"Pu",am:"Am",cu:"Cm",berk:"Bk",cali:"Cf",ei:"Es",fe:"Fm",men:"Md",no:"No",law:"Lr",ruther:"Rf",du:"Db",sea:"Sg",boh:"Bh",has:"Hs",mei:"Mt",da:"Ds",ro:"Rg",cope:"Cn",ununt:"Uut",fle:"Fl",ununp:"Uup",liv:"Lv",ununs:"Uus",ununo:"Uuo"}
n=prompt().toLowerCase()
for(i in e)n.indexOf(i)?i:alert(e[i])
Mika Lammi
quelle
2

Python - 652 649 637

Meine Hash-Tabelle basiert auf der Kombination von jedem zweiten und jedem dritten Zeichen des Großbuchstabennamens:

import re
def f(s,c='S<8F0FCE;2.ACR;J@W$;BI8>GD*?GnHQ<K>&T\(51IAg/Y?S2=169.,325(F(98?>?=^97DUCITX;SJ`0C<P9iLP/G4B,A(-A?(3QLLZ;81D(.4F;L8GaVP[=\=cOX3U,LQl6:E9/OXdSe(4,TSV/=FN98?K.18Q>R$+<GG[IS-4?;4H;T/IMq9<LXMYH4HG<>>KTT,>IIEM,[Nf<,:Z60(A9fImZTMRTcM?[lVg^qC}',e='HHeLiBeBCNOFNeNaMgAlSiPSClArKCaScTiVCrMnFeCoNiCuZnGaGeAsSeBrKrRbSrYZrNbMoTcRuRhPdAgCdInSnSbTeIXeCsBaLaCePrNdPmSmEuGdTbDyHoErTmYbLuHfTaWReOsIrPtAuHgTlPbBiPoAtRnFrRaAcThPaUNpPuAmCmBkCfEsFmMdNoLrRfDbSgBhHsMtDsRgCnUutFlUupLvUusUuo'):
 U=s.upper();X=lambda x:chr(32+sum(ord(u)-65for u in x))
 return re.findall('[A-Z][a-z]*',e)[zip(c[::2],c[1::2]).index((X(U[1::3]),X(U[:-1:2])))]

Hier ist der entsprechende Generator:

table = '''
H     Hydrogen
He    Helium
...
Uuo   Ununoctium
'''

table = map(lambda l: l.split(), table.split('\n')[1:-1])

abbr = []
for name in map(str.upper, zip(*table)[1]):
    abbr.append(chr(32+sum(ord(u)-65 for u in name[1::3]))+
                chr(32+sum(ord(u)-65 for u in name[:-1:2])))
print 'c=' + ''.join(abbr)
print 'e=' + ''.join(zip(*table)[0])
print 'Unique' if len(table) == len(set(abbr)) else 'Duplicates'

Es gibt wahrscheinlich Raum für Verbesserungen, insbesondere für das Komprimieren der beiden langen Saiten.

Getestet mit:

for short, name in table:
    if f(name) != short:
        print "Wrong result!"
Falko
quelle
2

Golfscript - 1052 821

{.91<32*+}%:x;'H
He
Li
Be
B
C
N
F
Ne
Na
Mg
Al
Si
P
S
Cl
Ar
K
Ca
Sc
Ti
V
Cr
Mn
Fe
Co
Ni
Cu
Zn
Ga
Ge
As
Se
Br
Kr
Rb
Sr
Y
Zr
Nb
Mo
Tc
Ru
Rh
Pd
Ag
Cd
In
Sn
Sb
Te
I
Xe
Cs
Ba
La
Ce
Pr
Nd
Pm
Sm
Eu
Gd
Tb
Dy
Ho
Er
Tm
Yb
Lu
Hf
Ta
W
Re
Os
Ir
Pt
Au
Hg
Tl
Pb
Bi
Po
At
Rn
Fr
Ra
Ac
Th
Pa
U
Np
Pu
Am
Cm
Bk
Cf
Es
Fm
Md
No
Lr
Rf
Db
Sg
Bh
Hs
Mt
Ds
Rg
Cn
Uut
Fl
Uup
Lv
Uus'n/'hy
he
lit
bery
bor
car
nit
flu
neon
so
mag
al
sili
ph
su
chl
arg
pot
calc
sc
tit
v
chr
man
iro
cob
nic
copp
zin
gal
ge
ars
sel
br
k
rub
st
yttr
zir
nio
mo
tec
ruthen
rho
pa
silv
cad
in
tin
an
tel
io
x
cae
ba
lan
ce
pra
neod
prom
sa
eu
gad
ter
dy
ho
er
thu
ytte
lu
haf
ta
tu
rhe
os
iri
pla
go
mer
tha
le
bi
pol
as
rado
fr
radi
ac
tho
prot
ur
nep
plu
am
cu
berk
cali
ei
fe
men
no
law
ruther
du
sea
boh
has
mei
da
ro
cope
ununt
fle
ununp
liv
ununs
ununo'n/[{x\?)}/]1?=

Erläuterung:

{        }%                              Map these ops to the input string:
 .91<32*+                                   Add 32 if less than 91 (convert to lowercase, in essence)
           :x;                           Store to x.
              '...'  '...'               The first array is the symbols, the second is the names.
                                         (stripped down to the minimum necessary)
                   n/     n/             Convert them to arrays.
                             {    }/     For each element in the name array...
                              x\?)          ...return 1 if the element is found in the input.
                            [       ]    Gather every element in an array...
                                     1?  Find the 1 in the array (the only element name match)...
                                       = ...then return that symbol in the symbol array.
                               (implied) Print.
Josiah Winslow
quelle
11
OMG, Ein Stück Golfscript mit nicht weniger als 10 Zeichen!
WallyWest
1
Sie können dieses String-Array massiv verbessern, indem Sie einen String mit Newline als Trennzeichen verwenden und dann Folgendes tunn/
Peter Taylor,
Ich habe das letzte Mal gemacht, warum zum Teufel habe ich nicht daran gedacht? Jetzt aktualisieren.
Josiah Winslow
2

Haskell, 920 817 807 776 Zeichen

Nachdem ich viel zu lange daran gearbeitet hatte, ein Regelsystem für die Zeichen eines Elementnamens in seinem Symbol zu erstellen, und ein wenig gebastelt hatte, gelang es mir, ein Skript zu schreiben, das Element in Symbol umsetzt. Eisen war ein Problem für mich, da ich bestimmte Zeichen aus GOLD, SILVER, TIN, LEAD, SODIUM, MERCURY, ANTIMONY, POTASSIUM und TUNGSTEN in ein nicht verwendetes periodisches Symbol umwandeln konnte (ich entschied mich für eine Stichprobe, die die Integration am einfachsten machte) sie in die bestehenden Regeln einbinden) und dann nach symbolischer Konvertierung übersetzen; Eisen war jedoch ein Problem, da Ir, Io und In bereits verwendet werden. Das waren ursprünglich 920 Zeichen, aber ich erkannte, dass die letzte Musterübereinstimmung (die größte) nicht vorhanden sein musste, da sie entweder die Dinge durchgehen ließ (was sie nicht tat) oder mit allen übereinstimmte. deshalb, Ich habe es durch ein Sammelzeichen ersetzt. Danach spielte ich weiter von 817 auf 808, indem ich einige Muster mit Platzhaltern so abkürzte, dass sie für diesen Elementnamen immer noch eindeutig waren (z. B. ist Lawrencium das einzige Element mit einem 'w' im Namen, also "* w "entspricht 1 Zeichen weniger als" Law ").

Hier ist mein Code. Ich habe es für alle Elemente getestet und es so codiert, dass es seine Eingabe automatisch in titlecase konvertiert, also keine Probleme mit der Groß- und Kleinschreibung.

EDIT 1

Ich reduzierte es weiter auf 776 Zeichen, indem ich den case-Ausdruck in t durch eine Musterübereinstimmung ersetzte (dies ist sinnvoll, weil der case-Ausdruck den rohen Operanden im Gegensatz zu einem Ausdruck im Sinne des Operanden testete), unnötige Klammern entfernte und Ausdrücken eals durch neue Zeilen getrennte Zeichenfolge anstelle einer Liste von Zeichenfolgen und später Aufteilen in die Hauptfunktion. Da es sich bei diesen Änderungen nur um Golf handelt, habe ich die für Menschen lesbare Version unverändert gelassen.

import Data.Char
m _[]=True;m[]_=False;m k@(c:s)x@(y:z)=case y of{']'->m s x;'['->let(i,(_:j))=break(==']')z in(c`elem`i)&&m s j;'?'->m s z;'*'->null z||m k z||m s z||m s x;_->c==y&&m s z};p(a:t)(x:y)=case a of{'.'->x:p t y;'_'->p t y;_->a:p t y};p[]_=[];e="Iro\nUn\nCu Pa Ro Y*e\nR*r\n*pp\nCop Rado\nSea Thu\nCali Da P*ot Tha\nA*s Boh ?ub Ch [CG]ad [HM]a Liv Nep Plu Rhe S[ato] Tec Tin Z\nB*k Cae [ES]i *w Nio [FM]e N*d Pro Pla Ter\nBor Car Flu Hy Io Nit Ox Ph Su [UVY]\n*";s="Fe ._._. .____. .f .u .n ._____. .___. ._. .__. . ..";t"Sv"="Ag";t"Sd"="Na";t"Go"="Au";t"Le"="Pb";t"Mc"="Hg";t"An"="Sb";t"Ps"="K";t"Tu"="W";t"Tn"="Sn";t x=x;main=interact$unlines.map(\(a:b)->let y=toUpper a:map toLower b in t$p(snd.head.filter(any(m y).fst)$zip(map words$lines e)$words s)y).lines

Vom Menschen lesbare Version (Zeilenumbrüche, Abstände, ausführliche Namen, Kommentare: 2311 Zeichen)

import Data.Char

-- Test against search-pattern strings
match _ [] = True
match [] _ = False
match k@(c:s) x@(y:z) = case y of
']' -> match s x
'[' -> let (i,(_:j)) = break (==']') z in (c `elem` i) && match s j
'?' -> match s z
'*' -> null z || match k z || match s z || match s x
 _  -> c == y && match s z

-- Write according to name-pattern string
pattern (a:t) (x:y) = case a of
'.' -> x : (pattern t y)
'_' -> (pattern t y)
 _  -> a : (pattern t y)
pattern [] _ = []

-- Search-Patterns for the elements
elements=["Iro", -- Iron -> Fe
      "Un", -- UnUn-Blank-ium (1,3,5)
      "Cu Pa Ro Y*e", -- CuriuM PallaDium RoentGenium YtterBium (1,6)
      "R*r", -- Rutherfordium (1,f)
      "*pp", -- Copper (1,u)
      "Cop Rado", -- Copernicium Radon (1,n)
      "Sea Thu", -- SeaborGium ThuliuM (1,7)
      "Cali Da P*ot Tha", -- CaliFornium DarmStadtium ProtActinium PotaSsium (1,5)

      {- AsTatine ArSenic BoHrium DuBnium RuBidium ChLorine ChRome CaDmium
      GaDolinium HaFnium HaSsium MaNganese MaGnesium LiVermorium NePtunium
      PlUtonium RhEnium SaMarium StRontium SoDium TeChnetium TiN ZiNc
      ZiRconium (1,3) -}

      "A*s Boh ?ub Ch [CG]ad [HM]a Liv Nep Plu Rhe S[ato] Tec Tin Z", 

      {- BerKelium CaeSium EinSteinum SilIcon SilVer LawRencium NioBium
      FerMium MenDelevium MeiTnerium MerCury NeoDymium ProMethium PlaTinum
      TerBium (1,4) -}

      "B*k Cae [ES]i *w Nio [FM]e N*d Pro Pl Ter",

      {- Boron Carbon Fluorine Hydrogen Nitrogen Oxygen Phosphorous Sulphur
      Uranium Vanadium Yttrium (1) -}

      "Bor Car Flu Hy Io Nit Ox Ph Su [UVY]",
      "*"] -- Everything else (1,2)

-- respective naming patterns for searches
symbol = "Fe ._._. .____. .f .u .n ._____. .___. ._. .__. . .."

-- Translate fake symbols
translate x = case x of
"Sv" -> "Ag" -- SilVer
"Sd" -> "Na" -- SoDium
"Go" -> "Au" -- GOld
"Le" -> "Pb" -- LEad
"Mc" -> "Hg" -- MerCury
"An" -> "Sb" -- ANtimony
"Ps" -> "K" -- PotaSsium
"Tu" -> "W" -- TUngsten
"Tn" -> "Sn" -- TiN
  _  -> x  -- Keep everything else the same

main = interact $ unlines . map (\(a:b) -> let y = (toUpper a) : (map toLower b) in t $ p (snd.head.filter (any (m y) . fst) $ zip (map words e) $ words s) $ y) . lines

Wenn jemand an einer Erklärung für irgendeinen Teil interessiert ist, kann er sich gerne erkundigen.

Archaephyrryx
quelle
2

C # (826)

nicht die größte, aber ich dachte, ich würde es mit dem Handicap von c # versuchen.

using System;class P{static string s="HyHHe1Li1Be1BoBCaCNitNOxOFlFNe1SoNaMaMgAl1Sil1PhPSuSChClAr1PotKCal1Sc1Tit1VaVChrCrManMnIrFeCo1Ni1CopCuZiZnGa1Ge1ArsAsSe1Br1Kr1RuRbStSrYtYZirZrNioNbMo1TecTcRut1Rh1PaPdSiAgCadCdIn1TiSnAnSbTel1IoIXe1CaeCsBa1La1Ce1Pra1NeoNdPrPmSaSmEu1GadGdTeTbDy1Ho1Er1ThTmYttYbLu1HaHfTa1TuWRheReOs1Iri1PlPtGoAuMeHgThaTlLePbBi1Po1AsAtRaRnFr1Rad1Ac1Tho1ProPaUrUNepNpPluPuAm1CuCmBerBkCaliCfEiEsFeFmMenMdNo1LawLrRuthRfDuDbSeaSgBohBhHasHsMeiMtDaDsRoRgCopeCnUnUutFle1UnuUupLivLvUnunUus",n,t,k;static void Main(){var d=new System.Collections.Specialized.StringDictionary();while(s!=""){k=g;d[k]=g;if(d[k]=="1")d[k]=k.Substring(0,2);};t=Console.ReadLine();while(t!=""&!d.ContainsKey(t))t=t.Remove(t.Length-1);Console.Write(d[t]);}static string g{get{n="";do n+=s[0];while((s=s.Remove(0,1))!=""&&s[0]>96);return n;}}}

Deshalb habe ich ein Programm geschrieben, um den vollständigen Namen von Elementen (z. B. Carbon) in die kleinste, aber immer noch eindeutige Zeichenfolge umzuwandeln, und dies für alle Elemente in Bezug auf alle anderen eindeutigen Zeichenfolgen. Ich habe das dann zu einer großen hässlichen Zeichenkette serialisiert, in der Großbuchstaben den Beginn von "Chunks" bezeichnen, wobei Chunks zwischen Schlüsseln und Werten wechseln. Wie KeyValueKey2Value2 usw.

Dieses Skript desterilisiert diese große Zeichenfolge und schneidet ein Zeichen am Ende der eingegebenen Zeichenfolge ab, bis es im Wörterbuch aus der großen Zeichenfolge gefunden wird.

(Ich sollte hinzufügen, dass mein Wissen über C # nicht erstaunlich ist und die ursprüngliche Einreichung, die ich machte, nur Dinge verwendete, die ich wusste, aber ich hatte anschließend einige Tricks, die mir von anderen gezeigt wurden.)

miethpo
quelle
Sie können dies weiter verbessern, indem Sie alle Typdefinitionen in ändern var. Sie können ein paar weitere speichern, indem Sie nach der Einzelanweisung if blocks die geschweiften Klammern entfernen. Wenn Sie einem zuweisen t.Substring(int, int), Func<int, int, string>können Sie ein anderes Paar speichern.
Brandon
Ich habe die meisten variablen Defs "var" gemacht, aber anscheinend habe ich ein oder zwei verpasst, und auch das klammerlose Wenn völlig vergessen, danke.
miethpo
Sie können weitere 5 Zeichen durch varDrücken der string[] rund weitere 3 durch varDrücken der rasieren . Schließlich string t = Console....sparen Sie weitere 7, indem Sie ganz am Ende return new string[]in wechseln return new[].
Brandon
Es gibt eine Handvoll kleinerer Verbesserungen, die Sie durchführen können, z. B. das Verschieben Ihrer if(...) break;Logik in die for-Schleifen-Ausgangsbedingungen. Eine Reihe anderer logischer Inversionen kann angewendet werden, z. B. eine do { } while(..)in Ihrer Extraktionsmethode. Dies ist kürzer als das Hinzufügen einer separaten logischen Operation für den Eingabefall. Ich habe eine Änderung an Ihrem Code veröffentlicht, die aufgrund meiner geringen Anzahl an Mitarbeitern auf dieser Website noch überprüft / akzeptiert werden muss. Ich habe es auf 870 Zeichen gebracht.
Nicholas
1
@Nicholas Ich bin mir nicht sicher, ob es höflich ist, den Code eines anderen zu bearbeiten ...
miethpo
1

JavaScript (E6) 1433

Hier ist eine Obergrenze

F=n=>'0H0HYDROGEN0He0HELIUM0Li0LITHIUM0Be0BERYLLIUM0B0BORON0C0CARBON0N0NITROGEN0O0OXYGEN0F0FLUORINE0Ne0NEON0Na0SODIUM0Mg0MAGNESIUM0Al0ALUMINIUM0Si0SILICON0P0PHOSPHORUS0S0SULFUR0Cl0CHLORINE0Ar0ARGON0K0POTASSIUM0Ca0CALCIUM0Sc0SCANDIUM0Ti0TITANIUM0V0VANADIUM0Cr0CHROMIUM0Mn0MANGANESE0Fe0IRON0Co0COBALT0Ni0NICKEL0Cu0COPPER0Zn0ZINC0Ga0GALLIUM0Ge0GERMANIUM0As0ARSENIC0Se0SELENIUM0Br0BROMINE0Kr0KRYPTON0Rb0RUBIDIUM0Sr0STRONTIUM0Y0YTTRIUM0Zr0ZIRCONIUM0Nb0NIOBIUM0Mo0MOLYBDENUM0Tc0TECHNETIUM0Ru0RUTHENIUM0Rh0RHODIUM0Pd0PALLADIUM0Ag0SILVER0Cd0CADMIUM0In0INDIUM0Sn0TIN0Sb0ANTIMONY0Te0TELLURIUM0I0IODINE0Xe0XENON0Cs0CAESIUM0Ba0BARIUM0La0LANTHANUM0Ce0CERIUM0Pr0PRASEODYMIUM0Nd0NEODYMIUM0Pm0PROMETHIUM0Sm0SAMARIUM0Eu0EUROPIUM0Gd0GADOLINIUM0Tb0TERBIUM0Dy0DYSPROSIUM0Ho0HOLMIUM0Er0ERBIUM0Tm0THULIUM0Yb0YTTERBIUM0Lu0LUTETIUM0Hf0HAFNIUM0Ta0TANTALUM0W0TUNGSTEN0Re0RHENIUM0Os0OSMIUM0Ir0IRIDIUM0Pt0PLATINUM0Au0GOLD0Hg0MERCURY0Tl0THALLIUM0Pb0LEAD0Bi0BISMUTH0Po0POLONIUM0At0ASTATINE0Rn0RADON0Fr0FRANCIUM0Ra0RADIUM0Ac0ACTINIUM0Th0THORIUM0Pa0PROTACTINIUM0U0URANIUM0Np0NEPTUNIUM0Pu0PLUTONIUM0Am0AMERICIUM0Cm0CURIUM0Bk0BERKELIUM0Cf0CALIFORNIUM0Es0EINSTEINIUM0Fm0FERMIUM0Md0MENDELEVIUM0No0NOBELIUM0Lr0LAWRENCIUM0Rf0RUTHERFORDIUM0Db0DUBNIUM0Sg0SEABORGIUM0Bh0BOHRIUM0Hs0HASSIUM0Mt0MEITNERIUM0Ds0DARMSTADTIUM0Rg0ROENTGENIUM0Cn0COPERNICIUM0Uut0UNUNTRIUM0Fl0FLEROVIUM0Uup0UNUNPENTIUM0Lv0LIVERMORIUM0Uus0UNUNSEPTIUM0Uuo0UNUNOCTIUM'
.match(RegExp('([^0]+)0+'+n,'i'))[1]

Test in der FireFox / FireBug-Konsole

F('Rutherfordium')

Ausgabe

Rf
edc65
quelle
1

SmileBASIC, 1763 1418 1204 1128 Bytes

INPUT E$Hro$="H
Hiu$="He
Lhi$="Li
Byl$="Be
Bon$="B
Cbo$="C
Nro$="N
Oge$="O
For$="F
Nn$="Ne
Siu$="Na
Mne$="Mg
Ami$="Al
Sic$="Si
Psp$="P
Sfu$="S
Cor$="Cl
Aon$="Ar
Pas$="K
Cci$="Ca
Snd$="Sc
Tan$="Ti
Vad$="V
Com$="Cr
Mga$="Mn
In$="Fe
Cal$="Co
Nke$="Ni
Cpe$="Cu
Zc$="Zn
Gli$="Ga
Gma$="Ge
Aen$="As
Sen$="Se
Bmi$="Br
Kpt$="Kr
Rid$="Rb
Son$="Sr
Yri$="Y
Zco$="Zr
Nbi$="Nb
Myb$="Mo
Thn$="Tc
Rhe$="Ru
Rdi$="Rh
Pla$="Pd
Sve$="Ag
Cmi$="Cd
Iiu$="In
T$="Sn
Aim$="Sb
Tlu$="Te
Iin$="I
Xon$="Xe
Csi$="Cs
Biu$="Ba
Lth$="La
Pse$="Pr
Ndy$="Nd
Pme$="Pm
Sar$="Sm
Eop$="Eu
Gol$="Gd
Tbi$="Tb
Dpr$="Dy
Hmi$="Ho
Eiu$="Er
Tli$="Tm
Yer$="Yb
Let$="Lu
Hni$="Hf
Tta$="Ta
Tgs$="W
Rni$="Re
Oiu$="Os
Idi$="Ir
Pti$="Pt
Gd$="Au
Mcu$="Hg
Tll$="Tl
Ld$="Pb
Bmu$="Bi
Pon$="Po
Aat$="At
Ron$="Rn
Fnc$="Fr
Riu$="Ra
Ain$="Ac
Tri$="Th
Pta$="Pa
Uni$="U
Ntu$="Np
Pto$="Pu
Ari$="Am
Ciu$="Cm
Bke$="Bk
Cif$="Cf
Est$="Es
Fmi$="Fm
Mde$="Md
Nel$="No
Lre$="Lr
Dni$="Db
Sbo$="Sg
Bri$="Bh
Hsi$="Hs
Mtn$="Mt
Dms$="Ds
Rnt$="Rg
Cer$="Cn
Unt$="Uut
Fro$="Fl
Unp$="Uup
Ler$="Lv
Uns$="Uus
Uno$="Uuo
S$=VAR(E$[0]+MID$(E$,3,2))IF"Cm"==S$*!VAL(".1"+E$[1])THEN S$="Ce
IF LEN(E$)>12THEN S$="Rf
?S$

Ich habe 3 Charaktere ausgewählt, die größtenteils einzigartig sind (das 0., 2. und 3.), was zwei Sonderfälle hinterlässt: Cer / Curium sind beide "Ciu" und Ruthenium / Rutherfordium sind beide "Rhe". Bei Ciu überprüfe ich, ob das zweite Zeichen des Namens "e" oder "E" ist, und bei "Rhe" überprüfe ich die Länge des Namens.

VAR(name)gibt die Variable mit diesem Namen zurück. Variablennamen unterscheiden nicht zwischen Groß- und Kleinschreibung.

12Me21
quelle
0

T-SQL, 900 894 676 Bytes

SELECT ISNULL((SELECT LEFT(value,3)FROM
STRING_SPLIT('Sb An-As Ars-At Ast-Bk Berk-Bh Boh-B  Bor-Cd Cad-Cs Cae-Cf Cali-C  Car-Cl Chl-Cr Chr-Cn Cope-Cu Copp-Cm Cu-Ds Da-Db Du-Es Ei-Fm Fe-F  Flu-Gd Gad-Au Go-Hf Haf-Hs Has-H  Hy-I  Io-Fe Iro-Lr Law-Pb Le-Lv Liv-Mg Mag-Mn Man-Mt Mei-Md Men-Hg Mer-Nd Neod-Np Nep-Nb Nio-N  Nit-O  Ox-Pd Pa-P  Ph-Pt Pla-Pu Plu-K  Pot-Pm Prom-Pa Prot-Rn Rado-Re Rhe-Rg Ro-Rb Rub-Rf Ruther-Sm Sa-Sg Sea-Ag Silv-Na So-Sr St-S  Su-Tc Tec-Tb Ter-Tl Tha-Tm Thu-Sn Tin-W  Tu-UuoUnuno-UupUnunp-UusUnuns-UutUnunt-U  Ur-V  V-Yb Ytte-Y  Yttr-Zn Zin-Zr Zir'
    ,'-')m,t WHERE e LIKE SUBSTRING(value,4,9)+'%'),
(SELECT UPPER(LEFT(e,1))+LOWER(SUBSTRING(e,2,1))FROM t))

Rückgaben dienen nur der Lesbarkeit. Die zweite Zeile ist eine sehr lange Zeichenfolge.

STRING_SPLIT wird in SQL 2016 und höher unterstützt.

Die Eingabe erfolgt über eine bereits vorhandene Tabelle entnommen t mit varchar Feld e , je unseren IO - Standards . Die Ausgabe wird mit Leerzeichen auf 3 Zeichen aufgefüllt. Die Regeln waren unklar, ob das in Ordnung war. Bei Bedarf kann ich eine hinzufügen TRIM.

Die Eingabetabelle wird mit einer Tabelle verknüpft, die eine Liste aller Elementsymbole (aufgefüllt mit 3 Zeichen) mit dem kürzesten eindeutigen Präfix für jeden Elementnamen enthält ( Xreicht für Xenon aus , Rutherfordium muss Rutheres jedoch von Ruthenium unterscheiden ).

EDIT 1 : 218 Zeichen wurden gespeichert, indem die 44 Einträge aus der Liste entfernt wurden, deren Symbol die ersten beiden Buchstaben ihres Namens sind. Die ISNULLFunktion wird verwendet, um festzustellen, ob die erste Abfrage keine Zeile zurückgibt. In diesem Fall wird aus dem Namen des Eingabeelements das Symbol (ordnungsgemäß in Groß- und Kleinschreibung) generiert.

BradC
quelle