Układ okresowy pierwiastków - Code Golf

47

Na podstawie golfa praktycznego - stany USA

Twoim zadaniem jest znalezienie skrótu (symbolu) elementu o nazwie elementu, aż do ununoctium (118). Skorzystaj z układu okresowego na Wikipedii .

Dzięki piskliwemu ossifrage możesz znaleźć pełną listę elementów do skrótów na http://pastebin.com/DNZMWmuf .

Nie możesz używać żadnych zasobów zewnętrznych. Ponadto nie można używać żadnych wbudowanych danych dotyczących elementów układu okresowego. Obowiązują standardowe luki.

Wejście

Wejście może być ze standardowego wejścia, pliku prompt, inputitd.

Format wejściowy:

Wszystkie poniższe dane są poprawnymi danymi wejściowymi:

Carbon
carbon
CARBON
cArBOn

Zasadniczo nazwa elementu - bez rozróżniania wielkości liter.

Nie musisz obsługiwać błędów pisowni ani żadnych nieprawidłowych nazw elementów. Niepoprawne dane wejściowe to niezdefiniowane zachowanie.

Wyjście :

Symbol elementu. Pierwszy znak musi być aktywowane i reszta muszą być pisane małymi literami.

Przykładowe dane wyjściowe: C

Przypadki testowe:

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

Jest o wiele więcej elementów niż stanów, więc spodziewam się, że trudniej będzie znaleźć ogólną zasadę dla nich.

To jest kod golfowy. Najkrótszy kod wygrywa!

soktinpk
źródło
4
@squeamishossifrage Thanks. Obie wersje („siarka” i „siarka”) są dopuszczalne. Twój program nie musi obsługiwać obu, ale tylko jeden.
soktinpk
1
... niemożliwe do zrobienia z wyrażeniami regularnymi. Masz nas dobrze.
Josiah Winslow
2
@ Xrylite Spróbuj przeczytać zasady: „ Wprowadź ... nazwa elementu - wielkość liter nie ma znaczenia… Wyjście … Pierwszy znak musi być pisany wielkimi literami, a reszta musi być pisana małymi literami”.
Jim Balter
2
Co z poprawną pisownią (aluminium) w porównaniu z amerykańską (aluminium)?
Paul R
4
@codebreaker Tak, jeśli dane wejściowe są nieprawidłowe, program może ulec awarii, zawiesić się, wydrukować Aulub cokolwiek zechcesz. @Paul R Jeśli istnieje wiele sposobów na przeliterowanie elementu (np. Siarka vs siarka lub aluminium vs aluminium), użyj tego, co skraca Twój program. Nie musisz obsługiwać obu przypadków.
soktinpk

Odpowiedzi:

27

CJam, 337 297 293 232 220 201 200 bajtów

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

Powyższy kod używa notacji karetki, ponieważ zawiera znaki kontrolne.

Kosztem 24 dodatkowych bajtów (łącznie 224) można uniknąć tych znaków.

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

Możesz wypróbować ten kod w interpretatorze CJam .

Przypadki testowe

$ 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

Jak to działa

Pierwszym krokiem jest odczytanie nazwy elementu ze STDIN i zastosowanie raczej rozbudowanej funkcji skrótu, która mapuje wszystkie nazwy elementów w zakresie [0, 225] :

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.                                                  ";

Wiele symboli elementu składa się z pierwszego i drugiego, pierwszego i trzeciego, pierwszego i czwartego, pierwszego i piątego lub pierwszego i dziesiątego (który jest tylko pierwszym) znaku angielskiej nazwy elementu. Będziemy reprezentować te elementy odpowiednio liczbami od 0 do 4. Wszystkie pozostałe elementy (reprezentowane przez 5) będą wymagać tabeli przeglądowej.

Wynikową tabelę można przekazać w następujący sposób:

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

Tablica kodów znaków jest konwertowana z bazy 256 na bazę 7, a cyfry 6 są zastępowane seriami trzech zer.

To jest tabela decyzyjna 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]

