IUPAC w swojej nieznośnej mądrości stworzyli systematyczną nazwę elementu dla każdego nowo utworzonego elementu. Jest to tymczasowa nazwa elementu, dopóki w końcu nie zdecydują się na prawdziwą nazwę. Działa to tak: każda cyfra numeru elementu ma przypisany prefiks na podstawie jego wartości. Prefiksy są łączone z „ium” na końcu. Kiedy to zrobisz i jeśli otrzymasz podwójne i's (ii) lub potrójne n's (nnn), zamień je na pojedyncze i's i podwójne n's. Symbolem elementu jest pierwsza litera każdego użytego prefiksu połączonego i skapitalizowanego wyniku. Użyte prefiksy znajdują się poniżej.

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

Więc dla tego golfa twój kod musi wygenerować zarówno nazwę elementu, jak i jego symbol dla danej dodatniej liczby całkowitej. Więc jeśli twój kod otrzymał 137, powinien wypisać na standardowe wyjście lub zwrócić oba untriseptiumi Uts. Powinien być ważny od co najmniej 118 do 558 . Każda wyższa jest poprawna, jeśli nie zwiększa długości kodu.

Przykład Pythona przedstawiający metodę:

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 wygrywa bajtami kadmu!

Mathematica 10.1, ind (49) kadm (48)

To rozwiązanie wykorzystuje wbudowaną bibliotekę właściwości elementów, w tym nazw i skrótów IUPAC. (Nie widziałem tej techniki, której należy unikać w golfie. Wydaje się to być zachęcane. Ale może to być (być może ponad) akceptowalne - Mathematica implementuje tę bibliotekę (i wiele innych), pobierając dane z Serwery Wolfram przy pierwszym użyciu (i przypuszczam, że czasami sprawdzam aktualizacje).)

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

Jak by to wyglądało w porównaniu do używania elements.py lub periodictable.py w Pythonie?

Edycja: Kilka miesięcy później: Zauważyłem, że napisałem na maszynie kod wyjściowy 122. Ponownie uruchomiłem kod i sprawdziłem, że popełniłem ten błąd, a nie Mathematica.

Python 3, Unhexseptium (167) bajtów

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

Są to wyniki, gdy program działa na każdej liczbie od 1 do 999 (włącznie)

Pip , Thorium Actinium Radon (86)

^{(Nie wdychaj tego wpisu, bo dostaniesz raka płuc.)}

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

Pobiera numer elementu jako argument wiersza polecenia i wyświetla nazwę i skrót w osobnych wierszach.

Objaśnienie (nieco nie golfa):

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)

iiI nnnobsługi używa regex zastąpienie funkcji wywołania zwrotnego (dodana w najnowszej wersji PIP): dla każdego meczu ii|nnn, podejmie wszelkie ale pierwszy znak i używać jako zamiennik.

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

Zakładam, że nie ma znaczenia, w jakiej kolejności zwracane są nazwa i symbol. Tutaj symbol jest pierwszy:

$ 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 bajtów

teraz wielkie litery symbol

To jest Mathematica bez wbudowanego 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 na 10 liczbach losowych:

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

Wielkie litery to trudna część. (Test w FireFox)

Edytuj 3 bajty zapisane przez użytkownika 2786485

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>

Rubin - 163 156 147 143 134 134 (Untriquadium) bajtów

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

Mam nadzieję zagrać w golfa w ten sposób

Edycja: Dzięki za @steveverrill za stratę 9 bajtów!

Edit2: Jeszcze raz dziękuję za @steveverrill za kolejne 4 bajty! (Naprawdę sprytne rozwiązanie!)

Pyth, 67 bajtów (Holmium)

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

Wypróbuj online w Pyth Compiler / Executor .

Jak to działa

            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 bajtów ( Biunnilium Binilbium)

Minus octium (8) bajtów, dzięki @ edc65!

130 159 147 bajtów (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``

Dane wejściowe jak f(324). Ugh, czułem się bardzo golfowo.

CJam, 74 72 71 70 70 69 bajtów (Thulium)

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

Pamiętaj, że kod zawiera znaki niedrukowalne.

Dzięki @ Sp3000 za wskazanie błędu w mojej początkowej wersji i zasugerowanie )/podejścia.

