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，则应将其打印到stdout或同时返回untriseptium和Uts。它的有效期至少应为118到558。如果不增加代码长度，则更高的值是有效的。

显示该方法的Python示例：

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

这与在Python中使用elements.py或periodtable.py相比有什么不同？

编辑：几个月后：注意到我已经输入了122的缩写输出。

Python 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（包括1和999）之间的每个数字上运行时的结果

PIP，钍 锕氡（86）

^{（请勿吸入该物质，它会使您罹患肺癌。）}

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

将元素编号作为命令行参数，并在单独的行上输出名称和缩写。

说明（有点不符合要求）：

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

JavaScript（ES6）164（unhexquadium）171

大写是棘手的部分。（在FireFox中测试）

编辑保存的3个字节thx user2786485

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

我希望这样打下去

编辑：感谢@steveverrill削减了9个字节！

Edit2：再次感谢@steveverrill 4个字节！（非常聪明的解决方案！）

Pyth，67个字节（Ho）

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

在Pyth编译器/执行器上在线尝试。

这个怎么运作

            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)

的JavaScript（ES6），210 202字节（Biunnilium Binilbium）

减去八（8）个字节，这要归功于@ edc65！

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)。gh，我感觉很高尔夫。

CJam，74 72 71 70 69字节（Thulium）

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（s）

可以处理所有可能投入的输入，从nilium最远到最远都可以。我到ennennennennennennennennennennennennennennennennennennennennennennium之前，我放弃了与按9键。

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，存储每个前缀的长度，是使用Python脚本使用搜索功能长度的所有小数≤7发现cosh(，cos(和e^(。

尚未进行高尔夫运动，但是TI-BASIC的两字节小写字母以及一如既往的缺乏字符串操作命令将损害该程序的得分。

Python 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使用s之前将istrip 替换掉，因为这是double 的唯一可能来源。同样，我们通过检查大小写来剥离。iiuminenn/nil

视网膜，206 196 186 179（Unseptennium）字节（在线试玩）

感谢@MartinBüttner（https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner）教给我这种语言。

感谢@FryAmTheEggman斩断了7个字节。

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.

Go，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

C on x86、192（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)
}

Haskell中，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，hexunium（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

我先生成符号，然后将其存储到容纳空间并创建名称。循环比使用/g四个或更多替换球更具高尔夫感（我们只能有一个ii和/或一个nnn，因此它们不必位于循环中，但不会造成伤害）。最后，检索并附加保留的符号。

（注意，当我写这篇文章时，我没有看到现有的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个（非字节）字节

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的输入作为每行一个数字。

Java 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 = ASCII57。Char0 = 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” .Split（）[n -'0']））+“ ium”）。Replace（“ nnn”，“ nn”）。Replace（“ ii”，“ i”）+“” + string.Join（“”，v.ToString（） .Select（（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选择字符以触发lambda。

lambda通过拆分前缀字符串来动态生成一个数组（少于定义它的字符）。然后，通过查看当前字符的int值（上面提到的n-'0'技巧），拉出要使用的前缀索引。

所有这些都包装在一个字符串中。Join将所有LINQ结果连接在一起。敲击“ ium”，然后在末尾输入几个.replace语句以清理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），但结果却更长了。

我对regexp的匹配器感到特别自豪/羞愧90|[23]$，它是regexp的依靠，9并且0是最远的分开的数字（因此，唯一的一对相差9 －39代码中的结果j是成为整数值并且*n仍然是ASCII）字符）和那个字符，2并且3仅在最后一位不同，因此将其除以2会将其压缩。

扩展代码：

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()更换nnn和ii图案

Javascript-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或在线尝试。

Python，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')))