47

您的任务是在给定元素名称的情况下找到元素的缩写（符号），最多为ununoctium（118）。使用Wikipedia上的元素周期表。

多亏了ossifrage，您可以在http://pastebin.com/DNZMWmuf找到完整的缩写元素列表。

您不得使用任何外部资源。此外，您可能不使用任何专门有关元素周期表元素的内置数据。有标准漏洞。

输入项

输入可以从标准输入，文件prompt，input等等。

输入格式：

以下所有有效输入：

Carbon
carbon
CARBON
cArBOn

本质上，元素名称-不区分大小写。

您不必处理拼写错误或任何无效的元素名称。无效的输入是未定义的行为。

输出：

元素的符号。第一个字符必须是大写，其余必须是小写。

输出示例： C

测试用例：

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

元素比状态多得多，因此我希望为这些元素找到一个通用规则会更加困难。

这是代码高尔夫。最短的代码胜出！

code-golf kolmogorov-complexity chemistry

— soktinpk
source

4

@squeamishossifrage谢谢。两种版本（“硫”和“硫”）都是可以接受的。您的程序不必同时处理两个，但是只能处理一个。

— soktinpk

1

...与正则表达式无关。你对我们很好。

— Josiah Winslow 2014年

2

@Xrylite尝试阅读规则：“ 输入 ...元素名称-不区分大小写... 输出 ...第一个字符必须大写，其余字符必须小写”。

— 吉姆·巴尔特

2

正确的拼写（铝）与美国的拼写（铝）呢？

— Paul R

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附加到单个字符符号上，并用Q替换Uu，则每个符号将恰好是两个字符长。可以按以下方式推送：

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

字符代码数组从256到25转换，将A的字符代码加到所有数字上（在过程中广播到Character），并将结果分成长度为2的块。

这是查找表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.                                         ";

— 丹尼斯
source

但是它是如何工作的呢？

— 2014年

2

@Claudiu：我添加了一个解释。

— 丹尼斯

3

我已经阅读了解释的前三分之一，到目前为止，我所拥有的是“魔术”。难以置信

— Mooing Duck 2014年

7

“AcAlAmSbArAsAtBaBkBeBiBhBBrCdCsCaCfCCeClCrCoCnCuCmDsDbDyEsErEuFmFlFFrGdGaGeAuHf HsHeHoHInIIrFeKrLaLrPbLiLvLuMgMnMtMdHgMoNdNeNpNiNbNNoOsOPdPPtPuPoKPrPmPaRaRnReRh RgRbRuRfSmScSgSeSiAgNaSrSTaTcTeTbTlThTmSnTiWUuoUupUusUutUVXeYbYZnZr”= 226个字符。您的解决方案= 200个字符。这里有一些适当的伏都教徒。

— 吱吱作响的ossifrage，2014年

我接受了这个答案，因为它似乎是最短的，但您可以随时发布其他答案。

— soktinpk

43

C，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的值。“ Tin”哈希值为零，因此“ Sn”位于表的开头。接下来的7个职位为空。为了使代码紧凑，用ASCII值34 + 7 = 41（“）”）表示。接下来是“铜”（8），四个空单元（34 + 4 = 38 =“＆”）和“钒”（13）。在计算完哈希值之后，程序将逐步浏览表格，对每个大写字母减去1，然后再加上0个或多个小写字母，对每个非字母字符减去（ASCII VALUE）-34。当值达到零时，我们找到了正确的结果。

— 吱吱作响的骨
source

3

@soktinpk Brute强制使用它:-)这是唯一一个哈希大小≤512且没有冲突的代码。我没有检查替代拼写，但是使用不同算法可能会有更好的功能（例如，使用XOR而不是加法）。

— 吱吱作响的ossifrage，2014年

2

设置为464 ...您有一副不必要的牙套。

— 吉姆·巴尔特

1

如果您考虑语法，那么它是明确的，必须被允许……对我们而言，它似乎模棱两可。哦，你抓到了另一个我没有的！祝贺您。。。我竭尽全力加强算法，但您一切都正确。

