Die IUPAC hat in ihrer unerträglichen Weisheit einen systematischen Elementnamen für jedes neu erstellte Element erstellt. Dies ist der temporäre Name eines Elements, bis sie sich endgültig über einen tatsächlichen Namen entschieden haben. Das funktioniert so: Jeder Ziffer einer Elementnummer wird anhand ihres Wertes ein Präfix zugewiesen. Die Präfixe werden am Ende mit 'ium' verkettet. Wenn dies erledigt ist und Sie doppelte i (ii) oder dreifache n (nnn) erhalten, ersetzen Sie sie durch einzelne i und doppelte n. Das Symbol für das Element ist der erste Buchstabe jedes verwendeten Präfixes, verkettet und das Ergebnis großgeschrieben. Die verwendeten Präfixe sind unten.

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

Daher muss Ihr Code für diesen Golf sowohl den Elementnamen als auch das Symbol für eine bestimmte positive Ganzzahl generieren. Wenn Ihr Code also mit 137 angegeben wurde, sollte er auf stdout gedruckt werden oder beide untriseptiumund zurückgeben Uts. Es sollte mindestens von 118 bis 558 gültig sein . Jeder höhere Wert ist gültig, wenn er die Länge Ihres Codes nicht erhöht.

Python-Beispiel mit der Methode:

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 gewinnt mit Cadmiumbytes!

Mathematica 10.1, Indium (49) Cadmium (48)

Diese Lösung verwendet eine integrierte Bibliothek mit Elementeigenschaften, einschließlich IUPAC-Namen und Abkürzungen. (Ich habe dies nicht als eine Technik gesehen, die beim Golfspielen vermieden werden sollte. Es scheint ermutigt zu sein. Aber dies könnte (vielleicht) am Rande des Akzeptablen liegen. Mathematica implementiert diese Bibliothek (und viele andere) durch Herunterladen von Daten von Wolframs Server, wenn Sie ihn zum ersten Mal verwenden (und ich gehe davon aus, dass gelegentlich nach Updates gesucht wird).

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

Inwiefern ist dies mit der Verwendung von elements.py oder periodictable.py in Python vergleichbar?

Bearbeiten: Monate später: Bemerkt, dass ich die Abkürzungsausgabe für 122 getippt habe. Ich habe den Code erneut ausgeführt und überprüft, dass ich diesen Fehler gemacht habe, nicht 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())

Dies sind die Ergebnisse, wenn das Programm auf jeder Zahl von 1 bis 999 (einschließlich) ausgeführt wird.

Pip , Thorium Actinium Radon (86)

^{(Atme diesen Eintrag nicht ein, es wird dir Lungenkrebs geben.)}

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

Nimmt die Elementnummer als Befehlszeilenargument und gibt den Namen und die Abkürzung in separaten Zeilen aus.

Erklärung (etwas 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)

Das iiund nnn-Verfahren verwendet einen regulären Ausdruck mit einer Rückruffunktion (in der neuesten Version von Pip hinzugefügt): ii|nnnNehmen Sie für jede Übereinstimmung von bis auf das erste Zeichen alle Zeichen und verwenden Sie sie als Ersatz.

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

Ich gehe davon aus, dass es keine Rolle spielt, in welcher Reihenfolge der Name und das Symbol zurückgegeben werden. Hier steht das Symbol an erster Stelle:

$ 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

Jetzt wird das Symbol groß geschrieben

Dies ist Mathematica ohne das eingebaute 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 auf 10 Zufallszahlen:

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

Die Großschreibung ist der schwierige Teil. (Test in Firefox)

Bearbeite 3 Bytes gespeichert als 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

Ich hoffe, dass ich auf diese Weise Golf spielen kann

Edit: Danke für @steveverrill für das Abschneiden von 9 Bytes!

Edit2: Danke nochmal für @steveverrill für weitere 4 Bytes! (Wirklich clevere Lösung!)

Pyth, 67 Bytes (Holmium)

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

Versuchen Sie es online im Pyth Compiler / Executor .

Wie es funktioniert

            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)

Minusoctium (8) Bytes, danke an @ 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``

Eingabe wie f(324). Ugh, ich fühlte mich so golfen.

CJam, 74 72 71 70 69 Bytes (Thulium)

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

Beachten Sie, dass der Code nicht druckbare Zeichen enthält.

Vielen Dank an @ Sp3000 für den Hinweis auf einen Fehler in meiner ersten Überarbeitung und den Vorschlag für die )/Vorgehensweise.

