Dans leur insupportable sagesse, l' IUPAC a créé un nom d'élément systématique pour tout élément nouvellement créé. C'est le nom temporaire d'un élément jusqu'à ce qu'ils se décident enfin du nom réel. Cela fonctionne comme suit: chaque préfixe d'un numéro d'élément se voit attribuer un préfixe en fonction de sa valeur. Les préfixes sont concaténés avec "ium" à la fin. Lorsque cela est fait et si vous obtenez double i (ii) ou triple n (nnn), remplacez-les par simples i et doubles n. Le symbole de l'élément est la première lettre de chaque préfixe utilisé, concaténé et en majuscule. Les préfixes utilisés sont ci-dessous.

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

Donc, pour ce golf, votre code doit générer à la fois le nom de l'élément et son symbole pour un entier positif donné. Donc, si votre code a été donné 137, il devrait imprimer sur stdout ou renvoyer les deux untriseptiumet Uts. Il devrait être valide d'au moins 118 à 558 . Toute valeur supérieure est valable si elle n'augmente pas la longueur de votre code.

Exemple Python montrant la méthode:

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 gagne avec des octets de cadmium!

Mathematica 10.1, indium (49) cadmium (48)

Cette solution utilise une bibliothèque intégrée de propriétés d'élément, y compris les noms et les abréviations IUPAC. (Je n’ai pas vu cela comme une technique à éviter en Golf. Cela semble être encouragé. Mais c’est peut-être à la limite de ce qui est acceptable - Mathematica implémente cette bibliothèque (et beaucoup d’autres) en téléchargeant des données depuis Les serveurs de Wolfram la première fois que vous l'utilisez (et je suppose que vérifie les mises à jour à l'occasion).)

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

Comment cela se compare-t-il à l'utilisation d'éléments.py ou periodictable.py en Python?

Edit: Des mois plus tard: J'ai remarqué que j'avais écrit l'abréviation pour 122. J'ai relu le code et vérifié que j'avais commis cette erreur, pas Mathematica.

Python 3, Unhexseptium (167) octets

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

Ce sont les résultats lorsque le programme est exécuté sur chaque nombre de 1 à 999 (inclus)

Pip , radium actinium thorium (86)

^{(N'inspirez pas cette entrée, cela vous donnera un cancer du poumon.)}

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

Prend le numéro d'élément en tant qu'argument de ligne de commande et affiche le nom et l'abréviation sur des lignes séparées.

Explication (un peu non golfée):

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)

Le traitement de iiand nnnutilise un remplacement de regex avec une fonction de rappel (ajoutée dans la version la plus récente de Pip): pour chaque correspondance de ii|nnn, prenez tous les caractères sauf le premier et utilisez-les en remplacement.

GNU sed, 171 (unseptunium)

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

Je suppose que l'ordre dans lequel le nom et le symbole sont retournés n'a pas d'importance. Ici, le symbole vient en premier:

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

capitalise maintenant le symbole

Ceci est Mathematica sans la fonction intégrée 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"}]&

Test sur 10 nombres aléatoires:

# -> 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 capitalisation est la partie la plus délicate. (Test en FireFox)

Éditez 3 octets sauvegardés 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) octets

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

J'espère jouer au golf de cette façon

Edit: Merci pour @steveverrill pour avoir réduit de 9 octets!

Edit2: Merci encore pour @steveverrill pour encore 4 octets! (Solution vraiment intelligente!)

Pyth, 67 octets (Holmium)

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

Essayez-le en ligne dans le compilateur / exécuteur Pyth .

Comment ça fonctionne

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

Moins octium (8) octets, grâce à @ edc65!

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

Entrée comme f(324). Ugh, je me sentais tellement golf-y.

CJam, 74 72 71 70 69 octets (Thulium)

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

Notez que le code contient des caractères non imprimables.

Merci à @ Sp3000 d'avoir signalé une erreur dans ma révision initiale et d'avoir suggéré l' )/approche.

Essayez en ligne à l' interprète CJAM: .

Comment ça fonctionne

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)

Fonctionne sur toutes les entrées que vous pouvez lancer, de niliumhaut en bas, aussi loin que vous le souhaitez. J'y suis arrivé ennennennennennennennennennennennennennennennennennennennennennenniumavant d'abandonner avec l'appui de la touche 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]);

Et une explication:

%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 octets

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

L'élément numéro N ne peut avoir un triple "n" que s'il se termine par 90, et ne peut avoir un double "i" que si le dernier chiffre est 2 ou 3. Nous utilisons les mathématiques pour vérifier ces cas.

Le nombre magique 1.5154, qui stocke la longueur de chaque préfixe, a été trouvé en utilisant un script Python pour rechercher toutes les décimales de longueur ≤ 7 en utilisant les fonctions cosh(, cos(et e^(.

Pas encore de jouer au golf, mais les lettres minuscules à deux octets et le manque de commandes de manipulation des cordes de TI-BASIC vont, comme toujours, nuire au score de ce programme.

Python 3, unpentquadium ( 156 155 154) octets

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

Plutôt que de remplacer iipar un irenvoi, nous renversons les is avant de virer de bord ium, car c’est la seule source possible de double is. De la même manière, nous décapons ns en recherchant un enn/nilcas.

Retina, 206 196 186 179 (Unseptennium) octets ( Essayez en ligne )

Merci à @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ) de m'avoir appris cette langue.

Merci à @FryAmTheEggman d' avoir coupé 7 octets.

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

Version Ueh-Byte: ici

Version Bnh-Byte: ici

CJam, 95 octets

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

Essayez-le en ligne

Ceci entre en compétition dans la catégorie "langages sans regex, et n'utilisant que des caractères imprimables". ;) Je ne m'attendais pas vraiment à une solution aussi courte que certaines des solutions déjà publiées, mais j'étais curieuse de savoir combien de temps elle durerait. Et depuis que je l’ai maintenant, je pourrais aussi bien le poster.

Explication:

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

Lit trois caractères de STDIN, plus sont ignorés, moins de résultats dans un crash. Donc, cela fonctionne pour chaque nombre compris entre unnilniliumet 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]})