Niezbędne działanie dla elementu z skrótem 1 , np., Odpowiada pierwszemu elementowi tej tablicy. Elementy tablicy, które nie odpowiadają skrótowi żadnego elementu, mają również zero, co pozwala na kompresję (0 0 0) ↦ 6 .

Teraz interpretujemy D dla skrótu 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        ";

Następnie przesuwamy tabelę wyszukiwania. Jeśli będziemy dołączać j do symboli pojedynczych znaków i zastąpić UU z Q , każdy symbol będzie długo dokładnie dwa znaki. Można go popchnąć w następujący sposób:

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

Tablica kodów znaków jest konwertowana z bazy 256 na bazę 25, kod znaku A jest dodawany do wszystkich cyfr (rzutowanie na znak w procesie), a wynik jest dzielony na części o długości dwa.

To jest tabela L:

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

Teraz przystępujemy do obliczania potencjalnych nazw elementów.

=                " 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.                              ";

Stos zawiera teraz

B M N

gdzie B to wartość logiczna D [H-1] / 5 , M to nazwa uzyskana z tabeli odnośników, a N to nazwa elementu utworzona przez wybranie znaków z E.

Prawie skończyliśmy:

?                " If B, push M; else, push N.                                            ";
( \              " Extract the first character from the string.                           ";
el               " Convert the rest to lowercase.                                         ";
Dennis
źródło
Ale jak to działa?
Claudiu
2
@Claudiu: Dodałem wyjaśnienie.
Dennis
3
Przeczytałem pierwszą trzecią wyjaśnienia i jak dotąd mam „magię”. Niesamowite
Mooing Duck
7
"AcAlAmSbArAsAtBaBkBeBiBhBBrCdCsCaCfCCeClCrCoCnCuCmDsDbDyEsErEuFmFlFFrGdGaGeAuHf HsHeHoHInIIrFeKrLaLrPbLiLvLuMgMnMtMdHgMoNdNeNpNiNbNNoOsOPdPPtPuPoKPrPmPaRaRnReRh RgRbRuRfSmScSgSeSiAgNaSrSTaTcTeTbTlThTmSnTiWUuoUupUusUutUVXeYbYZnZr" = 226 znaków. Twoje rozwiązanie = 200 znaków. Tu dzieje się jakieś właściwe voodoo.
piskliwy kostek
Zaakceptowałem tę odpowiedź, ponieważ wydaje się ona najkrótsza, ale możesz dodawać dodatkowe odpowiedzi.
soktinpk
43

C 452

Dobra funkcja skrótu pomaga. Mogą być lepsze. (Ulepszenia sugerowane przez @ugoren i in.)

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

Niegolfowany z komentarzami:

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

Użyłem brutalnej siły, aby znaleźć ten skrót; To był jedyny o wielkości skrótu ≤512, który nie miał kolizji. Nie sprawdzałem jednak alternatywnej pisowni i mogą istnieć lepsze funkcje z różnymi algorytmami (np. Używanie XOR zamiast dodawania).

Funkcja skrótu odwzorowuje ciągi tekstowe na wartości od 0 do 440. „Cyna” hash na zero, więc „Sn” znajduje się na początku tabeli. Następne 7 pozycji jest puste. Aby zachować kompaktowy kod, wskazuje na to wartość ASCII 34 + 7 = 41 („)”). Dalej jest „miedź” (8), cztery puste komórki (34 + 4 = 38 = „&”) i „wanad” (13). Po obliczeniu wartości skrótu program przechodzi przez tabelę, odejmując 1 dla każdej dużej litery, a następnie 0 lub więcej małych liter i odejmując (WARTOŚĆ ASCII) -34 dla każdego znaku niebędącego alfabetem. Gdy wartość osiągnie zero, znaleźliśmy poprawny wynik.

