IUPAC nella sua insostenibile saggezza ha creato un nome di elemento sistematico per qualsiasi elemento appena creato. Questo è il nome temporaneo di un elemento fino a quando non decidono finalmente un vero nome. Funziona così: a ogni cifra di un numero di elemento viene assegnato un prefisso in base al suo valore. I prefissi sono concatenati con 'ium' alla fine. Quando questo è fatto e se ottieni doppie i (ii) o triple n (nnn), sostituiscile con singole i e doppie n. Il simbolo per l'elemento è la prima lettera di ogni prefisso usato concatenato e il risultato maiuscolo. I prefissi utilizzati sono di seguito.

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

Quindi per questo golf, il tuo codice deve generare sia il nome dell'elemento che il suo simbolo per un dato intero positivo. Quindi, se il tuo codice è stato dato 137, dovrebbe stampare su stdout o restituire entrambi untriseptiume Uts. Dovrebbe essere valido da almeno 118 a 558 . Qualsiasi valore superiore è valido se non aumenta la lunghezza del codice.

Esempio di Python che mostra il metodo:

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 vince con byte di cadmio!

Mathematica 10.1, indio (49) cadmio (48)

Questa soluzione utilizza una libreria integrata di proprietà degli elementi, inclusi nomi e abbreviazioni IUPAC. (Non ho visto questo come una tecnica da evitare nel golf. Sembra essere incoraggiato. Ma questo potrebbe essere (forse oltre) al limite dell'accettabile - Mathematica implementa questa libreria (e molti altri) scaricando i dati da I server di Wolfram la prima volta che lo usi (e presumo occasionalmente controlli degli aggiornamenti).)

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

Come si confronta con l'utilizzo di elements.py o periodictable.py in Python?

Modifica: mesi dopo: ho notato che avevo scritto in modo errato l'output dell'abbreviazione per 122. Ho rieseguito il codice e verificato di aver fatto questo errore, non Mathematica.

Python 3, Unhexseptium (167) byte

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

Questi sono i risultati quando il programma viene eseguito su ogni numero compreso tra 1 e 999 (incluso)

Pip , Thorium Actinium Radon (86)

^{(Non inalare questa voce, ti darà il cancro ai polmoni.)}

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

Prende il numero dell'elemento come argomento della riga di comando e genera il nome e l'abbreviazione su righe separate.

Spiegazione (un po 'ungolfed):

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

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

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

The iiand nnnhandling utilizza una sostituzione regex con una funzione di callback (aggiunta nella versione più recente di Pip): per ogni partita di ii|nnn, prendi tutto tranne il primo carattere e usalo come sostituzione.

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

Presumo che non importa in quale ordine vengano restituiti il ​​nome e il simbolo. Qui, il simbolo viene prima di tutto:

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

ora capitalizza il simbolo

Questo è Mathematica senza il 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"}]&

Test su 10 numeri casuali:

# -> 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 capitalizzazione è la parte difficile. (Test in FireFox)

Modifica 3 byte salvati grazie all'utente2786485

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>

Rubino - 163 156 147 143 134 (Untriquadium) byte

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

Spero di giocare a golf in questo modo

Modifica: Grazie per @steveverrill per aver rasato 9 byte!

Edit2: Grazie ancora per @steveverrill per altri 4 byte! (Soluzione davvero intelligente!)

Pyth, 67 byte (olmio)

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

Provalo online nel compilatore / Executor Pyth .

Come funziona

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

Minus octium (8) byte, grazie a @ edc65!

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

Inserisci come f(324). Uff, mi sentivo così golf-y.

CJam, 74 72 71 70 69 byte (Thulium)

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

Si noti che il codice contiene caratteri non stampabili.

Grazie a @ Sp3000 per aver segnalato un errore nella mia revisione iniziale e suggerito l' )/approccio.

Provalo in rete nel interprete CJam: .

Come funziona

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)

Funziona su tutti gli input che puoi lanciare, da niliumfino a, e per quanto ti interessa. devoennennennennennennennennennennennennennennennennennennennennennennium prima di arrendermi premendo il tasto 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 una spiegazione:

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

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'elemento numero N può avere solo una tripla "n" se termina in 90 e può avere solo una doppia "i" se l'ultima cifra è 2 o 3. Usiamo la matematica per controllare quei casi.

Il numero magico 1.5154, che memorizza la lunghezza di ciascun prefisso, è stato trovato usando uno script Python per cercare tutti i decimali di lunghezza ≤7 usando le funzioni cosh(,cos( e e^(.

Non ho ancora giocato a golf, ma le lettere minuscole a due byte di TI-BASIC e la mancanza di comandi di manipolazione delle stringhe, come sempre, danneggeranno il punteggio di questo programma.

Python 3, unpentquadium ( 156 155 154) byte

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

Invece di sostituirlo iicon i, rstrip qualsiasi is prima di puntare su ium, poiché questa è l'unica fonte possibile di double is. Allo stesso modo, eliminiamo le richieste nverificando un enn/nilcaso.

Retina, 206 196 186 179 (Unseptennium) byte ( Provalo online )

Grazie a @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ) per avermi insegnato questa lingua.

Grazie a @FryAmTheEggman per aver tagliato 7 byte.

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

Versione Ueh-byte: qui

Versione Bnh-byte: qui

CJam, 95 byte

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

Provalo online

Questo compete nella categoria "lingue senza regex e usando solo caratteri stampabili". ;) Non mi aspettavo davvero che fosse breve come alcune delle soluzioni già pubblicate, ma ero curioso di sapere quanto tempo sarebbe finito comunque. E dato che l'ho preso ora, potrei anche pubblicarlo.

Spiegazione:

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

Legge tre caratteri da STDIN, più vengono ignorati, meno risulta in un arresto anomalo. Quindi funziona per ogni numero compreso tra 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]})