Versuchen Sie es online im CJam Interpreter: .

Wie es funktioniert

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)

Funktioniert mit allen Eingängen, die Sie verwenden können, von niliumbis zu, so weit Sie wollen. Ich musste, ennennennennennennennennennennennennennennennennennennennennennenniumbevor ich mit dem Drücken der 9-Taste aufgab.

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

Und eine Erklärung:

%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

Element Nummer N kann nur ein dreifaches "n" haben, wenn es mit 90 endet, und kann nur ein doppeltes "i" haben, wenn die letzte Ziffer 2 oder 3 ist. Wir verwenden Mathematik, um diese Fälle zu überprüfen.

Die magische Zahl 1.5154, die die Länge jeden Präfix speichert, wurde mit einem Python - Skript gefunden alle Dezimalstellen von Länge suchen ≤7 mit den Funktionen cosh(, cos(und e^(.

Das Golfen ist noch nicht abgeschlossen, aber die 2-Byte-Kleinbuchstaben von TI-BASIC und das Fehlen von Befehlen zur Manipulation von Zeichenfolgen beeinträchtigen die Punktzahl dieses Programms.

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

Anstatt sie zu ersetzen iimit iwir rstrip alle is , bevor wir auf die tack ium, da dies die einzige mögliche Quelle der Doppel ist is. Ebenso entfernen wir ns, indem wir nach einem enn/nilFall suchen .

Retina, 206 196 186 179 (Unseptennium) Bytes ( Online testen )

Vielen Dank an @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ), der mir diese Sprache beigebracht hat .

Vielen Dank an @FryAmTheEggman für das Abhacken von 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`^.

Ueh-Byte-Version: hier

Bnh-Byte-Version: hier

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"

Probieren Sie es online aus

Dies konkurriert in der Kategorie "Sprachen ohne Regex und nur mit druckbaren Zeichen." ;) Habe nicht wirklich damit gerechnet, dass es so kurz ist wie einige der bereits geposteten Lösungen, aber ich war gespannt, wie lange es sowieso dauern würde. Und da ich es jetzt habe, kann ich es auch posten.

Erläuterung:

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.

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

Liest drei Zeichen aus STDIN, mehr werden ignoriert, weniger führen zu einem Absturz. So funktioniert es für jede Zahl zwischen unnilniliumund 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]})

Ziemlich unkompliziert und keine Überraschungen. Außer vielleicht, dass ich die Großschreibung dadurch gelöst habe, dass ich alles bis auf den ersten Teil klein geschrieben habe und die einzelnen Teile bereits in Titelbuchstaben geschrieben habe. Inzwischen agressiv integriert, um den Verlust von Zeichen bei Zuweisungen von Variablen zu vermeiden.

Bonus nach der letzten Änderung: Funktioniert jetzt auch für längere Elementnummern:

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

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

Liest Ziffern aus stdinund druckt die Ergebnisse aus stdout. Verlässt sich auf sizeof(char*) == sizeof(int).

Ungolfed-Version:

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

34 Bytes weniger dank 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

Ich erstelle das Symbol, stelle es dann in den Laderaum und erstelle den Namen. Eine Schleife ist golfer als die Verwendung /gfür vier oder mehr Ersetzungen (wir können nur eine iiund / oder eine haben nnn, so dass sie nicht in der Schleife sein müssen, aber es tut nicht weh). Abschließend rufen Sie das angehaltene Symbol ab und hängen es an.

(NB ich hatte die existierende sed Antwort nicht gesehen, als ich dies schrieb)

Testfälle

Diese üben die iiund nnnSonderregeln aus:

$ 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

Und eine lächerliche, die zeigt, wie viel mehr dieser Code im Vergleich zur physischen Welt gibt:

$ ./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')

Formatiert:

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

Zumindest ist PHP diesmal ungefähr durchschnittlich.

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

Führt die Formularbefehlszeile wie folgt aus:

pentium.php 163

Ausgabe:

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

Bearbeiten

• 10 Byte gespeichert durch Ersetzen alle (nicht nur eine, duh ) array()-initializer mit[]
• 1 Byte gespart, indem das Leerzeichen hinzugefügt und 'ium 'stattdessen eine zusätzliche Verkettung verwendet wird.' '.

Perl, 109 (Unnilennium) Bytes

108 Code + 1 Schalter

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'

Übernimmt die Eingabe von STDIN als eine Nummer pro Zeile.

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 Unennoctium-Bytes

Der "n-'0 '" - Trick ist eine Möglichkeit, von ASCII zu Int zu konvertieren. Char 9 = ASCII 57. Char 0 = ASCII 48, also 57-48 = 9.

statischer privater String ToText (int v) {return (string.Join ("", v.ToString (). Select ((char n) => "kein dreifacher Quad-Pent-Hex-Sept-Okt-En" .Split () [n -'0 '])) + "ium"). Replace ("nnn", "nn"). Replace ("ii", "i") + "+ string.Join (" ", v.ToString () .Select ((char n) => "nubtqphsoe" [n-'0 '])); }

    static private string ToText(int  v)
    {
        string u,r="",t="";
        return v.ToString().Select((char n)=>{u="nil un bi tri quad pent hex sept oct enn".Split()[n-48];r+=u;t+=u[0];return r;}).Last()+"ium".Replace("nnn","nn").Replace("ii","i")+" "+t;
    }

Dieser Ansatz nimmt das int, konvertiert es in einen String und führt dann eine LINQ-Auswahl von Zeichen durch, die ein Lambda auslösen.

Das Lambda generiert ein Array im laufenden Betrieb (weniger Zeichen als definiert), indem die Zeichenfolge der Präfixe aufgeteilt wird. Anschließend wird der Index des zu verwendenden Präfixes ermittelt, indem der int-Wert des aktuellen Zeichens (der oben erwähnte Trick n-'0 ') betrachtet wird.

Alles, was in einen String eingeschlossen ist. Join, der alle LINQ-Ergebnisse zusammenfasst. Tack on the "ium", dann ein paar .Replace-Anweisungen am Ende, um die nnn 'und ii's zu bereinigen.

Fehlende Symbolausgabe hinzugefügt. Ich denke, es gibt eine effizientere Möglichkeit, die beiden LINQs zusammenzuführen, aber es ist viel zu spät, um weiter daran zu arbeiten.

C 210 204 unennennium (199) Bytes

Dies erfordert ASCII als Laufzeitzeichensatz.

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

Ich habe versucht, eine rekursive Lösung (die die Notwendigkeit von pund vermeidet o), aber das stellte sich länger heraus.

Ich bin besonders Stolz / schämt der Matcher für den regulären Ausdruck 90|[23]$, der auf beruht 9und 0wobei die am weitesten Ziffern getrennt sind (und daher das einzige Paar , das von 9 unterscheiden - die 39in dem Code ist eine Folge der jein ganzzahliger Wert ist , und *nimmer noch ein ASCII Zeichen) und das 2und 3unterscheiden sich nur im letzten Bit, so dass die Division durch 2 sie verschmilzt.

Erweiterter Code:

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

Testgeschirr:

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

Nicht die beste ... aber ich lerne immer noch R, also dachte ich, ich würde meinen Versuch posten. Irgendwelche Vorschläge, um es besser zu machen? Nun, da ich darüber nachdenke, ist es wahrscheinlich möglich, die n-1-Zeile zu unterteilen, anstatt Platz für die Erstellung von Zeilennamen zu verschwenden.

Anwendungsbeispiel

> 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. Erstellen Sie einen Schlüssel, konvertieren Sie ihn in einen Datenrahmen und legen Sie ihn als Variable fest k
2. Stellen Sie die Zeilennamen wie 0-9zur einfachen Identifizierung ein
3. Eingaben übernehmen x, in Zeichen konvertieren, aufteilen (zB 137 auf "1" "3" "7")
4. Teilmenge kbasierend auf der eingegebenen Teilzahl und Rückgabe der Einträge
5. Verketten Sie sie und fügen Sie hinzu -ium
6. Teilmenge kmit Teilzeichenfolge, um den ersten Buchstaben der Übereinstimmungen abzurufen. Dies wird mit einem Leerzeichen dazwischen mit der Ausgabe von Schritt 5 verkettet
7. Verwenden Sie sub(), um die Muster nnnund zu ersetzenii

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

Seltsamerweise waren meine Versuche, map zu verwenden, länger als die for-Schleife.

EDIT: Hoppla, ich habe vergessen, das Datum zu überprüfen.

PHP, 131 + 1 Byte (untriunium)

immer noch furchtbar lang:

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

Laufen Sie als Pipe mit -nRoder versuchen Sie es 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')))