Spróbuj go online w tłumacza CJam: .

Jak to działa

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)

Działa na wszystkich wejściach, które możesz na niego rzucić, od, niliumaż do tak daleko, jak chcesz. Udało mi się, ennennennennennennennennennennennennennennennennennennennennennenniumzanim zrezygnowałem z naciskania klawisza 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]);

I wyjaśnienie:

%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 bajtów

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 o numerze N może mieć potrójne „n”, jeśli kończy się na 90, a może mieć podwójne „i”, jeśli ostatnia cyfra to 2 lub 3. Używamy matematyki do sprawdzania tych przypadków.

Magiczna liczba 1.5154, która przechowuje długość każdego prefiksu, został znaleziony przy użyciu skryptu Python przeszukać wszystkie dziesiętne długości ≤7 używając funkcji cosh(, cos(oraz e^(.

Nie skończyłem jeszcze gry w golfa, ale dwubajtowe małe litery TI-BASIC i brak poleceń manipulacji ciągami, jak zwykle, zaszkodzą wynikowi tego programu.

Python 3, unpentquadium ( 156 155 154) bajtów

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

Zamiast wymieniać iiz imy rstrip żadnych is zanim przyczepność na ium, ponieważ jest to możliwe jedynie źródłem podwójnych is. Podobnie usuwamy ns, sprawdzając enn/nilprzypadek.

Retina, 206 196 186 179 (Unseptennium) bajtów ( Wypróbuj online )

Dzięki @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ) za nauczenie mnie tego języka.

Dzięki @FryAmTheEggman za odcięcie 7 bajtów.

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

Wersja bajtowa: tutaj

Wersja B-bajtowa: tutaj

CJam, 95 bajtów

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

Wypróbuj online

To konkuruje w kategorii „języki bez wyrażeń regularnych i tylko przy użyciu znaków do wydrukowania”. ;) Tak naprawdę nie spodziewałam się, że będzie on tak krótki jak niektóre z już opublikowanych rozwiązań, ale byłem ciekawy, jak długo by to się skończyło. A skoro mam go teraz, równie dobrze mogę go opublikować.

Wyjaśnienie:

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.

Idź, 322 bajtów (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)}

Odczytuje trzy znaki ze STDIN, więcej jest ignorowanych, mniej powoduje awarię. Działa to dla każdej liczby między unnilniliumi 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]})

Dość proste i bez niespodzianek. Może z wyjątkiem tego, że rozwiązałem problem wielkich liter, odsuwając na bok wszystko oprócz pierwszej części i mając poszczególne części już w tytule. Agresywnie nakreślone do tej pory, aby uniknąć utraty znaków dla przypisań do zmiennej.

Premia po ostatniej zmianie: teraz działa również na dłuższe liczby elementów:

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

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

Odczytuje cyfry stdini drukuje wyniki stdout. Polega na sizeof(char*) == sizeof(int).

Wersja bez golfa:

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 bajtów)

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

Ogolono 34 bajty dzięki nim.

GNU sed, unhexunium (161 bajtów)

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

Najpierw generuję symbol, a następnie chowam go do miejsca i tworzę nazwę. Pętla jest bardziej golfowa niż używanie /gczterech lub więcej zamienników (możemy mieć tylko jeden iii / lub jeden nnn, więc nie muszą znajdować się w pętli, ale to nie boli). Na koniec pobierz i dołącz trzymany symbol.

(Uwaga: nie widziałem istniejącej odpowiedzi sed, kiedy to napisałem)

Przypadki testowe

Wykonują one iii nnnspecjalne zasady:

$ 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

I niedorzeczny, pokazujący o ile więcej ten kod daje w porównaniu ze światem fizycznym:

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

T-SQL 329 bajtów

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

Sformatowany:

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 bajty, niepentbium

Tym razem przynajmniej PHP jest gdzieś średnio.

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

Działa z wiersza polecenia, takiego jak:

pentium.php 163

Wynik:

unhextrium Uht

Bez golfa

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

Edytować

• zaoszczędził 10 bajtów, zastępując cały (nie tylko jeden, duh ) array()-inicjalizator[]
• zaoszczędzono 1 bajt, dodając białe znaki oraz 'ium 'zamiast tego stosując dodatkową konkatenację.' '.

Perl, 109 (Unnilennium) bajtów

Kod 108 + 1 przełącznik

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'

Pobiera dane wejściowe ze STDIN jako jedną liczbę w wierszu.

Java 8 216 bajtów

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 bajtów unennoctium

Sztuczka „n-'0” jest sposobem na konwersję z ascii na int. Char 9 = ASCII 57. Char 0 = ASCII 48, więc 57-48 = 9.

statyczny prywatny ciąg ToText (int v) {return (string.Join ("", v.ToString (). Wybierz ((char n) => "zero bic quad pent hex hex sept oct enn" .Split () [n -'0 '])) + „ium”). Zamień („nnn”, „nn”). Zamień („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;
    }

To podejście przyjmuje int, konwertuje na ciąg, a następnie wykonuje LINQ wybór znaków, które odpalają lambda.

Lambda generuje tablicę w locie (mniej znaków niż ją definiuje), dzieląc ciąg prefiksów. Następnie pobiera indeks prefiksu do użycia, patrząc na wartość int bieżącego znaku (sztuczka n-0 wspomniana powyżej).

Wszystko to jest zawinięte w ciąg. Połącz, który łączy wszystkie wyniki LINQ razem. Tack na „ium”, a następnie kilka .Replace na końcu, aby oczyścić nnn i ii.

Dodano brakujące wyjście symbolu. Myślę, że istnieje bardziej skuteczny sposób, łącząc dwa LINQ, ale jest już za późno, aby się na niego szturchać.

C, 210 204 unennennium (199) bajtów

Wymaga to ASCII jako zestawu znaków środowiska wykonawczego.

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

Wypróbowałem rozwiązanie rekurencyjne (które pozwala uniknąć potrzeby pi o), ale okazało się, że było dłużej.

Jestem szczególnie dumny / wstydzić dopasowującego do regexp 90|[23]$, która opiera się 9i 0jest najdalej oddzielone cyfry (a więc tylko parę, które różnią się od 9 - 39w kodzie jest konsekwencją jjest liczbą całkowitą i *nnadal ASCII charakter) i to 2i 3różnią się tylko ostatnim bitem, więc dzielenie przez 2 łączy je.

Rozszerzony kod:

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

Uprząż testowa:

#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 bajtów

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

Nie najlepsze ... ale wciąż uczę się R, więc pomyślałem, że opublikuję moją próbę. Jakieś sugestie, żeby to poprawić? Teraz, gdy o tym myślę, prawdopodobnie możliwe jest podzbiór wiersza n-1 zamiast marnowania miejsca na tworzenie nazw wierszy.

Przykładowe użycie

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

Bez golfa

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. Utwórz klucz, przekonwertuj na ramkę danych i ustaw jako zmienną k
2. Ustaw nazwy wierszy, 0-9aby ułatwić ich identyfikację
3. Weź dane wejściowe x, przekonwertuj na znak, podziel je (np. 137 na „1” „3” „7”)
4. Podzbiór koparty na wprowadzonym numerze podzielonym i zwraca wpisy
5. Połącz je razem i dodaj -ium
6. Podzbiór również kza pomocą podciągów, aby wyciągnąć pierwszą literę dopasowań. Jest to konkatenowane z wynikiem z kroku 5 z pustą przestrzenią między nimi
7. Służy sub()do zastępowania wzorów nnniii

JavaScript - 169 bajtów

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

Dziwnie, moje próby użycia mapy były dłuższe niż pętla for.

EDYCJA: Ups, zapomniałem sprawdzić datę.

PHP, 131 + 1 bajtów (untriunium)

wciąż okropnie długo:

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

Uruchom jako potok z -nRlub spróbuj online .

Python, 154 bajty

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