Abbastanza semplice e senza sorprese qui. Tranne forse il fatto che ho risolto il problema della capitalizzazione minuscola tutto tranne la prima parte e avendo le singole parti già nella custodia del titolo. Ormai fortemente aggressivo per evitare di perdere caratteri per assegnazioni di variabili nude.

Bonus dopo l'ultima modifica: ora funziona anche per numeri di elementi più lunghi:

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

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

Legge cifre da stdine stampa i risultati a stdout. Conta su sizeof(char*) == sizeof(int).

Versione non golfata:

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

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

Rasato 34 byte grazie a nimi.

GNU sed, unhexunium (161 byte)

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

Genero prima il simbolo, quindi lo nascondo nello spazio di attesa e creo il nome. Un loop è più golfoso che utilizzare /gper quattro o più sostituzioni (possiamo avere solo uno iie / o uno nnn, quindi non devono essere all'interno del loop, ma non fa male). Infine, recupera e aggiungi il simbolo trattenuto.

(NB non avevo visto la risposta sed esistente quando ho scritto questo)

Casi test

Esercitano le regole speciali 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 uno ridicolo, che mostra quanto più offre questo codice, rispetto al mondo fisico:

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

T-SQL 329 byte

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

formattato:

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

Bene, almeno questa volta PHP è nella media.

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

Esegue la riga di comando come:

pentium.php 163

Produzione:

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

modificare

• salvato 10 byte sostituendo tutto (non solo uno, duh ) array()-inizializzatore con[]
• salvato 1 byte aggiungendo lo spazio bianco e 'ium 'usando invece una concatenazione aggiuntiva.' '.

Perl, 109 (Unnilennium) byte

108 codice + 1 interruttore

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'

Riceve input da STDIN come un numero per riga.

Java 8 216 byte

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

Il trucco "n-'0 '" è un modo per convertire da ascii a int. Char 9 = ASCII 57. Char 0 = ASCII 48, quindi 57-48 = 9.

stringa privata statica ToText (int v) {return (string.Join ("", v.ToString (). Select ((char n) => "nil un bi tri quad pent hex hex set oct enn" .Split () [n -'0 '])) + "ium"). Sostituisci ("nnn", "nn"). Sostituisci ("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;
    }

Questo approccio prende int, si converte in una stringa, quindi esegue una selezione LINQ di caratteri che scatta una lambda.

La lambda genera un array al volo (meno caratteri che definendolo) suddividendo la stringa di prefissi. Quindi estrae l'indice del prefisso da utilizzare osservando il valore int del personaggio corrente (il trucco n-'0 'menzionato sopra).

Tutto ciò è racchiuso in una stringa. Unisci che concatena tutti i risultati LINQ insieme. Prova "ium", poi un paio di. Sostituisci le istruzioni alla fine per ripulire nnn 'e ii.

Aggiunto l'output del simbolo mancante. Penso che ci sia un modo più efficiente unendo i due LINQ, ma è troppo tardi per continuare a cercarlo.

C, 210 204 unennennium (199) byte

Ciò richiede ASCII come set di caratteri di runtime.

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

Ho provato una soluzione ricorsiva (che evita la necessità di pe o) ma che si è rivelata più lunga.

Sono particolarmente orgoglioso / vergogna del matcher per la regexp 90|[23]$ , che si basa su 9ed 0essendo la più lontana separato cifre (e quindi l'unica coppia che differiscono di 9 - il 39nel codice è una conseguenza di jessere un valore intero e *nancora un ASCII carattere) e quello 2e 3differiscono solo nell'ultimo bit, quindi dividendoli per 2 li confonde.

Codice espanso:

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

Collaudare l'imbragatura:

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

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

Non il migliore ... ma sto ancora imparando R, quindi ho pensato di pubblicare il mio tentativo. Qualche suggerimento per renderlo migliore? Ora che ci penso è probabilmente possibile effettuare il sottoinsieme nella riga n-1 anziché sprecare spazio creando nomi di riga.

Esempio di utilizzo

> 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. Crea una chiave, converti in frame di dati e imposta come variabile k
2. Impostare i nomi delle righe come 0-9 per una facile identificazione
3. Prendi l'input x , converti in carattere, suddividilo (es. 137 in "1" "3" "7")
4. sottoinsieme k basato sull'input del numero diviso e restituire le voci
5. Concatenali insieme e aggiungi -ium
6. Anche sottoinsieme k usando la sottostringa per estrarre la prima lettera delle corrispondenze. Questo è concatenato all'output del passaggio 5 con uno spazio vuoto tra di loro
7. Utilizzare sub()per sostituire i modelli nnneii

Javascript - 169 byte

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

Stranamente, i miei tentativi di usare la mappa sono stati più lunghi del ciclo for.

EDIT: Oops, ho dimenticato di controllare la data.

PHP, 131 + 1 byte (untriunium)

ancora terribilmente lungo:

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

Esegui come pipe -nRo provalo online .

Python, 154 byte

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