Періодична таблиця елементів - код гольфу


47

На базі Практичного гольфу - США

Ваше завдання - знайти абревіатуру (символ) елемента, який задається назвою елемента, аж до унукокцію (118). Використовуйте періодичну таблицю у Вікіпедії .

Завдяки кричущому кості, ви можете знайти повний список елементів до абревіатур на http://pastebin.com/DNZMWmuf .

Ви не можете використовувати будь-які зовнішні ресурси. Крім того, ви не можете використовувати будь-які вбудовані дані конкретно про елементи періодичної таблиці. Застосовуються стандартні лазівки.

Вхідні дані

Вхідні дані можуть бути зі стандартного вводу, файлу, prompt,input і т.д.

Формат введення:

Усі наведені нижче дані є дійсними введеннями:

Carbon
carbon
CARBON
cArBOn

По суті, назва елемента - регістр нечутливий.

Вам не потрібно обробляти неправильні написання чи будь-яке недійсне ім’я елемента. Неправильне введення - це невизначена поведінка.

Вихід :

Символ для елемента. Перший символ повинен бути капіталізовані , а решта сусло бути в нижньому регістрі.

Приклад виводу: C

Тестові приклади:

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

Елементів є набагато більше, ніж держав, тому я думаю, що для них буде важче знайти загальне правило.

Це код гольфу. Найкоротший код виграє!


4
@squeamishossifrage Дякую Обидві версії ("сірка" та "сірка") є прийнятними. Ваша програма не повинна обробляти обидві, однак, лише одну.
soktinpk

1
... неможливо зробити з регулярними виразами. Ви добре нас зробили.
Джосія Уінслоу

2
@Xrylite Спробуйте прочитати правила: " Введіть ... ім'я елемента - нечутливий до регістру ... Виведення ... Перший символ має бути написаний з великої літери, а решта має бути малі".
Джим Балтер

2
А як щодо правильного написання (Алюміній) проти американського правопису (Алюміній)?
Пол Р

4
@codebreaker Так, якщо введення даних не вірно, програма може вийти з ладу, зависнути, надрукувати Auабо все, що вам потрібно. @Paul R Якщо існує багато способів написання елемента (наприклад, сірка проти сірки або алюміній проти алюмінію), використовуйте те, що робить вашу програму коротшою. Вам не доведеться займатися обома справами.
soktinpk

Відповіді:


27

CJam, 337 297 293 232 220 201 200 байт

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

У наведеному вище коді використовується позначення каретки, оскільки він містить контрольні символи.

Ціною 24 додаткових байтів (всього 224) цих символів можна уникнути.

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

Ви можете спробувати цей код в інтерпретаторі CJam .

Тестові справи

$ 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

Як це працює

Перший крок - прочитати ім'я елемента з STDIN і застосувати досить розроблену хеш-функцію, яка відображає всі назви елементів у діапазоні [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.                                                  ";

Багато символів елементів утворені першим і другим, першим і третім, першим і четвертим, першим і п'ятим або першим і десятим (що є лише першим) символом англійського імені елемента. Ми будемо представляти ці елементи цифрами від 0 до 4 відповідно. Для всіх елементів (представлених 5) потрібна таблиця пошуку.

Отриману таблицю можна натиснути так:

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

Масив символьних кодів перетворюється з бази 256 на базу 7 і 6, замінюється пробіжками з трьох 0.

Це таблиця рішень 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]

Необхідна дія для елемента з хешем 1 , наприклад, відповідає першому елементу цього масиву. Елементи масиву, які не відповідають хешу жодного елемента, також дорівнюють нулю, що дозволяє (0 0 0) ↦ 6 стиснути .

Тепер ми інтерпретуємо D для хеш-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        ";

Далі натискаємо на таблицю пошуку. Якщо ми додамо j до односимвольних символів і замінимо Uu на Q , кожен символ буде мати рівно два символи. Його можна натиснути так:

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

Масив символьних кодів перетворюється з бази 256 в базу 25, код символу A додається до всіх цифр (відтворення символу в процесі) і результат розбивається на шматки довжиною два.

Це таблиця пошуку L:

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

Тепер переходимо до обчислення імен потенційних елементів.

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

Стек тепер містить

B M N