piskliwy kostuch
źródło
3
@soktinpk Brute wymusił to :-) To był jedyny o wielkości skrótu ≤512, który nie miał kolizji. Nie sprawdzałem jednak alternatywnej pisowni i mogą istnieć lepsze funkcje z różnymi algorytmami (np. Używanie XOR zamiast dodawania).
piskliwy ossifrage
2
Spraw, że 464 ... masz niepotrzebną parę aparatów ortodontycznych.
Jim Balter
1
Jeśli myślisz o gramatykę, to jednoznaczna i musi być dozwolony ... to po prostu wygląda niejednoznaczne do nas . Aha, i złapałeś kolejnego, którego nie złapałem! Gratuluję ... Starałem się zaostrzyć algorytm, ale wszystko dobrze zrozumiałeś.
Jim Balter
5
@Harshdeep - Funkcja skrótu odwzorowuje ciągi tekstowe na wartości od 0 do 440. „Cyna” hash na zero, więc „Sn” znajduje się na początku tabeli. Następne 7 pozycji jest puste. Aby zachować kompaktowy kod, wskazuje na to wartość ASCII 34 + 7 = 41 („)”). Dalej jest „miedź” (8), cztery puste komórki (34 + 4 = 38 = „&”) i „wanad” (13). Po obliczeniu skrótu program przechodzi przez tabelę, odejmując 1 dla każdej dużej litery, po której następuje 0 lub więcej małych liter, i odejmując (WARTOŚĆ ASCII) -34 dla każdego znaku niebędącego alfabetem. Gdy wartość osiągnie zero, znaleźliśmy poprawny wynik.
piskliwy ossifrage
2
Niezłe. Zapisz niektóre znaki za pomocą: 1 (h+c%32+74)*311%441.. 2. Upuść pi użyj s. 3. main(c)zapisuje jeden przecinek.
ugoren
13

JavaScript ES6, 690 708 bajtów

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)

