IUPAC 은 참을 수없는 지혜로 새로 만든 요소에 대해 체계적인 요소 이름 을 만들었습니다. 이것은 실제로 실제 이름에 대해 마음을 정할 때까지 요소의 임시 이름입니다. 요소 번호의 각 숫자에는 그 값에 따라 접두사가 할당됩니다. 접두사는 끝에 'ium'으로 연결됩니다. 이 작업을 수행하고 이중 i (ii) 또는 삼중 n (nnn)을 얻으면 단일 i 및 이중 n으로 대체하십시오. 요소의 기호는 연결되고 결과가 대문자로 사용 된 각 접두사의 첫 글자입니다. 사용 된 접두사는 다음과 같습니다.

0 nil       5 pent
1 un        6 hex
2 bi        7 sept
3 tri       8 oct
4 quad      9 enn

따라서이 골프의 경우 코드는 주어진 양의 정수에 대해 요소 이름과 기호를 모두 생성해야합니다. 코드가 137 주어진다면, 그것은 표준 출력 또는 반환 모두에 인쇄해야 untriseptium하고 Uts. 적어도 118에서 558 사이 여야합니다 . 코드 길이를 늘리지 않으면 더 높은 값이 유효합니다.

방법을 보여주는 파이썬 예제 :

def elename(n):
    '''Return name and symbol of new element for given element number.'''
    prefixes=['nil','un','bi','tri','quad','pent','hex','sept','oct','enn']
    nmeFixes, symFixes = [], []

    while n:  # each digit of element number is assigned a prefix
        n, i = divmod(n, 10)
        pf = prefixes[i]

        symFixes.append(pf[0])  # symbol uses only first letter of prefix
        nmeFixes.append(pf)

    # loop assembled prefixes in reverse order
    nmeFixes.reverse()
    symFixes.reverse()

    nmeFixes.append('ium')  # suffix
    name = ''.join(nmeFixes)
    symb = ''.join(symFixes).capitalize()

    # apply rule about too many n's or i's
    name = name.replace('nnn','nn')  # can happen with -90-
    name = name.replace('ii','i')  # -2ium or -3ium

    return name, symb

카드뮴 바이트로 에릭 타워가 승리합니다!

Mathematica 10.1, 인듐 (49) 카드뮴 (48)