де B - булева D [H-1] / 5 , M - ім'я, отримане з таблиці пошуку a N - ім'я елемента, утворене вибором символів з E.

Ми майже закінчили:

?                " If B, push M; else, push N.                                            ";
( \              " Extract the first character from the string.                           ";
el               " Convert the rest to lowercase.                                         ";

Але як це працює?
Клавдіу

2
@Claudiu: Я додав пояснення.
Денніс

3
Я прочитав першу третину пояснення, і поки що у мене є "Магія". Неймовірно
Mooing Duck

7
"AcAlAmSbArAsAtBaBkBeBiBhBBrCdCsCaCfCCeClCrCoCnCuCmDsDbDyEsErEuFmFlFFrGdGaGeAuHf HsHeHoHInIIrFeKrLaLrPbLiLvLuMgMnMtMdHgMoNdNeNpNiNbNNoOsOPdPPtPuPoKPrPmPaRaRnReRh RgRbRuRfSmScSgSeSiAgNaSrSTaTcTeTbTlThTmSnTiWUuoUupUusUutUVXeYbYZnZr" = 226 символів. Ваше рішення = 200 символів. Тут відбувається якийсь належний вуду.
писклива косточка

Я прийняв цю відповідь, оскільки вона, здається, є найкоротшою, але не соромтеся розміщувати додаткові відповіді.
soktinpk

43

С, 452

Хороша хеш-функція допомагає. Можуть бути і кращі. (Покращення, запропоновані @ugoren та ін.)

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

Безголівки з коментарями:

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

Я застосував грубу силу, щоб знайти цей хеш; Це був єдиний розмір хеша ≤512, у якого не було зіткнень. Я не перевіряв альтернативні написання, але можуть бути кращі функції з різними алгоритмами (наприклад, використання XOR замість додавання).

Хеш-функція відображає текстові рядки до значень від 0 до 440. "Олово" хешируется до нуля, тому "Sn" знаходиться в початку таблиці. Наступні 7 позицій порожні. Щоб зберегти код компактним, це вказується значенням ASCII 34 + 7 = 41 (")"). Далі йде "Мідь" (8), чотири порожні комірки (34 + 4 = 38 = "&") та "Ванадій" (13). Після обчислення хеша програма переходить через таблицю, віднімаючи 1 для кожної великої літери, а потім 0 ​​або більше малих літер, і віднімання (ASCII VALUE) -34 для кожного символу, що не використовується алфавітом. Коли значення досягає нуля, ми знайшли правильний результат.


3
@soktinpk Brute змусив це :-) Це був єдиний розмір хеша ≤512, у якого не було зіткнень. Я не перевіряв альтернативні написання, і можуть бути кращі функції з різними алгоритмами (наприклад, використання XOR замість додавання).
пискливе костенеж

2
Зробіть, що 464 ... у вас є непотрібна пара брекетів.
Джим Балтер

1
Якщо ви думаєте про граматику, це однозначне і повинно бути дозволено ... він просто виглядає неоднозначним нас . О, і ти зловив ще одного, якого я не зробив! Вітаю з цим ... Я дуже намагався підтягнути алгоритм, але у вас все правильно.
Джим Балтер

5
@Harshdeep - хеш-функція відображає текстові рядки на значення від 0 до 440. "Олово" хешируется до нуля, тому "Sn" знаходиться в початку таблиці. Наступні 7 позицій порожні. Щоб зберегти код компактним, це вказується значенням ASCII 34 + 7 = 41 (")"). Далі йде "Мідь" (8), чотири порожні комірки (34 + 4 = 38 = "&") та "Ванадій" (13). Після обчислення хеша програма переходить через таблицю, віднімаючи 1 для кожної великої літери, а потім 0 ​​або більше малих літер, і віднімання (ASCII VALUE) -34 для кожного символу, що не використовується алфавітом. Коли значення досягає нуля, ми знайшли правильний результат.
пискливе костіння

2
Хороший. Зберегти деякі символи з: 1. (h+c%32+74)*311%441. 2. Викиньте pі використовуйте s. 3. main(c)зберігає одну кому.
угорен

13

JavaScript ES6, 690 708 байт

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)

