IUPAC en su sabiduría insufrible ha creado un nombre de elemento sistemático para cualquier elemento recién creado. Este es el nombre temporal de un elemento hasta que finalmente deciden acerca de un nombre real. Funciona así: a cada dígito de un número de elemento se le asigna un prefijo en función de su valor. Los prefijos se concatenan con 'ium' al final. Cuando se hace esto y si obtiene dobles i's (ii) o triples n's (nnn), reemplácelos con single i's y double n's. El símbolo para el elemento es la primera letra de cada prefijo utilizado concatenado y resultado en mayúscula. Los prefijos utilizados están a continuación.

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

Entonces, para este golf, su código necesita generar tanto el nombre del elemento como su símbolo para un entero positivo dado. Entonces, si su código recibió 137, debería imprimirse en stdout o devolver ambos untriseptiumy Uts. Debe ser válido desde al menos 118 a 558 . Cualquier valor superior es válido si no aumenta la longitud de su código.

Ejemplo de Python que muestra el 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 gana con bytes de cadmio!

Mathematica 10.1, indio (49) cadmio (48)

Esta solución utiliza una biblioteca integrada de propiedades de elementos, incluidos los nombres y abreviaturas de IUPAC. (No he visto esto como una técnica que se debe evitar en el golf. Parece alentarse. Pero esto podría estar (tal vez por encima) de lo aceptable: Mathematica implementa esta biblioteca (y muchas otras) descargando datos de Los servidores de Wolfram la primera vez que lo usas (y supongo que ocasionalmente verifica si hay actualizaciones).

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

¿Cómo se compara esto con el uso de elements.py o periodictable.py en Python?

Editar: Meses después: Noté que había escrito la salida abreviada de 122. He vuelto a ejecutar el código y verifiqué que cometí este error, no Mathematica.

Python 3, Unhexseptium (167) bytes

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

Estos son los resultados cuando el programa se ejecuta en cada número del 1 al 999 (inclusive)

Pipa , radion actio torio (86)

^{(No inhale esta entrada, le dará cáncer de pulmón).}

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

Toma el número del elemento como un argumento de línea de comando y genera el nombre y la abreviatura en líneas separadas.

Explicación (algo no golfista):

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)

El iiy nnnel manejo utiliza un reemplazo de expresiones regulares con una función de devolución de llamada (añadido en la versión más reciente de la pipa): para cada partido de ii|nnn, tomar todo menos el primer carácter y su uso como un reemplazo.

GNU sed, 171 (septunio)

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

Supongo que no importa en qué orden se devuelven el nombre y el símbolo. Aquí, el símbolo es lo primero:

$ 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

ahora capitaliza el símbolo

Esto es Mathematica sin el incorporado 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"}]&

Prueba en 10 números aleatorios:

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

La capitalización es la parte difícil. (Prueba en FireFox)

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

Espero jugar golf de esta manera

Editar: ¡Gracias por @steveverrill por reducir 9 bytes!

Edit2: ¡Gracias por @steveverrill nuevamente por otros 4 bytes! (¡Una solución realmente inteligente!)

Pyth, 67 bytes (holmio)

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

Pruébelo en línea en Pyth Compiler / Executor .

Cómo 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, gracias a @ edc65!

130159147 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, me sentí tan golfista.

CJam, 74 72 71 70 69 bytes (Tulio)

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

Tenga en cuenta que el código contiene caracteres no imprimibles.

Gracias a @ Sp3000 por señalar un error en mi revisión inicial y sugerir el )/enfoque.

Pruébelo en línea en el intérprete Cjam: .

Cómo 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 en todas las entradas que puede lanzar, desde niliumhasta, hasta donde quiera llegar. Llegué ennennennennennennennennennennennennennennennennennennennennennenniumantes de rendirme presionando la 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]);

Y una explicación:

%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

El número de elemento N solo puede tener una triple "n" si termina en 90, y solo puede tener una doble "i" si el último dígito es 2 o 3. Utilizamos las matemáticas para verificar esos casos.

El número mágico 1.5154, que almacena la longitud de cada prefijo, se encontró con un script Python para buscar todas decimales de longitud ≤7 utilizando las funciones cosh(, cos(y e^(.

Todavía no ha terminado de jugar al golf, pero las letras minúsculas de dos bytes de TI-BASIC y la falta de comandos de manipulación de cadenas, como siempre, afectarán la puntuación de este 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())

En lugar de reemplazar iicon irstrip cualquier is antes de agregar el ium, ya que esa es la única fuente posible de doble is. Del mismo modo, despojamos ns al buscar un enn/nilcaso.

Retina, 206 196 186 179 (Unseptennium) bytes ( Pruébelo en línea )

Gracias a @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ) por enseñarme este idioma.

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

Versión de Ueh-byte: aquí

Versión Bnh-byte: aquí

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"

Pruébalo en línea

Esto compite en la categoría "idiomas sin expresiones regulares, y solo con caracteres imprimibles". ;) Realmente no esperaba que fuera tan corto como algunas de las soluciones ya publicadas, pero tenía curiosidad de cuánto tiempo terminaría de todos modos. Y desde que lo obtuve ahora, bien podría publicarlo.

