주기율표-코드 골프

47

Practical Golf 기반 -미국

당신의 임무는 최대 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 
— 속 팅크
소스
4
@squeamishossifrage 감사합니다. 두 가지 버전 ( "황"및 "황")이 모두 허용됩니다. 그러나 프로그램은 둘 다 처리 할 필요는 없습니다.
— soktinpk
1
... 정규와 관련이 없습니다. 당신은 우리를 잘 얻었다.
— Josiah Winslow
2
@Xrylite 규칙을 읽어 보십시오 : " 입력 ... 요소 이름-대소 문자를 구분하지 않습니다 ... 출력 ... 첫 문자는 대문자 여야하고 나머지는 소문자 여야합니다."
— Jim Balter
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은 3 개의 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 0) ↦ 6 압축이 가능합니다.

이제 H를 해시 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로 바꾸면 각 기호의 길이는 정확히 2 자입니다. 다음과 같이 푸시 할 수 있습니다.

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

문자 코드 배열은 기본 256에서 기본 25로 변환되고 A 의 문자 코드는 모든 숫자에 추가되며 (프로세스에서 문자로 캐스팅 됨) 결과는 길이 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.                                         ";
— 데니스
소스
그러나 어떻게 작동합니까?
— Claudiu
2
@Claudiu : 설명을 추가했습니다.
— Dennis
3
나는 설명의 첫 번째 1/3을 읽었으며 지금까지 내가 가진 것은 "Magic"입니다. Incredible
— Mooing Duck
7
"AcAlAmSbArAsAtBaBkBeBiBhBBrCdCsCaCfCCeClCrCoCnCuCmDsDbDyEsErEuFmFlFFrGdGaGeAuHf HsHeHoHInIIrFeKrLaLrPbLiLvLuMgMnMtMdHgMoNdNeNpNiNbNNoOsOPdPPtPuPoKPrPmPaRaRnReRh RgRbRuRfSmScSgSeSiAgNaSrSTaTcTeTbTlThTmSnTiWUuoUupUusUutUVXeYbYZnZr"= 226 개 문자. 해결책은 200 자입니다. 여기에 적절한 부두가 있습니다.
— squeamish ossifrage
이 답변은 가장 짧은 것 같지만 추가 답변을 자유롭게 게시 할 수 있으므로이 답변을 수락했습니다.
— 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"해시는 0으로, "Sn"은 테이블의 시작 부분에 있습니다. 다음 7 자리는 비어 있습니다. 코드를 간결하게 유지하려면 ASCII 값 34 + 7 = 41 ( ")")로 표시됩니다. 다음은 "구리"(8), 4 개의 빈 셀 (34 + 4 = 38 = "&") 및 "Vanadium"(13)입니다. 해시를 계산 한 후 프로그램은 테이블을 단계별로 실행하여 모든 대문자에 대해 1을 뺀 다음 0 이상의 소문자를 빼고 알파벳이 아닌 모든 문자에 대해 (ASCII VALUE) -34를 뺍니다. 값이 0에 도달하면 올바른 결과를 찾았습니다.

— 으스스한 ossifrage
소스
3
@soktinpk Brute가 강제로 :-) 충돌이없는 해시 크기가 ≤512 인 유일한 것입니다. 나는 다른 철자를 검사하지 않았으며 다른 알고리즘으로 더 나은 기능이있을 수 있습니다 (예 : 추가 대신 XOR 사용).
— squeamish ossifrage
2
464 ... ... 불필요한 괄호 쌍을 만드십시오.
— Jim Balter
1
당신이 문법에 대해 생각한다면, 그것은 모호하지 않으며 허용되어야합니다 ... 그것은 우리에게 모호하게 보입니다 . 아, 당신은 내가하지 않은 또 하나를 잡았다! 축하합니다 ... 알고리즘을 강화하기 위해 열심히 노력했지만 모든 것이 올바르게되었습니다.
— Jim Balter
5
@Harshdeep — 해시 함수는 텍스트 문자열을 0에서 440 사이의 값으로 매핑합니다. "Tin"해시는 0으로, "Sn"은 테이블의 시작 부분에 있습니다. 다음 7 자리는 비어 있습니다. 코드를 간결하게 유지하려면 ASCII 값 34 + 7 = 41 ( ")")로 표시됩니다. 다음은 "구리"(8), 4 개의 빈 셀 (34 + 4 = 38 = "&") 및 "Vanadium"(13)입니다. 해시를 계산 한 후 프로그램은 테이블을 단계별로 실행하여 모든 대문자에 대해 1을 뺀 다음 0 이상의 소문자를 빼고 알파벳이 아닌 모든 문자에 대해 (ASCII VALUE) -34를 뺍니다. 값이 0에 도달하면 올바른 결과를 찾았습니다.
— squeamish ossifrage
2
좋은데 다음과 같이 문자를 저장하십시오 (h+c%32+74)*311%441. 2.을 떨어 뜨려 p사용하십시오 s. 3. main(c)하나의 쉼표를 저장합니다.
— ugoren
13