Перший масив містить символи, а другий масив містить мінімальні літери, необхідні для того, щоб повідомити про який елемент йдеться. Завдяки core1024 та edc65 за допомогу в скороченні. Тест на http://jsfiddle.net/xjdev4m6/2/ . Трохи читабельніше:

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

Чи можете ви поголити кілька байтів, використовуючи той факт, що Neo відповідає неодиму, враховуючи, що Неон був переданий у списку?
Dancrumb

1
@Dancrumb На жаль, ні. Цикл починається з найкоротшого підрядка, тому він потраплятиме Neoдо того, як потрапить, Neonоскільки має менше літер.
NinjaBearMonkey

1
+1 за найкоротший JS досі. Хоча ви можете позбутися цього ifтвердження (Це ідеальна forумова), а також вбудувати чи змістити позиції деяких змінних, щоб скоротити код;)
core1024

2
на початку ).toLowerCase(-> )[L='toLowerCase'](потім у кінці a.toLowerCase(-> a[L](слід скоротити 4 символи
edc65

10

Ruby 1.9+, 565 471 447 444

Однолінійний. Тому що нічого не можна зробити з регулярними виразами ...
(Просто збережено 94 символи, додавши ще один регулярний вираз) ((і 24, спростивши їх))

p"VAlAmA.sArAcAnt|SbA.tBaB..kBeBiB.hBrBDyD.+sD.bE..sErEuF..mFrFlu|F@FlG.dGaGeG|AuH.fH.sHeHoHInIro|FeIrIKrL.vL.+rLaLiLuL|PbM.gMoM.+dM.nM.+tM|HgC.+sC.dC.+fCeCar|C@C....nCaCu|CmCop|CuCoC.rC.lN.+dN.+pNeN..bNit|N@NoNiOsOP..mPa|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/,''

(Новий рядок після рядка додано для "читабельності", видаліть для тесту)

використання: ruby periodic.rb aluminum$>

Пояснення:
Розбиття рядка на провідні регістри повертає масив регулярних виразів, щоб вони відповідали іменам елементів. Єдині алфавітні символи, дозволені в кожному, - це символи із абревіатури *. Вони впорядковані таким чином, що перший збіг, знайдений при порівнянні з аргументом командного рядка, *$*є правильним. Попередня gsub викреслює не-альфа-символи перед друком.

* Непарні абревіатури типу "Fe" для "Iron" обробляються |елементом: "Iro | Fe". Перший вибір - це те, що насправді відповідає; Потім gsub видаляє всі символи до "|", залишаючи фактичну абревіатуру.

Тестовий фреймворк (потрібен список @ squeamish: завантажений як 'table.txt' у робочому каталозі).

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

1
Постійні овації, якщо це працює для всіх 100+ випадків
edc65

Звичайно, це працює: ideone.com/7FZlAt
AShelly

У кожного є зухвалість стверджувати, що не можна зробити з регулярними виразами. Дякуємо, що довели їх (один сказав, багато хто вважав) неправильними :)
Маст

4

Рубі, 1068 байт

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]

Введення через STDIN.

Найкоротші унікальні підрядки імен елементів - від другого до шостого символу (або кінця імені, якщо воно занадто коротке). Тому я просто дістаю їх і роздивляю їх у хеш. Я також стиснув хеш, тому що це економить ще 200 байт. Ось як виглядає сам хеш:

{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"}

3

CJam, 462 449 434 401 391 384 382

За допомогою Денніса.

Код

Вкладені потрійні ifs, ймовірно, не є правильним способом зробити це в 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=

З відступами:

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=

Багато символів - це лише перші дві літери імені елемента. Вони обробляються у другому найглибшому шарі вкладених операторів. Багато інших - це перша і третя літера, або перша і четверта літера - вони обробляються в послідовних зовнішніх шарах. Символи, де відображається лише перша буква, і повні нерегулярні знаряддя, обробляються відповідно в п'ятому та третьому найглибших шарах.

Є кілька, де це плутається ( TelLuriumvs ThaLlium, або SILiconvs SILver, або RUTheniumvs RUTherfordium). Вони обробляються окремо.

Тут можна було б зробити багато гольфу, в основному за рахунок повторного використання кодових блоків та покращення керування нерегулярними правилами.


1
Кілька порад: 1. Поведінка недійсних імен елементів може бути невизначеною, тож, ніж "RUTHENIUM"=ви можете використовувати "RUTHEN"#!. 2. Вам не потрібно друкувати явно ( o) і нічого не видаляти перед фактичним назвою елемента ( ;"Si"); просто додайте ]W=до кінця свого коду, щоб видалити все, крім самого верхнього елемента стека. 3. Це робить кілька блоків порожніми. Якщо Bбулевий, B{...}{}?і B{...}*досягайте того ж. 4. Потрійний, якщо займає блоки або стеки елементів, тому можна скоротити {"Si"}до "Si".
Денніс

@Dennis Я думаю, що я все це додав. Управління стеком потребує роботи, хоча - занадто багато _і в ;усьому місці

@Dennis І я відголив декілька символів, змінивши регістр за замовчуванням на малі та використовуючи блок псевдонімів кодів більше

3

PHP, 507 485 476 466 символів

Використання: введіть назву елемента як параметр GET '0' - elements.php? 0 = carbon

Алгоритм: Проведіть по рядку даних, витягуючи підрядку, абревіатурні кодові пари. Якщо підрядник відповідає початку переданого елемента, використовуйте код абревіатури, щоб визначити, що вивести: Якщо код починається з літери, виведіть його як рядок. Якщо це число N, виведіть першу букву елемента + N-й лист. Елементи Unun мають спеціальний чек з кодом '|'. Якщо не знайдено жодної підрядки, яка б відповідала імені, яке було передано, виведіть перші два символи імені як абревіатуру.

Читаний код:

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

Конденсований:

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

2

JavaScript (1100)

Наївна реалізація світиться своєю простотою. Унікальний підрядний рядок від початку імені просто відображається на символ.

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

2

Пітон - 652 649 637

Моя хеш-таблиця заснована на поєднанні кожної секунди та кожного третього символу з великого імені:

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

Ось відповідний генератор:

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'

Можливо, є можливість вдосконалення, особливо стискання двох довгих струн.

Тестували:

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

2

Гольфскрипт - 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?=

Пояснення:

{        }%                              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.

11
OMG, фрагмент Golfscript, який не має 10 символів або менше!
WallyWest

1
Ви можете отримати значне поліпшення цього масиву рядків, скориставшись одним рядком з новою лінією в якості роздільника, а потім зробити цеn/
Пітер Тейлор

Я робив це минулого разу, чому, чорт, не думав про це? Оновлення зараз.
Джосія Уінслоу

2

Хаскелл, 920 817 807 776 Chars

Занадто довго працюючи над створенням правил для того, які символи імені елементів входять до його символу, і трохи поворухнувшись, мені вдалося написати сценарій, який легко переводить елемент на символ. Залізо було проблемою для мене, тому що я міг вибирати певні символи з GOld, SilVer, TiN, LEad, SoDium, MerCury, ANtimony, PotaSsium та TUngsten, перетворюючи їх у невикористаний періодичний символ (я вибрав той вибір, який спростив інтеграцію. їх у існуючі правила), а потім переклад після символічного перетворення; Однак залізо було проблемою, оскільки Ір, Іо та Ін вже використовуються. Спочатку це було 920 символів, але я зрозумів, що остаточний збір шаблонів (найбільший) там не повинен бути, оскільки він або пропускає речі (чого не було), або відповідає всім; тому Я замінив його загальним символом. Після цього я продовжив гольфувати з 817 до 808, скорочуючи деякі шаблони, використовуючи символи підрядних символів таким чином, що вони все ще були унікальними для цього імені елемента (наприклад, єдиний елемент із символом "w" - Lawrencium, тому "* w "відповідає тому, що на 1 менше символу, ніж" Закон ").

Ось мій код. Я перевірив його на всіх елементах, і зашифрував його так, щоб він автоматично перетворив свої дані в регістр заголовків, тому не виникало проблем з чутливістю до регістру.

ЗРІД 1

Далі я зменшив його до 776 символів, замінивши вираз регістру у t на відповідність шаблону (це має сенс, оскільки вираз регістру тестував необроблений операнд на відміну від виразу в операнді), видаляючи непотрібні дужки та повторно виражаючи eяк рядки з обмеженим рядком, а не списком рядків, а пізніше розділяючи його на головну функцію. Оскільки ці зміни є суто гольфними, я залишив читану людиною версію незмінною.

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

Прочитана людиною версія (нові рядки, пробіли, багатослівні назви, коментарі: 2311 символів)

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

Якщо когось цікавить пояснення будь-якої частини цього, сміливо запитайте.


2

C # (826)

не найбільший, але я думав, що спробую це з гандикатом 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;}}}