Explicación:

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

Lee tres caracteres de STDIN, se ignoran más, menos resultan en un bloqueo. Entonces funciona para cada número entre unnilniliumy 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 sencillo y sin sorpresas aquí. Excepto, tal vez, que resolví el problema de las mayúsculas al poner en minúsculas todo menos la primera parte y tener las partes individuales ya en mayúsculas. Agresivamente en línea para evitar perder caracteres por asignaciones de variables desnudas.

Bonificación después del último cambio: ahora también funciona para números de elementos más largos:

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

C en x86, 192 (Unennbio)

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

Lee dígitos stdine imprime los resultados en stdout. Se basa en sizeof(char*) == sizeof(int).

Versión sin golf:

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, bipentbio ( 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

Afeitado 34 bytes de descuento gracias a nimi.

GNU sed, unhexunio (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

Primero genero el símbolo, luego lo guardo en el espacio de espera y creo el nombre. Un bucle es más golfístico que usarlo /gpara cuatro o más reemplazos (solo podemos tener uno iiy / o uno nnn, por lo que no es necesario que estén dentro del bucle, pero no duele). Finalmente, recupere y agregue el símbolo retenido.

(Nota: no había visto la respuesta sed existente cuando escribí esto)

Casos de prueba

Estos ejercen las reglas especiales iiy 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

Y uno ridículo, que muestra cuánto más da este código, en comparación con el 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')

Formateado:

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

Bueno, al menos PHP esta vez en algún lugar alrededor del promedio.

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

Ejecuta la línea de comando del formulario como:

pentium.php 163

Salida:

unhextrium Uht

Sin golf

$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

• ahorró 10 bytes reemplazando todo (no solo uno, duh ) array()-inicializador con[]
• ahorró 1 byte al agregar el espacio en blanco junto con 'ium 'una concatenación adicional.' '.

Perl, 109 (Unnilennium) bytes

108 código + 1 interruptor

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'

Toma la entrada de STDIN como un número por línea.

Java 8 216 Bytes

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

El truco "n-'0 '" es una forma de convertir de ascii a int. Char 9 = ASCII 57. Char 0 = ASCII 48, entonces 57-48 = 9.

cadena privada estática ToText (int v) {return (string.Join ("", v.ToString (). Seleccione ((char n) => "nil un bi tri quad pent hex sept oct enn" .Split () [n -'0 '])) + "ium"). Reemplazar ("nnn", "nn"). Reemplazar ("ii", "i") + "" + string.Join ("", v.ToString () .Seleccione ((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;
    }

Este enfoque toma el int, lo convierte en una cadena y luego realiza una selección de caracteres LINQ que dispara una lambda.

La lambda genera una matriz sobre la marcha (menos caracteres que la definición) al dividir la cadena de prefijos. Luego, extrae el índice del prefijo para usar mirando el valor int del carácter actual (el truco n-'0 'mencionado anteriormente).

Todo lo que está envuelto en una cadena. Unir que concatena todos los resultados LINQ juntos. Agregue el "ium", luego un par de declaraciones .Replace al final para limpiar el nnn 'y el ii's.

Se agregó la salida del símbolo que falta. Creo que hay una manera más eficiente al fusionar los dos LINQ, pero es demasiado tarde para seguir hurgando.

C, 210 204 unenenio (199) bytes

Esto requiere ASCII como el conjunto de caracteres de tiempo de ejecución.

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

Intenté una solución recursiva (que evita la necesidad de py o) pero resultó más tiempo.

Estoy particularmente orgulloso / avergonzado de la coincidencia para la expresión regular 90|[23]$, que se basa 9y 0es el dígito separado más alejado (y, por lo tanto, el único par que difiere en 9; 39el código es una consecuencia de jser un valor entero y *naún un ASCII carácter) y eso 2y 3difieren solo en el último bit, por lo que dividir por 2 los combina.

Código ampliado:

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

Arnés de prueba:

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

No es el mejor ... pero todavía estoy aprendiendo R, así que pensé en publicar mi intento. ¿Alguna sugerencia para mejorarlo? Ahora que lo pienso, probablemente sea posible subconjunto en la fila n-1 en lugar de perder espacio creando nombres de fila.

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

Sin golf

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. Cree una clave, conviértala en un marco de datos y configúrela como variable k
2. Establezca los nombres de fila como 0-9para una fácil identificación
3. Tome la entrada x, conviértala en carácter, divídala (p. Ej. 137 a "1" "3" "7")
4. Subconjunto kbasado en la entrada del número dividido y devuelve las entradas
5. Concatenarlos juntos y agregar -ium
6. Subconjunto también kusando subcadena para extraer la primera letra de las coincidencias. Esto se concatena a la salida del paso 5 con un espacio en blanco entre ellos
7. Use sub()para reemplazar los patrones nnnyii

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

Curiosamente, mis intentos de usar el mapa fueron más largos que el ciclo for.

EDITAR: Vaya, olvidé comprobar la fecha.

PHP, 131 + 1 bytes (untriunio)

todavía muy largo:

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

Ejecutar como tubería -nRo probarlo en línea .

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