ขึ้นอยู่กับการปฏิบัติกอล์ฟ - สหรัฐอเมริกา

งานของคุณคือการหาตัวย่อ (สัญลักษณ์) ขององค์ประกอบที่กำหนดชื่อองค์ประกอบจนถึงและรวมถึง ununoctium (118) ใช้ตารางธาตุในวิกิพีเดีย

ขอขอบคุณที่ ossifrage คลื่นไส้คุณสามารถหารายชื่อเต็มขององค์ประกอบตัวย่อที่http://pastebin.com/DNZMWmuf

คุณไม่สามารถใช้ทรัพยากรภายนอก นอกจากนี้คุณไม่สามารถใช้ข้อมูลในตัวโดยเฉพาะเกี่ยวกับองค์ประกอบของตารางธาตุ ช่องโหว่มาตรฐานใช้

อินพุต

อินพุตอาจมาจาก stdin ไฟล์promptและinputอื่น ๆ

รูปแบบอินพุต:

ทั้งหมดต่อไปนี้เป็นอินพุตที่ถูกต้อง:

Carbon
carbon
CARBON
cArBOn

เป็นหลักชื่อองค์ประกอบ - กรณีตาย

คุณไม่ต้องจัดการกับการสะกดผิดหรือชื่อองค์ประกอบที่ไม่ถูกต้อง อินพุตไม่ถูกต้องเป็นพฤติกรรมที่ไม่ได้กำหนด

ผลผลิต :

สัญลักษณ์สำหรับองค์ประกอบ อักขระตัวแรกจะต้องเป็นตัวพิมพ์ใหญ่และส่วนที่เหลือ จะต้องเป็นตัวพิมพ์เล็ก

ตัวอย่างผลลัพธ์: C

กรณีทดสอบ:

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

มีองค์ประกอบอื่น ๆ อีกมากมายกว่ารัฐดังนั้นฉันคาดว่ามันจะยากที่จะหากฎทั่วไปสำหรับสิ่งเหล่านี้

นี่คือรหัสกอล์ฟ รหัสที่สั้นที่สุดชนะ!

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คือ Boolean 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.                                         ";

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 แทนการเพิ่ม)

ฟังก์ชัน hash จับคู่สตริงข้อความกับค่าตั้งแต่ 0 ถึง 440 "Tin" hash ให้เป็นศูนย์ดังนั้น "Sn" จึงอยู่ที่จุดเริ่มต้นของตาราง อีก 7 ตำแหน่งว่างเปล่า เพื่อให้รหัสกะทัดรัดนี้จะถูกระบุด้วยค่า ASCII 34 + 7 = 41 (")") ถัดมาคือ "Copper" (8), เซลล์ว่างสี่เซลล์ (34 + 4 = 38 = "&") และ "Vanadium" (13) หลังจากคำนวณแฮชโปรแกรมจะเลื่อนไปตามตารางโดยลบ 1 สำหรับตัวพิมพ์ใหญ่ทั้งหมดตามด้วยตัวอักษรตัวพิมพ์เล็ก 0 ตัวหรือมากกว่าและการลบ (ASCII VALUE) -34 สำหรับอักขระที่ไม่ใช่ตัวอักษรทุกตัว เมื่อค่าถึงศูนย์เราได้พบผลลัพธ์ที่ถูกต้อง

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

ทับทิม 1.9+, 565 471 447 444