자바 스크립트 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
소스
Neon이 목록에 전달 된 경우 Neo가 Neodymium과 일치한다는 사실을 사용하여 일부 바이트를 줄일 수 있습니까?
— Dancrumb
1
@Dancrumb 불행히도 아닙니다. 루프는 가장 짧은 부분 문자열로 시작하므로 문자 수가 적어 Neo적중 Neon되기 전에 적중 합니다.
— NinjaBearMonkey 1
1
지금까지 가장 짧은 JS의 경우 +1입니다. 이 문장을 제거 할 수 있지만if (완벽한 for조건 임) 일부 변수의 위치를 ​​인라인하거나 이동하여 코드를 줄이려면;)
— core1024
2
처음에 ).toLowerCase(-> )[L='toLowerCase'](그런 다음 끝에서 a.toLowerCase(-> a[L](4 문자를
— 잘라야합니다
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는 인쇄하기 전에 비 알파 문자를 제거합니다.

* "철"의 "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, 462449434401 391384 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 문의 두 번째로 깊은 계층에서 처리됩니다. 많은 사람들이 첫 번째와 세 번째 문자 또는 첫 번째와 네 번째 문자입니다.이 문자는 연속적인 외부 레이어에서 처리됩니다. 첫 번째 문자 만 나타나고 불규칙한 완전한 문자는 각각 다섯 번째와 세 번째 계층에서 처리됩니다.

혼란스러워하는 곳 ( TelLuriumvs ThaLlium, SILiconvs SILver, RUTheniumvs RUTherfordium) 이 몇 가지 있습니다 . 이들은 별도로 처리됩니다.

대부분의 코드 블록을 재사용하고 불규칙한 처리를 개선하여 많은 골프를 할 수 있습니다.

1
몇 가지 팁 : 1. 유효하지 않은 요소 이름에 대한 동작은 정의되어 있지 않으므로 "RUTHENIUM"=사용할 수 없습니다 "RUTHEN"#!. 2. o실제 요소 이름 ( ;"Si") 앞에 명시 적으로 인쇄 하거나 ( ) 제거 할 필요가 없습니다 . ]W=코드 끝에 추가 하여 최상위 스택 요소를 제외한 모든 것을 제거하십시오. 3. 몇 블록을 비 웁니다. 경우 B부울입니다, B{...}{}?그리고 B{...}*같은 얻을 수 있습니다. 당신은 단축 할 수 있도록 4. 원은, 블록 또는 스택 요소를 걸리는 경우 {"Si"}에 "Si".
— Dennis
내가 생각 @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];
— Sir_Lagsalot
소스
2

자바 스크립트 (1100)

단순하게 빛나는 순진한 구현. 이름 시작 부분의 고유 한 하위 문자열은 단순히 symbol에 매핑됩니다.

e={hy:"H",he:"He",lit:"Li",bery:"Be",bor:"B",car:"C",nit:"N",ox:"O",flu:"F",neon:"Ne",so:"Na",mag:"Mg",al:"Al",sili:"Si",ph:"P",su:"S",chl:"Cl",arg:"Ar",pot:"K",calc:"Ca",sc:"Sc",tit:"Ti",v:"V",chr:"Cr",man:"Mn",iro:"Fe",cob:"Co",nic:"Ni",copp:"Cu",zin:"Zn",gal:"Ga",ge:"Ge",ars:"As",sel:"Se",br:"Br",k:"Kr",rub:"Rb",st:"Sr",yttr:"Y",zir:"Zr",nio:"Nb",mo:"Mo",tec:"Tc",ruthen:"Ru",rho:"Rh",pa:"Pd",silv:"Ag",cad:"Cd",in:"In",tin:"Sn",an:"Sb",tel:"Te",io:"I",x:"Xe",cae:"Cs",ba:"Ba",lan:"La",ce:"Ce",pra:"Pr",neod:"Nd",prom:"Pm",sa:"Sm",eu:"Eu",gad:"Gd",ter:"Tb",dy:"Dy",ho:"Ho",er:"Er",thu:"Tm",ytte:"Yb",lu:"Lu",haf:"Hf",ta:"Ta",tu:"W",rhe:"Re",os:"Os",iri:"Ir",pla:"Pt",go:"Au",mer:"Hg",tha:"Tl",le:"Pb",bi:"Bi",pol:"Po",as:"At",rado:"Rn",fr:"Fr",radi:"Ra",ac:"Ac",tho:"Th",prot:"Pa",ur:"U",nep:"Np",plu:"Pu",am:"Am",cu:"Cm",berk:"Bk",cali:"Cf",ei:"Es",fe:"Fm",men:"Md",no:"No",law:"Lr",ruther:"Rf",du:"Db",sea:"Sg",boh:"Bh",has:"Hs",mei:"Mt",da:"Ds",ro:"Rg",cope:"Cn",ununt:"Uut",fle:"Fl",ununp:"Uup",liv:"Lv",ununs:"Uus",ununo:"Uuo"}
n=prompt().toLowerCase()
for(i in e)n.indexOf(i)?i:alert(e[i])
— 미카 라미
소스
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, 10 자 이하의 Golfscript 조각입니다!
— WallyWest
1
줄 바꿈 문자가있는 하나의 문자열을 구분 기호로 사용한 다음 수행하여 해당 문자열 배열을 크게 개선 할 수 있습니다.n/
— Peter Taylor
지난번에 내가 왜 그렇게 생각하지 않았어? 지금 업데이트 중입니다.
— Josiah Winslow
2

하스켈 920 817 807 776 개 숯을

요소 이름의 문자가 기호에 포함되는 규칙과 약간의 땜질에 대한 규칙 시스템을 너무 오랫동안 작업 한 후 요소를 기호로 쉽게 변환하는 스크립트를 작성할 수있었습니다. 아이언은 GOLD, SilVer, TiN, LEad, SoDium, MerCury, ANtimony, PotaSsium 및 TUngsten에서 특정 문자를 샘플링하여 사용하지 않는주기 기호로 변환 할 수 있었기 때문에 문제가되었습니다. 그것들을 기존 규칙으로) 그리고 상징적 변환 후 번역; 그러나 Ir, Io 및 In이 모두 이미 사용 되었기 때문에 Iron은 문제가되었습니다. 처음에는 920 자 였지만, 마지막 패턴 일치 (가장 큰)가있을 필요가 없다는 것을 깨달았습니다. 따라서, 나는 그것을 잡기 쉬운 와일드 카드로 바꿨다. 그 후, 나는 817에서 808로 골프를 쳤다. 와일드 카드를 사용하여 일부 요소는 그 요소 이름에 고유 한 방식으로 약어를 사용하여 축약했다. w "는"법률 "보다 1이 적은 문자와 일치합니다.

여기 내 코드가 있습니다. 모든 요소에 대해 테스트했으며 입력을 제목으로 자동 변환하도록 코딩하여 대소 문자 구분에 문제가 없습니다.

편집 1

t에서 케이스 표현식을 패턴 일치로 바꾸어 (776 케이스 표현식이 피연산자 측면의 표현식이 아닌 원시 피연산자를 테스트했기 때문에) 의미없는 괄호를 제거하고 다시 사용하여 776 자로 줄였습니다. e문자열 목록 대신 줄 바꿈으로 구분 된 문자열로 표현한 후 나중에 주 함수에서 분할합니다. 이러한 변경 사항은 순전히 골프이므로 사람이 읽을 수있는 버전은 변경하지 않았습니다.

import Data.Char
m _[]=True;m[]_=False;m k@(c:s)x@(y:z)=case y of{']'->m s x;'['->let(i,(_:j))=break(==']')z in(c`elem`i)&&m s j;'?'->m s z;'*'->null z||m k z||m s z||m s x;_->c==y&&m s z};p(a:t)(x:y)=case a of{'.'->x:p t y;'_'->p t y;_->a:p t y};p[]_=[];e="Iro\nUn\nCu Pa Ro Y*e\nR*r\n*pp\nCop Rado\nSea Thu\nCali Da P*ot Tha\nA*s Boh ?ub Ch [CG]ad [HM]a Liv Nep Plu Rhe S[ato] Tec Tin Z\nB*k Cae [ES]i *w Nio [FM]e N*d Pro Pla Ter\nBor Car Flu Hy Io Nit Ox Ph Su [UVY]\n*";s="Fe ._._. .____. .f .u .n ._____. .___. ._. .__. . ..";t"Sv"="Ag";t"Sd"="Na";t"Go"="Au";t"Le"="Pb";t"Mc"="Hg";t"An"="Sb";t"Ps"="K";t"Tu"="W";t"Tn"="Sn";t x=x;main=interact$unlines.map(\(a:b)->let y=toUpper a:map toLower b in t$p(snd.head.filter(any(m y).fst)$zip(map words$lines e)$words s)y).lines

사람이 읽을 수있는 버전 (줄 바꾸기, 간격, 자세한 이름, 설명 : 2311 문자) 

import Data.Char

-- Test against search-pattern strings
match _ [] = True
match [] _ = False
match k@(c:s) x@(y:z) = case y of
']' -> match s x
'[' -> let (i,(_:j)) = break (==']') z in (c `elem` i) && match s j
'?' -> match s z
'*' -> null z || match k z || match s z || match s x
 _  -> c == y && match s z

-- Write according to name-pattern string
pattern (a:t) (x:y) = case a of
'.' -> x : (pattern t y)
'_' -> (pattern t y)
 _  -> a : (pattern t y)
pattern [] _ = []

-- Search-Patterns for the elements
elements=["Iro", -- Iron -> Fe
      "Un", -- UnUn-Blank-ium (1,3,5)
      "Cu Pa Ro Y*e", -- CuriuM PallaDium RoentGenium YtterBium (1,6)
      "R*r", -- Rutherfordium (1,f)
      "*pp", -- Copper (1,u)
      "Cop Rado", -- Copernicium Radon (1,n)
      "Sea Thu", -- SeaborGium ThuliuM (1,7)
      "Cali Da P*ot Tha", -- CaliFornium DarmStadtium ProtActinium PotaSsium (1,5)

      {- AsTatine ArSenic BoHrium DuBnium RuBidium ChLorine ChRome CaDmium
      GaDolinium HaFnium HaSsium MaNganese MaGnesium LiVermorium NePtunium
      PlUtonium RhEnium SaMarium StRontium SoDium TeChnetium TiN ZiNc
      ZiRconium (1,3) -}

      "A*s Boh ?ub Ch [CG]ad [HM]a Liv Nep Plu Rhe S[ato] Tec Tin Z", 

      {- BerKelium CaeSium EinSteinum SilIcon SilVer LawRencium NioBium
      FerMium MenDelevium MeiTnerium MerCury NeoDymium ProMethium PlaTinum
      TerBium (1,4) -}

      "B*k Cae [ES]i *w Nio [FM]e N*d Pro Pl Ter",

      {- Boron Carbon Fluorine Hydrogen Nitrogen Oxygen Phosphorous Sulphur
      Uranium Vanadium Yttrium (1) -}

      "Bor Car Flu Hy Io Nit Ox Ph Su [UVY]",
      "*"] -- Everything else (1,2)

-- respective naming patterns for searches
symbol = "Fe ._._. .____. .f .u .n ._____. .___. ._. .__. . .."

-- Translate fake symbols
translate x = case x of
"Sv" -> "Ag" -- SilVer
"Sd" -> "Na" -- SoDium
"Go" -> "Au" -- GOld
"Le" -> "Pb" -- LEad
"Mc" -> "Hg" -- MerCury
"An" -> "Sb" -- ANtimony
"Ps" -> "K" -- PotaSsium
"Tu" -> "W" -- TUngsten
"Tn" -> "Sn" -- TiN
  _  -> x  -- Keep everything else the same

main = interact $ unlines . map (\(a:b) -> let y = (toUpper a) : (map toLower b) in t $ p (snd.head.filter (any (m y) . fst) $ zip (map words e) $ words s) $ y) . lines

누구든지이 부분에 대한 설명에 관심이 있으시면 언제든지 문의하십시오.

— 고고학
소스
2

C # (826)

가장 크지는 않지만 C #의 핸디캡으로 시도해 보았습니다.

using System;class P{static string s="HyHHe1Li1Be1BoBCaCNitNOxOFlFNe1SoNaMaMgAl1Sil1PhPSuSChClAr1PotKCal1Sc1Tit1VaVChrCrManMnIrFeCo1Ni1CopCuZiZnGa1Ge1ArsAsSe1Br1Kr1RuRbStSrYtYZirZrNioNbMo1TecTcRut1Rh1PaPdSiAgCadCdIn1TiSnAnSbTel1IoIXe1CaeCsBa1La1Ce1Pra1NeoNdPrPmSaSmEu1GadGdTeTbDy1Ho1Er1ThTmYttYbLu1HaHfTa1TuWRheReOs1Iri1PlPtGoAuMeHgThaTlLePbBi1Po1AsAtRaRnFr1Rad1Ac1Tho1ProPaUrUNepNpPluPuAm1CuCmBerBkCaliCfEiEsFeFmMenMdNo1LawLrRuthRfDuDbSeaSgBohBhHasHsMeiMtDaDsRoRgCopeCnUnUutFle1UnuUupLivLvUnunUus",n,t,k;static void Main(){var d=new System.Collections.Specialized.StringDictionary();while(s!=""){k=g;d[k]=g;if(d[k]=="1")d[k]=k.Substring(0,2);};t=Console.ReadLine();while(t!=""&!d.ContainsKey(t))t=t.Remove(t.Length-1);Console.Write(d[t]);}static string g{get{n="";do n+=s[0];while((s=s.Remove(0,1))!=""&&s[0]>96);return n;}}}

그래서 나는 요소 (예 : 탄소)의 전체 이름을 가능한 가장 작지만 여전히 고유 한 문자열로 바꾸는 프로그램을 작성했으며 다른 모든 고유 한 문자열과 관련하여 모든 요소에 대해이 작업을 수행했습니다. 그런 다음 대문자가 "청크"의 시작을 나타내는 큰 못생긴 문자열로 직렬화하고 청크는 키와 값 사이를 번갈아 가며 나타냅니다. KeyValueKey2Value2 등

이 스크립트는 큰 문자열을 해독하고 큰 문자열로 만든 사전에서 찾을 때까지 입력 된 문자열의 끝에서 문자를 잘라냅니다.

(C #에 대한 지식이 놀랍지 않다는 것을 추가해야하며 원래 제출 한 것은 내가 아는 것을 사용했지만 나중에 다른 사람들이 지적한 트릭이있었습니다.)

— 미에 포
소스
모든 유형 정의를로 변경하여이 범위를 더 넓힐 수 있습니다 var. 단일 명령문 if 블록 뒤에 중괄호를 제거하여 몇 가지를 더 절약 할 수 있습니다. 당신이 할당하면 t.Substring(int, int)A를 Func<int, int, string>다른 커플을 절약 할 수 있습니다.
— Brandon
나는 가장 가변적 인 defs를 "var"로 만들었지 만 한두 가지를 놓친 것 같습니다.
— miethpo
당신은에 의해 추가로 5 개 문자를 면도 할 수 var보내고 string[] r의해 추가 3 var을 보내고 string t = Console...., 마지막으로, 당신은 변경하면 더 많은 7을 절약 할 수 있습니다 return new string[]로 return new[]맨 끝에.
— Brandon
if(...) break;논리를 for 루프 종료 조건 으로 이동하는 등 수행 할 수있는 몇 가지 사소한 개선 사항이 있습니다 . do { } while(..)추출 방법에서 와 같이 여러 가지 다른 논리 반전을 적용 할 수 있습니다 . 이것은 입력 사례에 대해 별도의 논리 연산을 추가하는 것보다 짧습니다. 이 사이트의 저 응답으로 인해 여전히 검토 / 수락이 필요한 코드 수정 사항을 게시했습니다. 870 자로 줄였습니다.
— nicholas
1
@Nicholas 다른 사람의 코드 골프를 편집하는 것이 정중한지 잘 모르겠습니다.
— miethpo
1

자바 스크립트 (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 가지 특별한 경우를 남겼습니다. Cerium / Curium은 "Ciu"이고 Ruthenium / Rutherfordium은 "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 필드와 전자 , 우리의 IO의 기준에 따라 . 출력은 3 자로 공백으로 채워집니다. 그것이 괜찮은지에 대한 규칙은 불분명했다. 필요한 경우을 추가 할 수 있습니다 TRIM.

입력 테이블은 각 요소 이름에 대해 가장 짧은 고유 접두사가있는 모든 요소 기호 (3 자로 채워짐) 목록으로 생성 된 테이블과 결합됩니다 ( XenonX 에는 충분 하지만 Rutherfordium 은 Ruthenium 과 구별해야 함 ).Ruther

편집 1 : 기호가 이름의 처음 두 글자 인 목록에서 44 개의 항목을 제거하여 218자를 저장했습니다. 이 ISNULL함수는 첫 번째 쿼리가 행을 반환하지 못하는지 확인하는 데 사용되고 입력 된 경우 입력 요소 이름에서 기호 (적절한 경우)를 생성합니다.

— BradC
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.