— 吉姆·巴尔特

5

@Harshdeep —哈希函数将文本字符串映射到0到440之间的值。“ Tin”散列为零，因此“ Sn”位于表的开头。接下来的7个职位为空。为了使代码紧凑，用ASCII值34 + 7 = 41（“）”）表示。接下来是“铜”（8），四个空单元（34 + 4 = 38 =“＆”）和“钒”（13）。在计算完哈希值之后，程序将逐步浏览表格，对每个大写字母减去1，然后再加上0个或多个小写字母，对每个非字母字符减去（ASCII VALUE）-34。当值达到零时，我们找到了正确的结果。

— 吱吱作响的ossifrage，2014年

2

好东西。保存一些字符：1 (h+c%32+74)*311%441。2.放下p并使用s。3. main(c)保存一个逗号。

— ugoren 2014年

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

— 忍者熊猴子
source

鉴于Neon已通过列表，您是否可以利用Neo与钕匹配的事实来节省一些字节？

— Dancrumb 2014年

1

@Dancrumb不幸的是没有。循环从最短的子字符串开始，因此它将在命中Neo之前命中，Neon因为它的字母较少。

— NinjaBearMonkey

1

到目前为止最短的JS +1。尽管您可以摆脱该if语句（这是一个完美的for条件），并且可以内联或移动某些变量的位置，但可以缩短代码；）

— core1024 2014年

2