หนึ่งซับ เพราะไม่มีอะไร "เป็นไปไม่ได้ที่จะทำกับ regexes" ...
(เพิ่งบันทึก 94 chars โดยเพิ่ม regex อื่น) ((และ 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$>

คำอธิบาย: การ
แยกสตริงบนเมืองหลวงชั้นนำจะส่งคืนอาร์เรย์ของ regex เพื่อจับคู่กับชื่อองค์ประกอบ อักขระที่เป็นตัวอักษรที่ได้รับอนุญาตเท่านั้นในแต่ละตัวคือตัวย่อ * พวกเขาได้รับคำสั่งให้พบการจับคู่ครั้งแรกเมื่อเปรียบเทียบกับอาร์กิวเมนต์บรรทัดคำสั่ง*$*ที่ถูกต้อง 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")

Ruby, 1,068 ไบต์

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

CJam, 462 449 434 401 391 384 382

ด้วยความช่วยเหลือจาก Dennis

รหัส

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) สิ่งเหล่านี้ได้รับการจัดการแยกต่างหาก

การเล่นกอล์ฟมากมายสามารถทำได้ที่นี่ส่วนใหญ่โดยการใช้บล็อคโค้ดซ้ำและปรับปรุงการจัดการความผิดปกติ

PHP, 507 485 476 466 ตัวอักษร

การใช้งาน: ป้อนชื่อองค์ประกอบเป็นพารามิเตอร์ GET '0' - elements.php? 0 = carbon

อัลกอริทึม: เรียกใช้ผ่านสายข้อมูลดึงสายอักขระย่อยคู่รหัสย่อ หากสตริงย่อยตรงกับจุดเริ่มต้นขององค์ประกอบที่ส่งผ่านให้ใช้รหัสย่อเพื่อกำหนดสิ่งที่จะส่งออก: ถ้ารหัสเริ่มต้นด้วยตัวอักษรเอาท์พุทมันเป็นสตริง ถ้าเป็นตัวเลข N ให้พิมพ์อักษรตัวแรกขององค์ประกอบ + ตัวอักษร Nth องค์ประกอบ 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];

จาวาสคริปต์ (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])

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

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.

Haskell, 920 817 807 776 ตัวอักษร

หลังจากทำงานมานานเกินไปการสร้างระบบของกฎสำหรับสิ่งที่ตัวละครของชื่อองค์ประกอบจะรวมอยู่ในสัญลักษณ์ของมันและการแก้ไขเล็กน้อยฉันจัดการเพื่อเขียนสคริปต์ที่แปลองค์ประกอบเป็นสัญลักษณ์ได้อย่างง่ายดาย Iron เป็นปัญหาสำหรับฉันเพราะฉันสามารถลองตัวละครบางตัวจาก GOld, SilVer, TiN, LEad, SoDium, MerCury, Antimony, PotaSsium และ TUngsten เปลี่ยนพวกมันให้เป็นสัญลักษณ์ตามช่วงเวลาที่ไม่ได้ใช้ กฎเหล่านั้นเป็นกฎที่มีอยู่) แล้วแปลหลังจากการแปลงเชิงสัญลักษณ์ อย่างไรก็ตามเหล็กมีปัญหาเนื่องจากมีการใช้ Ir, Io และ In อยู่แล้ว นี่เป็นครั้งแรกที่ตัวอักษร 920 แต่ฉันตระหนักว่ารูปแบบสุดท้ายที่ตรงกับ (ที่ใหญ่ที่สุด) ไม่จำเป็นต้องมีเพราะมันปล่อยให้สิ่งต่าง ๆ ผ่าน (ซึ่งมันไม่ได้) หรือตรงกับพวกเขาทั้งหมด; ดังนั้น, ฉันแทนที่มันด้วยไวด์การ์ดที่จับได้ทั้งหมด หลังจากนั้นฉันเล่นกอล์ฟต่อจาก 817 ถึง 808 โดยย่อรูปแบบบางอย่างโดยใช้ wild-card ในลักษณะที่พวกเขายังคงเอกลักษณ์ของชื่อองค์ประกอบนั้น (เช่นองค์ประกอบเดียวที่มี 'w' ในชื่อคือ Lawrencium ดังนั้น "* w "ตรงกับที่มี 1 ตัวอักษรน้อยกว่า" กฎหมาย ")

นี่คือรหัสของฉัน ฉันทดสอบมันสำหรับองค์ประกอบทั้งหมดและฉันเขียนโค้ดเพื่อให้แปลงอินพุตของมันเป็นชื่อเรื่องโดยอัตโนมัติดังนั้นจึงไม่มีปัญหาเรื่องความไวของตัวพิมพ์เล็ก

แก้ไข 1

ฉันลดลงเหลือ 776 ตัวอักษรโดยแทนที่นิพจน์เคสในรูปแบบการจับคู่รูปแบบ (สิ่งนี้สมเหตุสมผลเนื่องจากนิพจน์กรณีกำลังทดสอบตัวถูกดำเนินการดิบซึ่งตรงข้ามกับนิพจน์ในแง่ของตัวถูกดำเนินการ) ลบวงเล็บที่ไม่จำเป็นออก แสดงeเป็นสตริงที่คั่นด้วย newline แทนที่จะเป็นรายการของสตริงและแยกภายหลังในฟังก์ชันหลัก เนื่องจากการเปลี่ยนแปลงเหล่านี้เป็นการเล่นกอล์ฟอย่างหมดจดฉันจึงไม่เปลี่ยนแปลงรุ่นที่มนุษย์อ่านได้

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

