Периодическая таблица элементов - Код Гольф

47

Основано на Практическом Гольфе - США

Ваша задача - найти аббревиатуру (символ) элемента с указанным именем элемента, вплоть до ununoctium (118). Используйте периодическую таблицу в Википедии .

Благодаря Squeamish Ossifrage, вы можете найти полный список элементов к аббревиатурам на http://pastebin.com/DNZMWmuf .

Вы не можете использовать какие-либо внешние ресурсы. Кроме того, вы не можете использовать какие-либо встроенные данные конкретно об элементах периодической таблицы. Применяются стандартные лазейки.

вход

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

Формат ввода:

Все следующие данные являются действительными:

Carbon
carbon
CARBON
cArBOn

По сути, имя элемента - без учета регистра.

Вам не нужно обрабатывать орфографические ошибки или любое неверное имя элемента. Неверный ввод - неопределенное поведение.

Выход :

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

Пример вывода: C

Тестовые случаи:

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

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

Это код гольф. Самый короткий код выигрывает!

soktinpk
источник
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 заменяются сериями из трех нулей.

Это таблица решений 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 , например, соответствует первому элементу массива this. Элементы массива, которые не соответствуют ни одному хешу элемента, также равны нулю, что позволяет сжатие (0 0 0) compression 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 - имя, полученное из таблицы поиска, а 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
Я прочитал первую треть объяснения, и пока что у меня есть «Магия». Невероятно
мычанка
7
"AcAlAmSbArAsAtBaBkBeBiBhBBrCdCsCaCfCCeClCrCoCnCuCmDsDbDyEsErEuFmFlFFrGdGaGeAuHf HsHeHoHInIIrFeKrLaLrPbLiLvLuMgMnMtMdHgMoNdNeNpNiNbNNoOsOPdPPtPuPoKPrPmPaRaRnReRh RgRbRuRfSmScSgSeSiAgNaSrSTaTcTeTbTlThTmSnTiWUuoUupUusUutUVXeYbYZnZr" = 226 символов. Ваше решение = 200 символов. Здесь происходит настоящее вуду.
брезгливое оссифраж
Я принял этот ответ, потому что он кажется самым коротким, но не стесняйтесь размещать дополнительные ответы.
soktinpk
43

С, 452

Хорошая хеш-функция помогает. Там могут быть лучше. (Улучшения, предложенные @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);}

Разоблаченный с комментариями:

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. «Tin» хэшируется до нуля, поэтому «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. "Tin" хэшируется в ноль, поэтому "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
  }
}
NinjaBearMonkey
источник
Можете ли вы сбрить некоторые байты, используя тот факт, что Neo соответствует Neodymium, учитывая, что Neon был пропущен в списке?
Dancrumb
1
@Dancrumb К сожалению, нет. Цикл начинается с самой короткой подстроки, поэтому он попадет Neoдо того, как попадет, Neonпотому что в нем меньше букв.
NinjaBearMonkey
1
+1 за самый короткий JS до сих пор. Хотя вы можете избавиться от этого ifутверждения (это идеальное forусловие), а также встроить или сместить позиции некоторых переменных, чтобы сократить код;)
core1024
2
в начале ).toLowerCase(-> )[L='toLowerCase'](затем в конце a.toLowerCase(-> a[L](следует вырезать 4
символа
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» для «железа», обрабатываются |элементом: «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")
AShelly
источник
1
Постоянные аплодисменты, если это работает для всех 100+ случаев
edc65
Конечно, это работает: ideone.com/7FZlAt
AShelly
У каждого есть смелость утверждать, что что-то не может быть сделано с помощью регулярных выражений. Спасибо за доказательство их (один сказал, многие думали) неправильно :)
Mast
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=

Многие символы - это только первые две буквы имени элемента. Они обрабатываются на втором по глубине уровне вложенных операторов if. Многие другие являются первой и третьей буквой или первой и четвертой буквой - они обрабатываются в последовательных внешних слоях. Символы, где появляется только первая буква, и полные нерегулярные символы обрабатываются в пятом и третьем самых глубоких слоях соответственно.

Есть несколько, где это запутывается ( TelLuriumпротив ThaLliumили SILiconпротив SILver, или RUTheniumпротив RUTherfordium). Они обрабатываются отдельно.

Здесь можно много поиграть в гольф, в основном путем повторного использования блоков кода и улучшения обработки нерегулярных кодов.


источник
1
Несколько советов: 1. Поведение для недопустимых имен элементов может быть неопределенным, поэтому "RUTHENIUM"=вы не сможете его использовать "RUTHEN"#!. 2. Вам не нужно oни явно печатать ( ), ни удалять что-либо до фактического имени элемента ( ;"Si"); просто добавьте ]W=в конец своего кода, чтобы удалить все, кроме самого верхнего элемента стека. 3. Это делает несколько блоков пустыми. Если Bэто логическое значение, B{...}{}?и B{...}*достичь того же. 4. Троичный, если принимает блоки или элементы стека, так что вы можете сократить {"Si"}до "Si".
Деннис
@ Денис Я думаю, что я добавил все это. Управление стеками требует работы, хотя - слишком много _и ;повсеместно
@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];
Sir_Lagsalot
источник
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

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

Объяснение:

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

Haskell, 920 817 807 776 символов

После слишком долгой работы над созданием системы правил для того, какие символы имени элемента включаются в его символ, и немного переделок, мне удалось написать скрипт, который легко переводит элемент в символ. Железо было для меня проблемой, потому что я мог выбрать некоторые символы из GOld, SilVer, TiN, LEad, SoDium, MerCury, ANtimony, PotaSsium и TUngsten, преобразовав их в неиспользуемый периодический символ (я выбрал тот, который делал выборку проще для интеграции их в существующие правила), а затем переводить после символического преобразования; Железо, однако, было проблемой, потому что Ir, Io и In все уже используются. Первоначально это было 920 символов, но я понял, что не должно быть там последнего совпадения с шаблоном (самое большое), поскольку оно либо пропускало вещи (чего не было), либо соответствовало всем; следовательно, Я заменил его универсальным подстановочным знаком. После этого я продолжил игру в гольф с 817 по 808, сокращая некоторые паттерны с использованием подстановочных знаков таким образом, чтобы они все еще были уникальными для этого имени элемента (например, единственный элемент с буквой 'w' в названии - Lawrencium, поэтому "* w "соответствует тому, что на 1 символ меньше, чем" Law ").

Вот мой код. Я проверил его для всех элементов и закодировал так, чтобы он автоматически преобразовывал свои входные данные в заглавные буквы, чтобы не возникало проблем с чувствительностью к регистру.

РЕДАКТИРОВАТЬ 1

Я также уменьшил его до 776 символов, заменив выражение case в t на совпадение с шаблоном (это имеет смысл, поскольку выражение case проверяло необработанный операнд, а не выражение в терминах операнда), удаляя ненужные скобки и повторно Выражение 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

Если кто-то заинтересован в объяснении какой-либо части этого, не стесняйтесь спрашивать.

archaephyrryx
источник
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;}}}