开始).toLowerCase(-> )[L='toLowerCase'](然后结束a.toLowerCase(-> a[L](应该减少4个字符

— edc65

10

红宝石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在打印之前会去除非字母字符。

*“ Iron”之类的奇异缩写如“ 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")

— 贝壳
source

1

起立鼓掌，如果它适用于所有100多个案例

— edc65 2014年

当然可以使用：ideone.com/7FZlAt

— AShelly

一个人敢于陈述正则表达式无法完成的事情。感谢您证明他们（一个人说，很多想法）是错误的:)

— 2014年

4

Ruby，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"}

— 马丁·恩德
source

3

果酱 462449434401391384 382

在丹尼斯的帮助下。

码

在CJam中，嵌套三元ifs 可能不是正确的方法。

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语句的第二最深层中进行处理。许多其他字符是第一个和第三个字母，或者第一个和第四个字母-这些字符在连续的外层中处理。仅第一个字母出现的符号和完整的不规则符号分别在最深的第五层和第三层中处理。

有些地方会让人感到困惑（TelLuriumvs ThaLlium，SILiconvs SILver或RUTheniumvs 或vs RUTherfordium）。这些分别处理。

在这里可以进行很多打高尔夫球，主要是通过重用代码块和改进对不规则项的处理。

1

一些提示：1.无效元素名称的行为可能是不确定的，因此"RUTHENIUM"=您不能使用"RUTHEN"#!。2.您无需显式打印（o）或删除实际元素名称（;"Si"）之前的任何内容；只需追加]W=到代码末尾即可删除除最顶层堆栈元素以外的所有内容。3.这使几个块为空。如果B是一个布尔值，B{...}{}?并B{...}*达到相同的。4.三元if接受块或堆栈元素，因此可以缩短{"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];

— 拉格萨洛特爵士
source

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

— 米卡·拉米（Mika Lammi）
source

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

— 法尔科
source

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.

— 乔西亚·温斯洛
source

11

OMG，不超过10个字符的Golfscript片段！

— WallyWest

1

通过使用带换行符的一个字符串作为分隔符，然后执行此操作，可以对该字符串数组进行大规模的改进n/

— Peter Taylor

我上次这样做了，为什么我没想到呢？现在更新。

— 2014年

2

哈斯克尔，920 817 807 776个字符

在花了很长时间为符号中包含元素名称的哪些字符创建规则系统并进行了一些修补之后，我设法编写了一个脚本，可以轻松地将元素转换为符号。铁对我来说是个问题，因为我可以对Gold，SilVer，TiN，LEad，SoDium，MerCury，ANTimony，PotaSsium和TUngsten中的某些字符进行采样，然后将它们转换为未使用的周期符号（我选择了哪种采样方法使其集成起来最简单）将其转换为现有规则），然后在符号转换后进行翻译；但是，铁是一个问题，因为Ir，Io和In已全部使用。最初是920个字符，但是我意识到最终的模式匹配（最大）不需要存在，因为它要么让事物掉线（不是），要么全部匹配。因此，我用通用通配符代替了它。之后，我通过使用通配符缩写某些模式，从而使它们在该元素名称中仍然是唯一的（例如，名称中唯一带有“ w”的元素是Lawrencium），从而从817到808进一步打高尔夫球。 w“与“ Law”相比要少1个字符）。

这是我的代码。我对所有元素进行了测试，并对它进行了编码，以便它自动将其输入转换为大写，因此不区分大小写。

编辑1

通过使用模式匹配替换t中的case表达式，我将其进一步减少为776个字符（这是有道理的，因为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

如果有人有兴趣对此进行任何解释，请随时提出。

— 始祖鸟
source

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＃的了解并不惊人，我最初提交的内容只是使用了我所知道的东西，但后来我得到了其他人指出的一些技巧。）

— 灭虫菊
source

您可以通过将所有类型定义更改为来进一步打高尔夫球var。如果在单语句if块之后删除括号，则可以节省更多。如果您分配t.Substring(int, int)给一个Func<int, int, string>，则可以保存另一对。

— 布兰登2014年

我将大多数变量defs设为“ var”，但似乎我错过了一两个，也完全忘记了无括号的ifs，谢谢。

— miethpo 2014年

您可以通过刮胡子另外5个字符var荷兰国际集团将string[] r通过与另外3 var荷兰国际集团的string t = Console....最后，你可以节省7个，通过改变return new string[]进return new[]在最后。

— 布兰登2014年

您还可以执行其他一些小的改进，例如将if(...) break;逻辑移至for循环退出条件。可以应用许多其他逻辑求反，例如do { } while(..)在您的提取方法中。这比为输入案例添加单独的逻辑运算要短。由于我在这个网站上的代表不高，因此我对您的代码进行了修改，但仍需要审核/接受。降至870个字符。

— nicholas 2014年

1

@Nicholas我不确定编辑别人的代码是否礼貌……

— miethpo 2014年

1

JavaScript（E6）1433

这是联合国上限

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

在FireFox / FireBug控制台中测试

F('Rutherfordium')

输出量

Rf

— edc65
source

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和3rd个字符），这留下了2种特殊情况：铈/铈均为“ Ciu”，而钌/卢瑟福均为“ Rhe”。对于Ciu，我检查名称的第二个字符是“ e”还是“ E”，对于“ Rhe”，我检查名称的长度。

VAR(name)返回具有该名称的变量。变量名称不区分大小写。

— 12Me21
source

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及更高版本中受支持。

根据我们的IO标准，输入通过带有varchar字段e的预先存在的表t进行。输出用空格填充到3个字符；规则尚不清楚。如有必要，我可以添加一个。TRIM

输入表与一个表连接在一起，该表包含所有元素符号（填充为3个字符）的列表，每个元素名称的唯一前缀最短（X对于Xenon足够，但是Rutherfordium需要Ruther将其与Ruthenium区别开））。

编辑1：通过从列表中删除44个条目（其符号是其名称的前两个字母）来保存218个字符；该ISNULL函数用于查看第一个查询是否无法返回行，如果是，则从输入元素名称生成符号（大小写正确）。

— 布拉德
source

元素周期表-代码高尔夫

CJam，337个 297 293 232 220 201 200字节

测试用例

这个怎么运作

C，452

JavaScript的ES6，690个708字节

Ruby，1068字节

果酱 462449434401391384 382

码

PHP，507个 485 476 466字符

JavaScript（1100）

蟒蛇- 652 649 637

Golfscript- 1052 821

哈斯克尔，920 817 807 776个字符

编辑1

C＃（826）

SmileBASIC，1763 1418 1204 1128字节

T-SQL，900个894 676字节