Pierwsza tablica zawiera symbole, a druga tablica zawiera minimum liter niezbędnych do wskazania, do którego elementu się odnosi. Dzięki core1024 i edc65 za pomoc w skróceniu. Test na stronie http://jsfiddle.net/xjdev4m6/2/ . Nieco bardziej czytelny:

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
źródło
Czy możesz ogolić kilka bajtów, wykorzystując fakt, że Neo pasuje do neodymu, biorąc pod uwagę, że Neon został przekazany na listę?
Dancrumb
1
@Dancrumb Niestety nie. Pętla zaczyna się od najkrótszego podłańcucha, więc uderzy Neozanim trafi, Neonponieważ ma mniej liter.
NinjaBearMonkey
1
+1 za najkrótszą jak dotąd JS. Chociaż możesz pozbyć się tego ifstwierdzenia (jest to idealny forwarunek), a także wstawić lub przesunąć pozycje niektórych zmiennych, aby skrócić kod;)
core1024
2
na początku ).toLowerCase(-> )[L='toLowerCase'](potem na końcu a.toLowerCase(-> a[L](powinien wyciąć 4 znaki
edc65
10

Ruby 1.9+, 565 471 447 444

Jednowarstwowy. Ponieważ nic nie jest „niemożliwe do wykonania z
wyrażeniami regularnymi ” ... (Zapisałem 94 znaki, dodając kolejne wyrażenie regularne) ((i 24, upraszczając je)

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

(dodano nowy wiersz za ciągiem „czytelność”, usuń do testu)

użycie: ruby periodic.rb aluminum$>

Objaśnienie:
Rozdzielenie ciągu na wielkie litery zwraca tablicę wyrażeń regularnych pasujących do nazw elementów. Jedyne dozwolone znaki alfabetu w każdym z nich to te ze skrótu *. Są one uporządkowane w taki sposób, że pierwsze dopasowanie znalezione podczas porównywania z argumentem wiersza poleceń *$*jest prawidłowe. Końcowy gsub usuwa przed drukowaniem znaki inne niż alfa.

* Dziwne skróty, takie jak „Fe” dla „Iron”, są obsługiwane przez |element: „Iro | Fe”. Pierwszym wyborem jest to, co jest właściwie dopasowane; gsub usuwa następnie wszystkie znaki aż do „|”, pozostawiając rzeczywisty skrót.

Środowisko testowe (wymaga listy @ squeamish : pobranej jako „table.txt” w katalogu roboczym).

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")
AShelly
źródło
1
Owacja na stojąco, jeśli działa we wszystkich
ponad
Oczywiście, że działa: ideone.com/7FZlAt
AShelly
Można śmiało stwierdzić, że czegoś nie można zrobić za pomocą wyrażenia regularnego. Dzięki za udowodnienie, że (jeden powiedział, wielu pomyślało) źle :)
Mast
4

Rubinowy, 1068 bajtów

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]

Wejście przez STDIN.

Najkrótsze unikatowe podciągi nazw elementów są od drugiego do szóstego znaku (lub końca nazwy, jeśli jest zbyt krótka). Więc po prostu biorę je i szukam w haszu. Skompresowałem również skrót, ponieważ pozwala to zaoszczędzić kolejne 200 bajtów. Oto jak wygląda sam skrót:

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

CJam, 462 449 434 401 391 384 382

Z pomocą Dennisa.

Kod

Zagnieżdżone trójki, jeśli prawdopodobnie nie są dobrym sposobem na zrobienie tego w CJam.

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=

Z wcięciami:

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=

Wiele symboli to tylko dwie pierwsze litery nazwy elementu. Są one obsługiwane w drugiej najgłębszej warstwie zagnieżdżonych instrukcji if. Wiele innych to pierwsza i trzecia litera lub pierwsza i czwarta litera - są one obsługiwane w kolejnych warstwach zewnętrznych. Symbole, w których pojawia się tylko pierwsza litera i pełne nieregularności, są obsługiwane odpowiednio w piątej i trzeciej najgłębszej warstwie.

Jest kilka, w których robi się zagubiony ( TelLuriumvs ThaLlium, lub SILiconvs SILverlub RUTheniumvs RUTherfordium). Są one obsługiwane osobno.

Można tu grać w golfa, głównie poprzez ponowne użycie bloków kodu i poprawę obsługi nieregularności.


źródło
1
Kilka wskazówek: 1. Zachowanie się w przypadku niepoprawnych nazw elementów może być niezdefiniowane, więc zamiast "RUTHENIUM"=używać "RUTHEN"#!. 2. Nie musisz drukować jawnie ( o) ani niczego usuwać przed faktyczną nazwą elementu ( ;"Si"); wystarczy dołączyć ]W=na końcu kodu, aby usunąć wszystko oprócz najwyższego elementu stosu. 3. To powoduje, że kilka bloków jest pustych. Jeśli Bjest wartością logiczną B{...}{}?i B{...}*osiąga to samo. 4. trójargumentowy jeśli bierze bloki lub elementy stosu, dzięki czemu można skrócić {"Si"}do "Si".
Dennis
@Dennis Myślę, że dodałem to wszystko. Zarządzanie stosami wymaga pracy, jednak - zbyt wielu _i ;wszędzie
@Dennis I ogoliłem kilka znaków, zmieniając domyślną wielkość liter na małe litery i używając więcej bloków
3

PHP, 507 485 476 466 znaków

Zastosowanie: wprowadź nazwę elementu jako parametr GET „0” - elements.php? 0 = węgiel

Algorytm: Przeprowadź ciąg danych, wyciągając podciąg, pary kodów skrótów. Jeśli podłańcuch pasuje do początku przekazywanego elementu, użyj kodu skrótu, aby określić, co ma zostać wyprowadzone: Jeśli kod zaczyna się na literę, wyślij go jako ciąg. Jeśli jest to liczba N, wypisz pierwszą literę elementu + N literę. Elementy Unun są specjalnie opatrzone kodem „|”. Jeśli nie znaleziono podłańcucha pasującego do przekazanej nazwy, wypisz pierwsze dwa znaki nazwy jako skrót.

Czytelny kod:

<?
$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];

Skondensowany:

<?$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
źródło
2

JavaScript (1100)

Naiwna realizacja lśni w swojej prostocie. Unikalny ciąg podrzędny od początku nazwy jest po prostu mapowany na symbol.

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

Python - 652 649 637

Moja tabela skrótów opiera się na kombinacji każdej sekundy i co trzeciego znaku wielkiej litery:

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

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

Prawdopodobnie jest miejsce na ulepszenia, zwłaszcza kompresję dwóch długich łańcuchów.

Testowane z:

for short, name in table:
    if f(name) != short:
        print "Wrong result!"
Falko
źródło
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?=

Wyjaśnienie:

{        }%                              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
źródło
11
OMG, kawałek Golfscript, który nie ma 10 znaków lub mniej!
WallyWest
1
Możesz uzyskać ogromną poprawę tej tablicy ciągów, używając jednego ciągu z znakiem nowej linii jako separatora, a następnie wykonującn/
Peter Taylor
Zrobiłem to ostatni raz, dlaczego, do cholery, nie pomyślałem o tym? Aktualizuję teraz.
Josiah Winslow
2

Haskell, 920 817 807 776 znaków

Po zbyt długiej pracy nad stworzeniem systemu reguł dla tego, jakie znaki nazwy elementu są zawarte w jego symbolu, i trochę majsterkowania, udało mi się napisać skrypt, który łatwo tłumaczy element na symbol. Żelazo było dla mnie problemem, ponieważ mogłem próbkować niektóre znaki z GOld, SilVer, TiN, LEad, SoDium, MerCury, ANtimony, PotaSsium i TUngsten, przekształcając je w nieużywany symbol okresowy (wybrałem dowolne próbkowanie, które ułatwiło integrację je do istniejących reguł), a następnie tłumaczenie po symbolicznej konwersji; Jednak żelazo stanowiło problem, ponieważ Ir, Io i In są już używane. Początkowo było to 920 znaków, ale zdałem sobie sprawę, że ostateczne dopasowanie wzorca (największe) nie musiało tam być, ponieważ albo pozwalało rzeczom przejść (co nie było), albo pasowało do nich wszystkich; w związku z tym, Zamieniłem go na symbol wieloznaczny typu catch-all. Następnie grałem w golfa od 817 do 808, skracając niektóre wzory za pomocą symboli wieloznacznych w taki sposób, że wciąż były unikalne dla tej nazwy elementu (np. Jedynym elementem z literą „w” w nazwie jest Lawrencium, więc „* w ”pasuje do tego o 1 mniej niż znak„ Prawo ”).

Oto mój kod. Przetestowałem go dla wszystkich elementów i zakodowałem go tak, aby automatycznie przekonwertował dane wejściowe na titlecase, więc nie ma problemów z rozróżnianiem wielkości liter.

EDYCJA 1

Ponadto zmniejszyłem go do 776 znaków, zastępując wyrażenie case wt dopasowaniem wzorca (ma to sens, ponieważ wyrażenie case testowało surowy operand w przeciwieństwie do wyrażenia pod względem argumentu), usuwając niepotrzebne nawiasy i ponownie wyrażając ejako ciąg rozdzielany znakiem nowej linii zamiast listy ciągów, a następnie dzieląc go w funkcji głównej. Ponieważ zmiany te mają charakter wyłącznie golfowy, nie zmieniłem wersji czytelnej dla człowieka.

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

Wersja czytelna dla człowieka (nowe linie, odstępy, pełne nazwy, komentarze: 2311 znaków)

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

Jeśli ktoś jest zainteresowany wyjaśnieniem jakiejkolwiek części tego pytania, możesz zapytać.

archaephyrryx
źródło
2

C # (826)

nie największy, ale pomyślałem, że spróbuję z handicapem c #.

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

Napisałem więc program, który przekształca pełną nazwę elementów (np. Węgiel) na najmniejszy, ale wciąż unikalny ciąg i zrobiłem to dla wszystkich elementów w odniesieniu do wszystkich innych unikalnych ciągów. Następnie zszeregowałem to do dużego brzydkiego łańcucha, w którym wielkie litery oznaczają początek „fragmentów”, przy czym fragmenty są naprzemiennie między kluczem a wartością. Jak KeyValueKey2Value2 itp.

Ten skrypt destyluje ten duży ciąg i odcina znak na końcu wprowadzonego ciągu, dopóki nie znajdzie go w słowniku utworzonym z dużego ciągu.

(Powinienem dodać, że moja znajomość języka C # nie jest niesamowita, a pierwotne zgłoszenie polegało na użyciu rzeczy, które znałem, ale później miałem inne sztuczki wskazane mi przez innych.)

miethpo
źródło
Możesz dalej grać w golfa, zmieniając wszystkie definicje typów na var. Możesz zaoszczędzić jeszcze kilka, usuwając nawiasy klamrowe po blokach pojedynczej instrukcji. Jeśli przypiszesz t.Substring(int, int)do Func<int, int, string>, możesz zapisać inną parę.
Brandon
Zrobiłem większość zmiennych def "var", ale wydaje mi się, że przegapiłem jedną lub dwie, a także całkowicie zapomniałem o bez wsporników ifs, dzięki.
miethpo
Można golić kolejne 5 znaków przez varing string[] ri przez kolejne 3 varing string t = Console....wreszcie, można zaoszczędzić 7 Więcej zmieniając return new string[]się return new[]na samym końcu.
Brandon
Istnieje kilka innych drobnych usprawnień, które można wykonać, takich jak przeniesienie if(...) break;logiki do warunków wyjścia dla pętli for. Można zastosować szereg innych inwersji logicznych, na przykład do { } while(..)w metodzie wyodrębniania. Jest to krótsze niż dodanie oddzielnej operacji logicznej dla przypadku wprowadzania. Opublikowałem w Twoim kodzie edycję, która wciąż wymaga przeglądu / akceptacji z powodu mojej niskiej liczby powtórzeń w tej witrynie. Sprowadziłem go do 870 znaków.
nicholas
1
@Nicholas Nie jestem pewien, czy edytowanie cudzego kodu golfowego jest grzeczne ...
miethpo
1

JavaScript (E6) 1433

Oto un górny limit

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

Przetestuj w konsoli FireFox / FireBug

F('Rutherfordium')

Wynik

Rf
edc65
źródło
1

SmileBASIC, 1763 1418 1204 1128 bajtów

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$

Wybrałem 3 postacie, które były w większości unikalne (0, 2 i 3), co pozostawia 2 przypadki szczególne: Cerium / Curium to „Ciu”, a Ruthenium / Rutherfordium to „Rhe”. W przypadku Ciu sprawdzam, czy drugim znakiem w nazwie jest „e” lub „E”, aw przypadku „Rhe” sprawdzam długość nazwy.

VAR(name)zwraca zmienną o tej nazwie. Nazwy zmiennych nie uwzględniają wielkości liter.

12Me21
źródło
0

T-SQL, 900 894 676 bajtów

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

Zwroty służą wyłącznie do odczytu, druga linia to jeden bardzo długi ciąg.

STRING_SPLIT jest obsługiwany w SQL 2016 i nowszych wersjach.

Dane wejściowe są pobierane za pomocą wcześniej istniejącej tabeli tz polem varchar e , zgodnie z naszymi standardami IO . Wyjście jest wypełnione spacjami do 3 znaków; zasady były niejasne, czy to było w porządku. W razie potrzeby mogę dodać TRIM.

Tabela wejściowa jest połączona z tabelą wygenerowaną z listą wszystkich symboli elementów (uzupełnionych do 3 znaków) z najkrótszym unikalnym prefiksem dla każdej nazwy elementu ( Xwystarcza dla Xenon , ale Rutherfordium wymaga Rutherodróżnienia go od rutenu ).

EDYCJA 1 : Zapisano 218 znaków, usuwając 44 wpisy z listy, której symbolem są dwie pierwsze litery ich nazwy; ISNULLfunkcja służy do sprawdzenia, czy pierwsze zapytanie nie zwróci wiersza, a jeżeli tak, generuje symbol (odpowiednio) z powlekanego nazwy elementu wejściowego.

BradC
źródło