Поэтому я написал программу для преобразования полного имени элементов (например, carbon) в наименьшую, но все же уникальную строку, и сделал это для всех элементов относительно всех других уникальных строк. Затем я сериализовал это в большую уродливую строку, где заглавные буквы обозначают начало «чанков», чанки чередуются между ключами и значениями. Как KeyValueKey2Value2 и т. Д.

Этот скрипт стерилизует эту большую строку и обрезает символ с конца введенной строки, пока не найдет его в словаре, составленном из большой строки.

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

miethpo
источник
Вы можете сделать это дальше, изменив все определения типов на var. Вы можете сохранить еще несколько, удалив фигурные скобки после одного оператора if блоков. Если вы назначите t.Substring(int, int)для Func<int, int, string>вы можете сохранить еще одну пару.
Брэндон
Я сделал большинство переменных defs "var", но, кажется, я пропустил один или два, также совершенно забыл о ifless, спасибо.
Miethpo
Вы можете сбрить еще 5 символов, varиспользуя 3, string[] rи еще 3, varиспользуя string t = Console...., наконец, вы сэкономите еще 7, перейдя return new string[]в return new[]самый конец.
Брэндон
Есть несколько других незначительных улучшений, которые вы можете выполнить, например, перевести вашу if(...) break;логику в условия выхода цикла for. Можно применить ряд других логических инверсий, например, do { } while(..)в вашем методе извлечения. Это короче, чем добавление отдельной логической операции для случая ввода. Я разместил изменения в вашем коде, которые все еще нуждаются в проверке / принятии из-за моей низкой репутации на этом сайте. Получил до 870 символов.
Николай
1
@ Николас, я не уверен, что редактировать чужой код - это вежливо.
Miethpo
1

JavaScript (E6) 1433

Здесь верхний предел

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

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

F('Rutherfordium')

Выход

Rf
edc65
источник
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-й), что оставляет 2 особых случая: церий / кюрий - оба «Ciu», а рутений / рутерфордий - «Rhe». Для Ciu я проверяю, является ли второй символ имени «e» или «E», а для «Rhe» я проверяю длину имени.

VAR(name)возвращает переменную с этим именем. Имена переменных не чувствительны к регистру.

12Me21
источник
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 с полем varchar e , в соответствии с нашими стандартами ввода-вывода . Вывод дополнен пробелами до 3 символов; правила были неясны, было ли это нормально. При необходимости я могу добавить TRIM.

Входная таблица объединяется с таблицей, созданной со списком всех символов элемента (с добавлением 3 символов) с кратчайшим уникальным префиксом для каждого имени элемента ( Xдостаточно для ксенона , но Rutherfordium требует Rutherотличить его от рутения ).

РЕДАКТИРОВАТЬ 1 : сохранил 218 символов, удалив из списка 44 записи, символ которых - первые две буквы их имени; ISNULLфункция используется , чтобы увидеть , если первый запрос не возвращает строку, и если да, генерирует символ (правильно обсаженный) от имени входного элемента.

BradC
источник