A IUPAC, em sua insuportável sabedoria, criou um nome de elemento sistemático para qualquer elemento recém-criado. Este é o nome temporário de um elemento até que eles finalmente se decidam sobre um nome real. Funciona assim: a cada dígito de um número de elemento é atribuído um prefixo com base em seu valor. Os prefixos são concatenados com 'ium' no final. Quando isso for feito e se você obtiver o dobro de i (ii) ou o triplo de n (nnn), substitua-os por um único i e um duplo n. O símbolo para o elemento é a primeira letra de cada prefixo usado concatenado e o resultado em maiúscula. Os prefixos usados ​​estão abaixo.

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

Portanto, para esse golfe, seu código precisa gerar o nome do elemento e seu símbolo para um número inteiro positivo. Portanto, se seu código recebeu 137, ele deve ser impresso em stdout ou retornado ambos untriseptiume Uts. Deve ser válido de pelo menos 118 a 558 . Qualquer valor mais alto é válido se não aumentar o comprimento do seu código.

Exemplo de Python mostrando o método:

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

Eric Towers vence com bytes de cádmio!

Mathematica 10.1, índio (49) cádmio (48)

Esta solução usa uma biblioteca interna de propriedades do elemento, incluindo nomes e abreviações IUPAC. (Eu não vi isso como uma técnica a ser evitada no Golf. Parece ser incentivado. Mas isso pode estar (talvez acima) no limite do aceitável - o Mathematica implementa essa biblioteca (e muitas outras) baixando dados de Servidores da Wolfram na primeira vez em que você o usa (e presumo que verifique atualizações ocasionalmente).

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

Como isso se compara ao uso de elements.py ou periodictable.py no Python?

Edit: Meses depois: Notei que havia digitado a saída de abreviação para 122. Repeti o código e verifiquei que cometi esse erro, não o Mathematica.

Bytes 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())

Estes são os resultados quando o programa é executado em todos os números de 1 a 999 (inclusive)

Pip , Radônio Actinium de Tório (86)

^{(Não inspire esta entrada, isso causará câncer de pulmão.)}

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

Pega o número do elemento como um argumento da linha de comando e gera o nome e a abreviação em linhas separadas.

Explicação (um pouco não-destruída):

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)

O manipulador iiand nnnusa uma substituição de regex com uma função de retorno de chamada (adicionada na versão mais recente do Pip): para cada correspondência de ii|nnn, pegue apenas o primeiro caractere e use-o como um substituto.

GNU sed, 171 (unseptúnio)

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

Suponho que não importa em que ordem o nome e o símbolo são retornados. Aqui, o símbolo vem primeiro:

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

Mathematica, unhexunium 163 161 bytes

agora capitaliza o símbolo

Este é o Mathematica sem o built-in 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"}]&

Teste em 10 números aleatórios:

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

A capitalização é a parte complicada. (Teste no FireFox)

Editar 3 bytes salvos 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>

Ruby - 163 156 147 143 134 (Untriquadium) bytes

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

Eu estou esperando jogar golfe assim

Edit: Obrigado por @steveverrill por cortar 9 bytes!

Edit2: Obrigado por @steveverrill novamente por mais 4 bytes! (Solução realmente inteligente!)

Pitão, 67 bytes (Holmium)

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

Experimente online no Pyth Compiler / Executor .

Como funciona

            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 bytes ( Biunnilium Binilbium)

Menos octium (8) bytes, graças a @ edc65!

130 159 147 Bytes (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``

Entrada como f(324). Ugh, eu me senti tão golf-y.

CJam, 74 72 71 70 69 bytes (Túlio)

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

Observe que o código contém caracteres não imprimíveis.

Agradeço ao @ Sp3000 por apontar um erro na minha revisão inicial e sugerir a )/abordagem.

Experimente em linha no intérprete CJam: .

Como funciona

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 (Unseptnilium)

Funciona em todas as entradas que você pode niliumusar , de até, até onde você quiser. Eu cheguei ennennennennennennennennennennennennennennennennennennennennennenniumantes de desistir de pressionar a tecla 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]);

E uma explicação:

%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, 223 218 bytes

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

O número de elemento N só pode ter um "n" triplo se terminar em 90 e "i" duplo se o último dígito for 2 ou 3. Usamos matemática para verificar esses casos.