Assez simple et sans surprises ici. Sauf peut-être que j'ai résolu le problème de la capitalisation en mettant les minuscules tout sauf la première partie et en ayant les différentes parties déjà dans le titre. Désormais, il est impérativement intégré pour éviter de perdre des caractères lors d’affectations de variables nues.

Bonus après le dernier changement: fonctionne désormais pour les numéros d'élément plus longs:

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

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

Lit les chiffres stdinet imprime les résultats dans stdout. S'appuie sur sizeof(char*) == sizeof(int).

Version non-golfée:

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

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

Rasé 34 octets grâce à Nimi.

GNU sed, unhexunium (161 octets)

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

Je génère d'abord le symbole, puis le cache dans un espace réservé et crée le nom. Une boucle est plus golfeuse que l’utilisation /gde quatre remplacements ou plus (nous ne pouvons avoir qu’un iiet / ou un nnn, ils n’ont donc pas besoin d’être à l’intérieur de la boucle, mais cela ne fait pas mal). Enfin, récupérez et ajoutez le symbole maintenu.

(NB: je n'avais pas vu la réponse sed existante quand j'ai écrit ça)

Cas de test

Ces règles iiet nnnrègles spéciales:

$ 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

Et un ridicule, montrant combien ce code donne plus par rapport au monde physique:

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

T-SQL 329 octets

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

Formaté:

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

Eh bien, au moins PHP est quelque part autour de la moyenne cette fois-ci.

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

Fonctionne en ligne de commande comme:

pentium.php 163

Sortie:

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

Modifier

• sauvé 10 octets en remplaçant tout (pas seulement un, duh ) array()-initializer par[]
• enregistré 1 octet en ajoutant les espaces blancs avec à la 'ium 'place en utilisant une concaténation supplémentaire.' '.

Perl, 109 octets

108 code + 1 commutateur

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'

Prend l'entrée de STDIN sous la forme d'un nombre par ligne.

Java 8 216 octets

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 octets unennoctium

Le truc "n-'0" est un moyen de convertir d'asci en int. Caractère 9 = ASCII 57. Caractère 0 = ASCII 48, donc 57-48 = 9.

Chaîne privée statique ToText (int v) {return (string.Join ("", v.ToString (). Select.) ((char n) => "rien ne trie pent pent hex sept oct enn" .Split () [n -'0 '])) + "ium"). Remplacez ("nnn", "nn"). Remplacez ("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;
    }

Cette approche prend l'int, convertit en chaîne, puis effectue une sélection de caractères LINQ qui se déclenche avec un lambda.

Le lambda génère un tableau à la volée (moins de caractères que sa définition) en scindant la chaîne de préfixes. Il extrait ensuite l'index du préfixe à utiliser en regardant la valeur int du caractère actuel (astuce n-'0 'mentionnée ci-dessus).

Tout cela est enveloppé dans une chaîne.Join qui concatène tous les résultats LINQ ensemble. Cliquetez sur le "ium", puis quelques déclarations. Remplacez à la fin pour nettoyer les nnn 'et ii.

Ajout de la sortie de symbole manquante. Je pense qu'il existe un moyen plus efficace de fusionner les deux LINQ, mais il est trop tard pour continuer à le fouiller.

C, 210 204 unennennium (199) octets

Cela nécessite ASCII en tant que jeu de caractères d'exécution.

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

J'ai essayé une solution récursive (qui évite le besoin de pet o) mais cela s'est avéré plus long.

Je suis particulièrement fier / honte de l'matcher pour l'expression rationnelle 90|[23]$, qui repose sur 9et 0étant le plus éloigné séparé chiffres (et donc la seule paire qui diffèrent par 9 - le 39dans le code est une conséquence d' jêtre une valeur entière , et *nencore une ASCII caractère) et que 2et 3diffèrent seulement dans le dernier bit, divisant par 2 les confond.

Code développé:

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

Harnais de test:

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

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

Pas le meilleur ... mais j'apprends toujours R alors j'ai pensé poster ma tentative. Des suggestions pour le rendre meilleur? Maintenant que j'y pense, il est probablement possible de créer un sous-ensemble sur la première ligne plutôt que de perdre de l'espace en créant des noms de ligne.

Exemple d'utilisation

> 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. Créer une clé, convertir en trame de données et définir comme variable k
2. Définissez les noms de ligne comme 0-9pour une identification facile
3. Prenez l’entrée x, convertissez-la en caractère, divisez-la (par exemple, 137 en "1" "3" "7")
4. Sous-ensemble kbasé sur l'entrée du numéro divisé et renvoyer les entrées
5. Concaténez-les et ajoutez -ium
6. kUtilisez également une sous- chaîne pour extraire la première lettre des correspondances. Ceci est concaténé à la sortie de l'étape 5 avec un espace vide entre eux
7. Utiliser sub()pour remplacer les motifs nnnetii

Javascript - 169 octets

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

Bizarrement, mes tentatives d'utiliser map ont été plus longues que la boucle for.

EDIT: Oups, j'ai oublié de vérifier la date.

PHP, 131 + 1 octets (untriunium)

encore terriblement long:

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

Exécuter en pipe -nRou essayer en ligne .

Python, 154 octets

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