เวอร์ชันที่มนุษย์สามารถอ่านได้ (ขึ้นบรรทัดใหม่เว้นวรรคชื่อ verbose ความคิดเห็น: 2311 Chars)

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

หากใครสนใจคำอธิบายในส่วนใดส่วนหนึ่งของนี้อย่าลังเลที่จะถาม

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

ดังนั้นฉันจึงเขียนโปรแกรมเพื่อเปลี่ยนชื่อเต็มขององค์ประกอบ (เช่นคาร์บอน) เป็นสตริงที่เล็กที่สุด แต่ก็ยังมีความเป็นไปได้และทำสิ่งนี้สำหรับองค์ประกอบทั้งหมดที่เกี่ยวข้องกับสตริงที่ไม่ซ้ำกันอื่น ๆ ทั้งหมด ฉันต่อเนื่องกันแล้วว่าในสตริงที่น่าเกลียดขนาดใหญ่ที่ตัวอักษรใหญ่หมายถึงจุดเริ่มต้นของ "chunks" โดยมีชิ้นสลับระหว่างการเป็นกุญแจกับค่า เช่น KeyValueKey2Value2 เป็นต้น

สคริปต์นี้หยุดการทำงานของสตริงขนาดใหญ่และตัดอักขระออกจากจุดสิ้นสุดของสตริงที่ป้อนจนกว่าจะพบในพจนานุกรมที่สร้างจากสตริงขนาดใหญ่

(ฉันควรเพิ่มความรู้เกี่ยวกับ C # ของฉันไม่น่าแปลกใจและการส่งต้นฉบับที่ฉันทำคือใช้สิ่งที่ฉันรู้

JavaScript (E6) 1433

นี่คือขีด จำกัด บน

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

ทดสอบในคอนโซล FireFox / FireBug

F('Rutherfordium')

เอาท์พุต

Rf

SmileBASIC, 1763 1418 1204 1128 bytes

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

ฉันเลือกตัวละคร 3 ตัวซึ่งส่วนใหญ่ไม่เหมือนใคร (0, 2 และ 3) ซึ่งเหลือ 2 กรณี: Cerium / Curium มีทั้ง "Ciu" และ Ruthenium / Rutherfordium เป็น "Rhe" สำหรับ Ciu ฉันตรวจสอบว่าอักขระตัวที่สองของชื่อคือ "e" หรือ "E" และสำหรับ "Rhe" ฉันจะตรวจสอบความยาวของชื่อ

VAR(name)ส่งคืนตัวแปรที่มีชื่อนั้น ชื่อตัวแปรไม่คำนึงถึงขนาดตัวพิมพ์

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 และสูงกว่า

การป้อนข้อมูลจะได้รับการผ่านตารางที่มีอยู่ก่อนทีมีเขต varchar E , ตามมาตรฐาน IO ของเรา เอาท์พุทเป็นเบาะที่มีช่องว่าง 3 ตัว กฎไม่ชัดเจนว่ามันโอเค TRIMถ้าจำเป็นผมสามารถเพิ่ม

ตารางอินพุตถูกรวมเข้ากับตารางที่สร้างด้วยรายการของสัญลักษณ์องค์ประกอบทั้งหมด (เบาะถึง 3 ตัวอักษร) พร้อมกับคำนำหน้าเฉพาะที่สั้นที่สุดสำหรับชื่อองค์ประกอบแต่ละชื่อ ( Xเพียงพอสำหรับซีนอนแต่Rutherfordiumต้องการRutherแยกแยะจากรูทีเนียม )

แก้ไข 1 : บันทึก 218 ตัวอักษรโดยลบ 44 รายการออกจากรายการที่มีสัญลักษณ์เป็นตัวอักษรสองตัวแรกของชื่อ; ISNULLฟังก์ชั่นที่ใช้ในการดูว่าแบบสอบถามครั้งแรกล้มเหลวที่จะกลับมาแถวและถ้าเป็นเช่นนั้นจะสร้างสัญลักษณ์ (ใส่ซองอย่างถูกต้อง) มาจากชื่อองค์ประกอบเข้า