Тому я написав програму, щоб перетворити повну назву елементів (наприклад, карбон) в найменший, але все ж унікальний рядок, і зробив це для всіх елементів стосовно всіх інших унікальних рядків. Потім я це серіалізував у велику некрасиву рядок, де великими літерами позначають початок "шматки", при цьому шматки чергуються між ключами та значеннями. Як KeyValueKey2Value2 і т.д.

Цей скрипт дестерилізує цю велику рядок і відрізає символ з кінця введеного рядка, поки він не знайде його у словнику, зробленому з великої рядка.

(Я повинен додати свої знання C # не дивовижно. Оригінальне подання, яке я зробив, - це просто використання речей, які я знав, але згодом у мене були вказані деякі хитрощі.)


Ви можете додатково пограти в гольф, змінивши всі визначення типів на var. Ви можете зберегти ще кілька, видаливши дужки після одноразового, якщо блокує. Якщо ви призначите t.Substring(int, int)собі Func<int, int, string>, можете зберегти ще одну пару.
Брендон

Я зробив найбільш змінну defs "var", але, здається, я пропустив один-два, а також зовсім забув про безглузді ifs, дякую.
miethpo

Ви можете поголити ще 5 символів, varвикористовуючи string[] rі ще 3, varвикористовуючи string t = Console...., нарешті, ще 7 заощадите, змінивши return new string[]їх return new[]у самому кінці.
Брендон

Існує кілька інших незначних удосконалень, які ви можете виконати, наприклад, переміщення if(...) break;логіки в умови виходу з циклу. Можна застосувати ряд інших логічних перетворень, наприклад, do { } while(..)у вашому методі вилучення. Це коротше, ніж додавання окремої логічної операції для випадку введення. Я опублікував редагування вашого коду, яке все ще потребує перегляду / прийняття через низьку кількість представників на цьому сайті. Зменшив його до 870 символів.
ніколас

1
@Nicholas Я не впевнений, що редагування чужого коду гольфу є ввічливим ...
miethpo

1

JavaScript (E6) 1433

Тут є верхня межа ООН

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

Тест в консолі FireFox / FireBug

F('Rutherfordium')

Вихід

Rf

1

SmileBASIC, 1763 1418 1204 1128 байт

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$

Я вибрав 3 символи, які були здебільшого унікальними (0-й, 2-й та 3-й), що залишає два особливих випадки: Церій / Курій - це "Ciu", а Rhetenium / Rutherfordium - обидва "Rhe". Для Ciu я перевіряю, чи є другий символ імені "e" або "E", а для "Rhe" я перевіряю довжину імені.

VAR(name)повертає змінну з цим ім'ям. Назви змінних залежать від регістру.


0

T-SQL, 900 894 676 байт

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

Повернення призначені лише для читання, другий рядок - один дуже довгий рядок.

STRING_SPLIT підтримується в SQL 2016 та новіших версіях.

Введення проводиться через попередньо існуючу таблицю t із варчарським полем e , відповідно до наших стандартів IO . На виході є пробіли до 3 символів; правила були незрозумілі, чи це нормально. Якщо потрібно, я можу додати аTRIM .

Таблиця введення поєднується з таблицею, згенерованою зі списком усіх символів елементів (доданих до 3 символів) з найкоротшим унікальним префіксом для кожного імені елемента ( Xдостатньо для Xenon , але Rutherfordium вимагає, Rutherщоб відрізняти його від Ruthenium ).

Редагування 1 : збережено 218 символів, видаливши 44 записи зі списку, символом яких є перші дві літери їх імені; ISNULLфункція використовується , щоб побачити , якщо перший запит не повертає рядок, і якщо так, генерує символ (правильно обсаджений) від імені вхідного елемента.

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.