이 솔루션은 IUPAC 이름 및 약어를 포함하여 내장 된 요소 특성 라이브러리를 사용합니다. (나는 이것을 골프에서 피할 수있는 기술로 보지 못했다. 장려되는 것처럼 보인다. 그러나 이것은 아마도 받아 들일 수있는 가장자리에있다. 아마도 Mathematica는 Wolfram의 서버는 처음 사용할 때 (때로는 업데이트 확인을 가정합니다.)

f=ElementData@@@{{#,"Abbreviation"},{#,"Name"}}&
(* 
Improved by @user5254 from 
f[n_]:=ElementData[n,#]&/@{"Abbreviation","Name"} 
*)

f[48]
(* {"Cd", "cadmium"} *)

f[118]
(* {"Uuo", "ununoctium"} *)

f[122]
(* {"Ubb", "unbibium"} *)

f[190]
(* {"Uen", "unennilium"} *)

f[558]
(* {"Ppo", "pentpentoctium"} *)

f[10^100-1]
(* {"Eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", "ennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennennium"} *)

이것은 파이썬에서 elements.py 또는 periodictable.py를 사용하는 것과 어떻게 비교됩니까?

편집 : 몇 달 후 : 122에 대한 약어 출력을 입력 한 것으로 나타났습니다. 코드를 다시 실행하고 Mathematica가 아니라이 오류가 발생했는지 확인했습니다.

파이썬 3, Unhexseptium (167) 바이트

h=x='';r=str.replace
for i in input():s=r('nubtqphsoeinirueeecnl  ianxptn    dt t'[int(i)::10],' ','');h+=s;x+=s[0]
print(r(r(h+'ium\n','ii','i'),'nnn','nn')+x.title())

1에서 999까지의 모든 숫자에서 프로그램이 실행될 때의 결과입니다.

핍 , 토륨 악티늄 라돈 (86)

^{(이 항목을 흡입하지 않으면 폐암이 발생합니다.)}

P(aR,tY"nil un bi tri quad pent hex sept oct enn"^s)."ium"R`ii|nnn`_@>1Yy@_@0MaUC:y@0y

요소 번호를 명령 행 인수로 사용하여 이름 및 약어를 별도의 행에 출력합니다.

설명 (뭔가 ungolfed) :

Y"nil un bi tri quad pent hex sept oct enn"^s  Build list of prefixes & store in y

    ,t                                         Range(10)
 (aR  y)                                       Replace each digit in input with
                                                 corresponding element in prefix list
        ."ium"                                 Append "ium"
              R`ii|nnn`_@>1                    Reduce too-long runs of letters
P                                              Print

 {y@a@0}Ma                                     For each digit in input, get first character
                                                 of corresponding prefix
Y                                              Store that list in y
          UC:y@0                               Uppercase the first item of y in place
                y                              Print y (items concatenated)

ii및 nnn사용 (핍의 최신 버전에 추가) 콜백 함수와 정규식 교체 처리 : 모든 경기 ii|nnn, 모든 걸리지 만 교체로 첫 번째 문자 사용을.

GNU sed, 171 (운 셉터 늄)

s/0/Nil/g
s/1/Un/g
s/2/Bi/g
s/3/Tri/g
s/4/Quad/g
s/5/Pent/g
s/6/Hex/g
s/7/Sept/g
s/8/Oct/g
s/9/Enn/g
s/$/ium/
h
s/[a-z]//g
G
s/./\L&/g
s/./\U&/
s/\n/ /
s/ii/i/g
s/nnn/nn/g

이름과 기호가 어떤 순서로 반환되는지는 중요하지 않습니다. 여기에서 기호가 먼저옵니다.

$ seq 180 190 | sed -f iupac.sed 
Uon unoctnilium
Uou unoctunium
Uob unoctbium
Uot unocttrium
Uoq unoctquadium
Uop unoctpentium
Uoh unocthexium
Uos unoctseptium
Uoo unoctoctium
Uoe unoctennium
Uen unennilium
$ 

매쓰, unhexunium 163 161 바이트

이제 기호를 대문자로

이것은 내장이없는 Mathematica입니다 ElementData.

f=StringReplace[##<>"ium, "<>{ToUpperCase@#1,##2}~StringTake~1&@@ToString/@nil[un,bi,tri,quad,pent,hex,sept,oct,enn][[IntegerDigits@#]],{"ii"->"i","nnn"->"nn"}]&

10 개의 난수를 테스트하십시오.

# -> f[#]& /@ RandomInteger[{118, 558}, 10] // ColumnForm

155->unpentpentium, Upp
338->tritrioctium, Tto
477->quadseptseptium, Qss
261->bihexunium, Bhu
158->unpentoctium, Upo
164->unhexquadium, Uhq
266->bihexhexium, Bhh
331->tritriunium, Ttu
404->quadnilquadium, Qnq
389->trioctennium, Toe

자바 스크립트 (ES6) 164 (16 진수) 171

대문자는 까다로운 부분입니다. (FireFox에서 테스트)

thx 사용자가 저장 한 3 바이트 편집

f=n=>[([...n+(l='')].map(c=>(c='nil,un,bi,tri,quad,pent,hex,sept,oct,enn'.split`,`[c],n=l?n+c[0]:c[0].toUpperCase(),l+=c)),l+'ium').replace(/i(i)|n(nn)/g,'$1$2'),n]

function test() { O.innerHTML=f(+I.value) }

test()

for(o='',i=99;i++<999;)o+=i+' '+f(i)+'\n';P.innerHTML=o

<input id=I onchange="test()" value="164"><span id=O></span><pre id=P></pre>

루비 - 163 156 147 143 134 (Untriquadium) 바이트

o=u='';gets.bytes{|c|k=%w[Nil un bI trI quad pent hex sept oct enN Ium][c%48];o+=k;u+=k[0]};puts o.tr_s('IN','in'),u[0..-2].capitalize

나는 이런 식으로 골프를 바라고 있어요

편집 : 9 바이트를 줄인 @steveverrill에게 감사드립니다!

Edit2 : 또 다른 4 바이트에 대해 @steveverrill에게 다시 감사드립니다! (정말 영리한 솔루션!)

Pyth, 67 바이트 (Holmium)

rshMJ@Lcs@LGjC"]ß!âÿeóÑiSÑA¼R¬HE"24\fjQT3-"ium"epj"nn"csJ*\n3

Pyth Compiler / Executor 에서 온라인으로 사용해보십시오 .

작동 원리

            jC"…"24       Convert the string from base 256 to base 24.
        s@LG              Select the letter that corresponds to each digit.
       c           \f     Split at 'f'.
     @L              jQT  Select the chunk that corresponds to each input digit.
    J                     Save in J.
 shM                      Form a string of the first letters of the chunks.
r                       3 Capitalize the first character.
                          Print. (implicit)

             csJ*\n3      Split the flattened J at "nnn".
        j"nn"             Join, separating by "nn".
       p                  Print.
-"ium"e                   Remove the last character ('i'?) from "ium".
                          Print. (implicit)

자바 스크립트 (ES6) 210 202 바이트 ( Biunnilium Binilbium)

@ edc65 덕분에 마이너스 옥 티엄 (8) 바이트!

130159147 바이트 (Untrinilium Unpentennium Unquadseptium)

f=z=>(c=(b=(z+"").split``.map(x=>"nil.un.bi.tri.quad.pent.hex.sept.oct.enn".split`.`[+x])).join``.replace(/nnn/g,"n"))+(c[c.length-1]!="i"?"i":"")+"um,"+(a=b.map(x=>x[0])).shift().toUpperCase()+a.join``

처럼 입력하십시오 f(324). 어, 너무 골프 느낌이 들었다.

CJam, 74 72 71 70 69 바이트 (툴륨)

r:i"ؾaÈÁaÎE<Ä+&:¬úD±"380b24b'af+)/f=_:c(euoS@s'n3*/"nn"*)"ium"|

코드에는 인쇄 할 수없는 문자가 포함되어 있습니다.

초기 개정에서 오류를 지적하고 )/접근 방식을 제안한 @ Sp3000에게 감사합니다 .

CJam 통역사 에서 온라인으로 사용해보십시오 .

작동 원리

r:i     e# Read a token and push the array of its character codes.
"…"     e# Push a string of unprintable characters.
380b24b e# Convert it from base 380 to base 24.
'af+    e# Add the character 'a' to each base-24 digit.
        e# This pushes "bijtrijquadjpentjhexjseptjoctjennjniljunj".
)/      e# Pop the last character and split the string at the remaining occurrences.
f=      e# For each character code in the input, select the correspoding chunk.
_:c     e# Push a copy and cast each string to character.
(euo    e# Shift out the first character, convert to uppercase, and print.
S@      e# Push a space and rotate the array of string on top of it.
s       e# Flatten the array of string.
'n3*/   e# Split at occurrences of "nnn". 
"nn"*   e# Join, using "nn" as separator.
)"ium"| e# Pop the last character and perform setwise union with "ium".
        e# If the last character is, e.g., 't', this pushes "tium".
        e# If the last character is 'i', this pushes "ium".

Matlab, 170 (비 격리)

원하는만큼 입력 할 수있는 모든 입력에서 작동합니다 nilium. 나는 ennennennennennennennennennennennennennennennennennennennennennennium9 키를 눌러 포기하기 전에 도착했다 .

l=['nubtqphsoe';'inirueeecn';'l  ianxptn';'    dt t  '];i=input('','s')-47;s=l(1,i);s(1)=s(1)-32;a=l(:,i);disp([strrep(strrep([a(a>32)' 'ium '],'nnn','nn'),'ii','i') s]);

그리고 설명 :

%Create a 2D array of the prefixes transposed
l=['nubtqphsoe';'inirueeecn';'l  ianxptn';'    dt t  '];
%Grab the input number
i=input('','s')     %Request the input and convert to string
               -47; %Convert from ASCII into an array of indecies (1 indexed)
%Generate the short form
s=l(1,i);
%Capitalise first letter in short form
s(1)=s(1)-32;
%Extract required prefixes for long form
a=l(:,i);
%Now the fun bit:
                     a(a>32)'                                    %Combine the prefixes removing spaces and transpose into a string
                    [         'ium ']                            %Append 'ium ' to the string (the space is to separate the short form)
             strrep(                 ,'nnn','nn')                %Replace 'nnn' with 'nn'
      strrep(                                    ,'ii','i')      %Replace 'ii' with 'i'
disp([                                                     s]); %And display both full and short form strings together

TI-BASIC, 223218 바이트

Input N
"nil un  bi  tri quadpenthex septoct enn→Str4
"int(10fPart(N/10^(X→Y₁
"sub(Str4,1+4Y₁,int(3fPart(e^(Y₁)1.5154)+2^not(X=2 and .9=fPart(N%) or X=1 and 1=int(5fPart(.1N→Y₂
"ium,"+sub("UBTQP",int(N%),1
For(X,1,3
Y₂+Ans+sub(Y₂(3-X),1,1
End
sub(Ans,1,length(Ans)-1

요소 번호 N은 90으로 끝나는 경우에만 트리플 "n"을 가질 수 있고 마지막 숫자가 2 또는 3 인 경우에는 더블 "i"만 가질 수 있습니다. 우리는 수학을 사용하여 이러한 경우를 확인합니다.

마법 번호 1.5154각 접두사의 길이를 저장, 기능을 사용하여 길이의 모든 소수를 ≤7 검색 파이썬 스크립트를 사용하여 발견 cosh(, cos(및 e^(.

아직 골프를 치지 않았지만 TI-BASIC의 2 바이트 소문자와 문자열 조작 명령이 없으면 항상이 프로그램의 점수가 떨어집니다.

파이썬 3 unpentquadium ( 156 (155) 154) 바이트

n=e=""
for c in input():s="nil un bi tri quad pent hex sept oct enn".split()[int(c)];n+=s[c<"1"<"nn"==n[-2:]:];e+=s[0]
print(n.strip("i")+"ium",e.title())

대신 교체 ii로 i우리가 어떤 rstrip i우리가에 압정 전에들 ium즉 이중의 유일하게 가능한 소스이기 때문에, i의. 마찬가지로 사례 n를 확인하여 s를 제거 enn/nil합니다.

망막, 206 196 186 179 (Unseptennium)는 (바이트 온라인으로보십시오 )

이 언어를 가르쳐 준 @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner )에게 감사합니다 .

7 바이트 를 잘라낸 @FryAmTheEggman 에게 감사 합니다.

T`d`nubtq\p\hs\oe
.+
$&, $&
(?<=,.*n)
il
(?<=,.*e)n?
nn
(?<=,.*u)
n
(?<=,.*b)
i
(?<=,.*t)
ri
(?<=,.*q)
uad
(?<=,.*p)
ent
(?<=,.*h)
ex
(?<=,.*s)
ept
(?<=,.*o)
ct
r`i?$
ium
T`l`L`^.

Ueh 바이트 버전 : 여기

Bnh 바이트 버전 : 여기

CJam, 95 바이트

liAbA,"nil un bi tri quad pent hex sept oct enn"S/er_:c(eu\+_1>"en"={\W"il"t\}&S@:+)_'i=!*"ium"

온라인으로 사용해보십시오

이것은 "정규식이없는 언어, 인쇄 가능한 문자 만 사용하는"범주에서 경쟁합니다. ;) 실제로 게시 된 솔루션 중 일부만큼 짧을 것이라고 기대하지는 않았지만 어쨌든 얼마나 오래 걸릴지 궁금했습니다. 그리고 지금 가져 왔으므로 게시 할 수도 있습니다.

설명:

li      Get input and convert to int.
Ab      Encode in decimal.
A,      Build list [0 .. 9].
"..."   String with prefixes.
S/      Split at spaces.
er      Transliterate. We now have a list of the prefix for each digit.
_:c     Copy and take first character of each, for short form.
(       Pop off first character.
eu      Convert it to upper case.
\+      Put it back in place. Done with short form.
_1>     Remove first character.
"en"=   Compare with "en", corresponding to the 90 special case.
{       Handle 90 case, replace 
  \       Swap full prefix list to top.
  W"il"t  Replace "nil" by "il" to avoid "nnn".
  \       Swap short form back to top.
}&      End of 90 case.
S       Push space between short form and full name.
@       Swap prefix list to top.
:+      Concatenate all the prefixes.
)       Pop off the last letter.
_'i=    Compare it with 'i.
!*      Multiply letter with comparison result. This gets rid of letter if it's 'i.
"ium"   Add the final part of the output.

이동, 322 바이트 (트리 비븀)

package main
import("os"
"strings"
"fmt")
func main(){p,n,s:="nil un  bi  tri quadpenthex septoct enn ","",make([]byte,0)
b:=make([]byte,3)
os.Stdin.Read(b)
var d byte=32
for _,r:=range b{i:=r-48
n+=p[4*i:4*i+4]
s,d=append(s,p[4*i]-d),0}
fmt.Printf("%sium %s",strings.NewReplacer(" ","","ii","i","nnn","nn").Replace(n),s)}

STDIN에서 세 문자를 읽습니다. 더 많은 문자는 무시되고 더 적은 충돌이 발생합니다. 그래서 사이의 모든 번호를 작동 unnilnilium하고 ennennennium.

PowerShell을 170 168 165 (Unhexpentium)

-join($a="$input"[0..9]|%{(($x=(-split'Nil Un Bi Tri Quad Pent Hex Sept Oct Enn')["$_"]).ToLower(),$x)[!($y++)]})+'ium'-replace'(nn)n|(i)i','$1$2'
-join($a|%{$_[0]})

여기에는 매우 간단하고 놀라운 것이 없습니다. 어쩌면 첫 번째 부분을 제외한 모든 것을 소문자로하고 개별 부분을 제목으로 이미 작성하여 대문자 문제를 해결했을 수도 있습니다. 베어 변수 할당에 대한 문자 손실을 피하기 위해 지금까지 적극적으로 인라인됩니다.

마지막 변경 후 보너스 : 이제 더 긴 요소 번호에도 적용됩니다.

> echo 1337| powershell -noprofile -file "element.ps1"
Untritriseptium
Utts

x86, 192의 C (Unennbium)

int c,s,a[8],x,main(){while((c=getchar()-48)>=0)x="nil\0un\0\0bi\0\0tri\0quadpenthex\0septoct\0enn"+4*c,strncat(a,x+(c<s-8),4),strncat(a+5,x,1),s=c;printf("%s%s %s",a,"ium"+((s&14)==2),a+5);}

에서 숫자를 읽고 stdin결과를에 인쇄합니다 stdout. 에 의존합니다 sizeof(char*) == sizeof(int).

언 골프 버전 :

int c, s, // Current and last digit, initially zero (0-9, not '0'-'9')
    a[8], // Buffer to write to (type doesn't matter when passed by pointer)
    x; // Int-pointer into lookup table

main() {
    while ((c = getchar() - 48) >= 0) { // 48 == '0'
        x = "nil\0un\0\0bi\0\0tri\0quadpenthex\0septoct\0enn" + 4*c;
        strncat(a, x+(c<s-8), 4); // Write digit, skip first char if c==0 && s==9
        strncat(a+5, x, 1); // Write first digit character somewhere else
        s = c;
    }
    printf("%s%s %s", a, "ium"+((s&14)==2), a+5); // Append "ium" (or "um" if s==2||s==3)
}

하스켈 bipentbium ( 305 271 269 265 261 259 253 252 바이트)

import Data.Char
main=getLine>>=putStr.a
m=map toLower
a n=(r.m$p)++(k.filter isUpper$p)where p=(n>>=(words"Nil Un Bi Tri Quad Pent Hex Sept Oct Enn"!!).digitToInt)++"ium "
r('n':'n':'n':x)="nn"++r x
r('i':'i':x)='i':r x
r(x:z)=x:r z
r x=x 
k(h:t)=h:m t

nimi 덕분에 34 바이트를 줄였습니다.

GNU sed, unhexunium (161 바이트)

h
y/0123456789/nubtqphsoe/
s/./\u&/
x
s/$/ium/
:
s/0/nil/
s/1/un/
s/2/bi/
s/3/tri/
s/4/quad/
s/5/pent/
s/6/hex/
s/7/sept/
s/8/oct/
s/9/enn/
s/nnn/nn/
s/ii/i/
t
G

먼저 심볼을 생성 한 다음이를 보류 공간에 숨기고 이름을 만듭니다. 루프는 /g4 개 이상의 교체에 사용 하는 것보다 골퍼입니다 (우리는 하나 ii또는 하나만 가질 수 nnn있으므로 루프 내부에있을 필요 는 없지만 아프지는 않습니다). 마지막으로 보류 된 기호를 검색하고 추가하십시오.

(NB 나는 이것을 쓸 때 기존의 sed 답변을 보지 못했다)

테스트 사례

이들은 다음 ii과 같은 nnn특별 규칙을 행사합니다 .

$ seq 100 89 1000 | ./60208.sed
unnilnilium
Unn
unoctennium
Uoe
biseptoctium
Bso
trihexseptium
Ths
quadpenthexium
Qph
pentquadpentium
Pqp
hextriquadium
Htq
septbitrium
Sbt
octunbium
Oub
ennilunium
Enu
ennennilium
Een

그리고 실제 세계와 비교 하여이 코드가 얼마나 더 많은지를 보여주는 어리석은 것 :

$ ./60208.sed <<<281039817
bioctunniltriennoctunseptium
Bounteous

T-SQL 329 바이트

creat proc x(@a char(3))as select replace(replace((select a.b as[text()]from(select left(@a,1)a union select substring(@a,2,1)union select right(@a,1))z join(values(0,'nil'),(1,'un'),(2,'bi'),(3,'tri'),(4,'quad'),(5,'pent'),(6,'hex'),(7,'sept'),(8,'oct'),(9,'enn'))a(a,b)on z.a=a.a for xml path(''))+'ium','ii','i'),'nnn','nn')

형식화 :

create proc x(@a char(3))as 
select replace(replace(
(select a.b as[text()]from
    (
    select left(@a,1)a 
    union select substring(@a,2,1)
    union select right(@a,1))z 
join(values(0,'nil'),(1,'un'),(2,'bi'),(3,'tri'),(4,'quad'),(5,'pent'),(6,'hex'),(7,'sept'),(8,'oct'),(9,'enn')
    )a(a,b)on z.a=a.a 
for xml path('')
)+'ium','ii','i'),'nnn','nn')

PHP 152 153 163 바이트 unpentbium

글쎄, 이번에는 적어도 PHP가 평균 정도입니다.

while(null!=$x=$argv[1][$i++]){$a.=$y=[nil,un,bi,tri,quad,pent,hex,sept,oct,enn][$x];$b.=$y[0];}echo str_replace([ii,nnn],[i,nn],$a.'ium ').ucfirst($b);

다음과 같은 양식 명령 행을 실행합니다.

pentium.php 163

산출:

unhextrium Uht

언 골프

$y = array('nil','un','bi','tri','quad','pent','hex','sept','oct','enn');

while (null != ($x = $argv[1][$i++])) {
    $a .= $y[$x];
    $b .= $y[$x][0];
}

echo str_replace(
        array('ii','nnn'),
        array('i','nn'),
        $a . 'ium ')
     .ucfirst($b);

편집하다

• 모든 ( 초기 뿐만 아니라 duh ) array()-initializer를 다음과 같이 대체하여 10 바이트를 절약 했습니다.[]
• 'ium '여분의 연결을 사용하는 대신 공백을 추가하여 1 바이트를 절약했습니다..' '.

Perl, 109 (Unnilennium) 바이트

108 코드 + 1 스위치

perl -pe 's!.!qw{Nil Un Bi Tri Quad Pent Hex Sept Oct Enn}[$&]!ge;s!nnN!nN!g;s!i?$!ium!;$_=lc$_.y!a-z!!dr;s!\b.!\U$&!g'

STDIN에서 입력을 한 줄에 하나의 숫자로 가져옵니다.

자바 8 216 바이트

String f(int i){
String[] s = {"nil","un","bi","tri","quad","pent","hex","sept","oct","enn"};
return ((""+i).chars().mapToObj(y->s[y-48]).collect(Collectors.joining())+"ium").replace("ii","i").replace("nnn","n");
}

C # 229 (Bibiennium) 198 개의 유니 노튬 바이트

"n-'0 '"트릭은 ASCII에서 int로 변환하는 방법입니다. Char 9 = ASCII 57. Char 0 = ASCII 48이므로 57-48 = 9입니다.

정적 개인 문자열 ToText (int v) {return (string.Join ( "", v.ToString (). Select ((char n) => "nil un bi tri quad pent hex sept oct enn"). n [Split () [n -'0 ']))) + "ium"). Replace ( "nnn", "nn"). Replace ( "ii", "i") + ""+ string.Join ( "", v.ToString () 선택 ((char n) => "nubtqphsoe"[n-'0 '])); }

    static private string ToText(int  v)
    {
        string u,r="",t="";
        return v.ToString().Select((char n)=>{u="nil un bi tri quad pent hex sept oct enn".Split()[n-48];r+=u;t+=u[0];return r;}).Last()+"ium".Replace("nnn","nn").Replace("ii","i")+" "+t;
    }

이 접근법은 int를 가져 와서 문자열로 변환 한 다음 람다를 발생시키는 LINQ 문자 선택을 수행합니다.

람다는 접두사 문자열을 분할하여 즉석에서 배열을 정의하는 것보다 배열을 생성합니다. 그런 다음 현재 문자의 int 값 (위에서 언급 한 n-'0 '트릭)을보고 사용할 접두어 색인을 가져옵니다.

모든 문자열에 래핑됩니다. 모든 LINQ 결과를 연결하는 Join.Join "ium"에 붙인 다음 몇 개의. nnn과 ii를 정리하기 위해 마지막에 문을 대체하십시오.

누락 된 심볼 출력을 추가했습니다. 나는 두 개의 LINQ를 병합하여보다 효율적인 방법이 있다고 생각하지만, 계속 찌르는 것은 늦습니다.

C, 210 204 unennennium (199) 바이트

런타임 문자 세트로 ASCII가 필요합니다.

f(char*n,char*s){char*c="NilUnBiTriQuadPentHexSeptOctEnn",*p,*o=n,i,j;for(;*n;){for(j=i=*n-48,p=c;*p&32||i--;++p);for(*s++=*n=*p+32;*++p&32;)*s++=*p;s-=*n++-j==39||j/2-*n==1;}*o-=32;strcpy(s,"ium");}

나는 재귀 적 솔루션을 시도 했지만 ( p및 필요성을 피함 o) 더 길어졌습니다.

나는 / 특히 자랑 정규 표현식에 대한 정규 부끄럽다 90|[23]$에 의존 9하고 0먼 9 차이 자리 (따라서 만 쌍의 분리되는 - 39코드에서는의 결과이다 j정수 가치와 *n여전히 ASCII 문자) 및 그 2와 3이산화황 conflates 그들로 나누어, 마지막 비트 다르다.

확장 코드 :

void f(char *n,                 /* input number / output symbol */
       char *s)                 /* output name */
{
    char *c = "NilUnBiTriQuadPentHexSeptOctEnn", /* digit names */
        *p,
        *o = n,                 /* first char of input */
        i, j;                   /* current digit value */
    for (;*n;) {
        j = i = *n-48;
        for (p=c;  *p&32 || i--;  ++p) /* Find the i'th capital letter in c */
                ;
        for (*s++ = *n++ = *p++ + 32;  *p&32;  ) /* Downcase and copy following lowercase */
            *s++ = *p++;
        s -= *n-j==39 || j/2-*n==1;   /* backup one if 9 is followed by 0, or if 2 or 3 is at end of input */
    }
    *o -= 32;                   /* Capitalise symbol */
    strcpy(s,"ium");            /* Finish name */
}

테스트 하네스 :

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    char buf[1024];
    while (*++argv) {
        f(*argv, buf);
        printf("%s %s\n", *argv, buf);
    }
    return EXIT_SUCCESS;
}

R, 278 바이트

g<-function(x){k<-data.frame(c("nil","un","bi","tri","quad","pent","hex","sept","oct","enn"));row.names(k)<-0:9;n<-unlist(strsplit(as.character(x),""));return(sub("nnn","nn",sub("ii","i",paste(c(as.vector(k[n,]),"ium"," ",sapply(k[n,],function(x)substr(x,1,1))),collapse=""))))}

최고는 아니지만 ... 여전히 R을 배우고 있으므로 시도를 게시 할 것이라고 생각했습니다. 더 나은 제안이 있으십니까? 이제 생각하기 때문에 행 이름을 만드는 공간을 낭비하지 않고 nth-1 행의 하위 집합을 만드는 것이 가능할 것입니다.

사용법 예

> g(118)
[1] "ununoctium uuo"
> g(999)
[1] "ennennennium eee"
> g(558)
[1] "pentpentoctium ppo"
> g(118)
[1] "ununoctium uuo"
> g(90)
[1] "ennilium en"
> g(2)
[1] "bium b"

언 골프

g <- function(x) {
    k <- data.frame(c("nil","un","bi","tri","quad","pent","hex","sept","oct","enn"))
    row.names(k) <- 0:9
    n <- unlist(strsplit(as.character(x),""))
    return(
        sub("nnn", "nn", sub("ii", "i", paste(c(as.vector(k[n,]),"ium"," ", sapply(k[n, ],function(x)substr(x,1,1))), collapse = ""))))
}

1. 키를 생성하고 데이터 프레임으로 변환 한 후 변수로 설정 k
2. 0-9쉽게 식별 할 수 있도록 행 이름을 설정하십시오.
3. 입력을 받아 x문자로 변환 한 후 나눕니다 (예 : 137 ~ "1" "3" "7")
4. k분할 번호 입력을 기반으로하는 하위 집합 및 항목 반환
5. 그것들을 연결하고 추가하십시오 -ium
6. 또한 k일치하는 첫 번째 문자를 가져 오기 위해 부분 문자열을 사용하는 하위 집합 입니다. 이것은 5 단계의 출력에 연결되어 있으며 그 사이에 공백이 있습니다.
7. 및 패턴 sub()을 교체하는 데 사용nnnii

자바 스크립트-169 바이트

n=>eval(`q='nil0un0bi0tri0quad0pent0hex0sept0oct0enn'.split(0);for(b of (_=$='')+n){c=q[b];$+=q[b];_+=(_?c:c.toUpperCase())[0]}$.replace(/i$()|n(nn)/g,'$1$2')+'ium '+_`)

기 묘하게도 map을 사용하려는 시도가 for 루프보다 길었 습니다.

편집 : 죄송합니다, 날짜를 확인하는 것을 잊었다.

PHP, 131 + 1 바이트 (untriunium)

여전히 끔찍하게 길다 :

for(;~$c=$argn[$i];print$i++?$n[0]:$n&_)$r.=$n=[nil,un,bi,tri,quad,pent,hex,sept,oct,enn][$c];echo strtr(_.$r.ium,[ii=>i,nnn=>nn]);

파이프로 실행 -nR하거나 온라인으로 사용해보십시오 .

파이썬, 154 바이트

import re
n=input('')
for c in n:
 print(re.sub('ii','i',re.sub('nnn','nn',['nil','un','bi','tri','quad','pent','hex','sept','oct','enn'][int(c)]+'ium')))