O número mágico 1.5154, que armazena o comprimento de cada prefixo, foi encontrado usando um script Python para pesquisar todos os decimais de comprimento ≤7 utilizando as funções cosh(, cos(e e^(.

Ainda não terminou o golfe, mas as letras minúsculas de dois bytes do TI-BASIC e a falta de comandos de manipulação de cordas, como sempre, afetarão a pontuação deste programa.

Python 3, unpentquadium ( 156 155 154) bytes

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

Em vez de substituir iipor i, removemos qualquer is antes de atacar o ium, pois essa é a única fonte possível de is duplo . Da mesma forma, removemos ns verificando um enn/nilcaso.

Retina, 206 196 186 179 (Unseptennium) bytes ( Experimente on-line )

Agradeço a @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ) por me ensinar esse idioma.

Obrigado a @FryAmTheEggman por cortar 7 bytes.

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`^.

Versão ueh-byte: aqui

Versão Bnh-byte: aqui

CJam, 95 bytes

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

Experimente online

Ele concorre na categoria "idiomas sem regex e usando apenas caracteres imprimíveis". ;) Realmente não esperava que fosse tão curto quanto algumas das soluções já postadas, mas fiquei curioso por quanto tempo isso acabaria. E como eu o comprei agora, é melhor postá-lo.

Explicação:

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 bytes (tribibium)

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

Lê três caracteres de STDIN, mais são ignorados, menos resultam em uma falha. Por isso, funciona para todos os números entre unnilniliume 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]})

Bastante direto e sem surpresas aqui. Exceto, talvez, que eu tenha resolvido a questão da capitalização, aplicando letras minúsculas a tudo, exceto a primeira parte, e tendo as partes individuais já em maiúsculas. Agrressivamente, agora, para evitar a perda de caracteres para atribuições de variáveis ​​simples.

Bônus após a última alteração: agora também funciona para números de elemento mais longos:

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

C em 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);}

Lê dígitos stdine imprime os resultados para stdout. Depende sizeof(char*) == sizeof(int).

Versão não destruída:

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

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

Retirou 34 bytes graças a nimi.

GNU sed, unhexunium (161 bytes)

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

Eu giro o símbolo primeiro, depois o escondo no espaço reservado e crio o nome. Um loop é mais eficiente do que o uso /gpara quatro ou mais substituições (podemos ter apenas um iie / ou um nnn, para que eles não precisem estar dentro do loop, mas não dói). Por fim, recupere e acrescente o símbolo em espera.

(NB eu não tinha visto a resposta sed existente quando escrevi isso)

Casos de teste

Eles exercem as regras especiais iie 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

E uma ridícula, mostrando quanto mais esse código oferece, comparado ao mundo físico:

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

T-SQL 329 bytes

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

Formatado:

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 bytes, unpentbium

Bem, pelo menos o PHP está em torno da média dessa vez.

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

Executa a linha de comando do formulário como:

pentium.php 163

Resultado:

unhextrium Uht

Ungolfed

$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);

Editar

• economizou 10 bytes substituindo todos (não apenas um, duh ) array()inicializador por[]
• economizou 1 byte adicionando o espaço em branco e 'ium 'usando uma concatenação extra.' '.

Perl, 109 bytes (Unnilennium)

Código 108 + 1 chave

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'

Recebe a entrada do STDIN como um número por linha.

Java 8 216Bytes

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 bytes de unennoctium

O truque "n-'0 '" é uma maneira de converter de ascii para int. Char 9 = ASCII 57. Char 0 = ASCII 48, então 57-48 = 9.

string privada estática ToText (int v) {return (string.Join ("", v.ToString (). Select ((char n) => "nulo))") -'0 '])) + "ium"). Substitua ("nnn", "nn"). Substitua ("ii", "i") + "" + string.Join ("", v.ToString () .Selecione ((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;
    }

Essa abordagem pega int, converte em uma sequência e executa uma seleção de caracteres LINQ que dispara uma lambda.

O lambda gera uma matriz em tempo real (menos caracteres do que a defini-la) dividindo a sequência de prefixos. Em seguida, ele puxa o índice do prefixo para uso, observando o valor int do caractere atual (o truque n-'0 'mencionado acima).

Tudo isso é envolvido em uma string.Join que concatena todos os resultados do LINQ juntos. Adquira o "ium" e, em seguida, algumas instruções. Substitua no final para limpar os nnn 'e ii's.

Adicionada a saída do símbolo ausente. Eu acho que existe uma maneira mais eficiente de mesclar os dois LINQs, mas é muito tarde para continuar cutucando.

C, 210 204 unennennium (199) bytes

Isso requer ASCII como o conjunto de caracteres de tempo de execução.

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

Eu tentei uma solução recursiva (o que evita a necessidade de pe o), mas que acabou por mais tempo.

Estou particularmente orgulhoso / envergonhado do matcher para o regexp 90|[23]$, que depende 9e 0é o dígito mais distante (e, portanto, o único par que difere por 9 - 39o código é uma conseqüência de jser um valor inteiro e *nainda um ASCII caractere) e that 2e 3diferem apenas no último bit, então dividir por 2 os confunde.

Código expandido:

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

Equipamento de teste:

#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 bytes

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

Não é o melhor ... mas ainda estou aprendendo R, então pensei em publicar minha tentativa. Alguma sugestão para melhorar? Agora que penso nisso, provavelmente é possível fazer um subconjunto na enésima-linha 1, em vez de desperdiçar espaço criando nomes de linhas.

Exemplo de uso

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

Ungolfed

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. Crie uma chave, converta em quadro de dados e defina como a variável k
2. Defina os nomes das linhas 0-9para facilitar a identificação
3. Pegue a entrada x, converta para caractere, divida-a (por exemplo, 137 para "1" "3" "7")
4. Subconjunto com kbase na entrada do número de divisão e retorna as entradas
5. Concatene-os e adicione -ium
6. Também subconjunto kusando substring para puxar a primeira letra das correspondências. Isso é concatenado para a saída da etapa 5 com um espaço em branco entre eles
7. Use sub()para substituir os padrões nnneii

Javascript - 169 bytes

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 '+_`)

Estranhamente, minhas tentativas de usar o mapa foram mais longas que o loop for.

EDIT: Opa, esqueci de verificar a data.

PHP, 131 + 1 bytes (untriunium)

ainda muito longo:

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

Execute como pipe -nRou experimente online .

Python, 154 bytes

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