IUPAC своєю непереборною мудрістю створив систематичну назву елемента для будь-якого новоствореного елемента. Це тимчасова назва елемента, поки вони нарешті не складуть свою думку про власне ім’я. Це працює так: кожній цифрі номера елемента присвоюється префікс виходячи з його значення. Префікси з'єднуються з 'ium' в кінці. Коли це зроблено і якщо ви отримаєте подвійні i (ii) або потрійні n (nnn), замініть їх на одиничні i і подвійні n. Символ для елемента є першою літерою кожного використаного префікса, об'єднаного і з великої літери. Нижче використовуються префікси.

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

Отже, для цього гольфу ваш код повинен генерувати як ім’я елемента, так і його символ для заданого натурального числа. Отже, якщо вашому коду було надано 137, він повинен надрукувати для stdout або повернути обидва untriseptiumі Uts. Він повинен бути дійсним щонайменше від 118 до 558 . Будь-яка вища версія дійсна, якщо вона не збільшує довжину вашого коду.

Приклад Python, що показує метод:

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

Ерік Тауерс виграє кадмиєві байти!

Mathematica 10.1, кадмій індію (49) (48)

Це рішення використовує вбудовану бібліотеку властивостей елементів, включаючи імена та абревіатури IUPAC. (Я не розглядав це як техніку, яку слід уникати в Golf. Це, мабуть, заохочується. Але це може бути на (можливо, над) межі прийнятного - Mathematica реалізує цю бібліотеку (та багато інших), завантажуючи дані з Сервери Wolfram при першому його використанні (і я припускаю, що час від часу перевіряє оновлення).)

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

Як би це порівняти з використанням elements.py або periodictable.py в Python?

Редагувати: Через місяці: Помітив, що я набрав абревіатуру для виходу 122. Я повторно запустив код і переконався, що я допустив цю помилку, а не Mathematica.

Python 3, Unhexseptium (167) байт

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

Це результати, коли програма працює на кожному номері від 1 до 999 (включно)

Піп , Торій Актіній Радон (86)

^{(Не вдихайте цей запис, це дасть вам рак легенів.)}

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

Приймає номер елемента як аргумент командного рядка та виводить ім’я та абревіатуру в окремі рядки.

Пояснення (дещо неозорене):

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)

iiІ nnnобробки використовує регулярний вираз заміни з функцією зворотного виклику (додана в останній версії Піп): для кожного матчу ii|nnn, вжити всіх , крім першого персонажа і використовувати в якості заміни.

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

Я припускаю, що не має значення, в якому порядку повертаються ім'я та символ. Ось символ на першому місці:

$ 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 байт

тепер з великої літери символ

Це Математика без вбудованого 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"}]&

Тест на 10 випадкових чисел:

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

Капіталізація - складна частина. (Тест у FireFox)

Редагуйте 3 байти, збережені 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) байт

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

Я сподіваюсь гольфу таким чином вниз

Редагувати: Дякуємо @steveverrill за гоління 9 байт!

Edit2: Ще раз дякую за @steveverrill за ще 4 байти! (Дійсно розумне рішення!)

Піт, 67 байт (Голмій)

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

Спробуйте в Інтернеті у складі Pyth Compiler / Executor .

Як це працює

            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 байт ( Біунілій Бінільбій)

Мінус octium (8) байтів, завдяки @ edc65!

130 159 147 байт (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``

Вхід як f(324). Фу, я відчував себе так гольф-у.

CJam, 74 72 71 70 69 байт (Thulium)

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

Зауважте, що код містить недруковані символи.

Завдяки @ Sp3000 за вказівку на помилку в моїй початковій редакції та запропонування )/підходу.

Спробуйте онлайн в інтерпретатором CJam: .

Як це працює

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

Матлаб, 170 (Unseptnilium)

Працює на всіх входах, які ви можете кинути на нього, від niliumдо, а також наскільки ви хочете піти. Я дістався до того, ennennennennennennennennennennennennennennennennennennennennennenniumяк я здався натисканням клавіші 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]);

І пояснення:

%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 байт

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

Елемент N може мати потрійне "n", лише якщо він закінчується в 90, і може мати лише подвійне "i", якщо остання цифра дорівнює 2 або 3. Ми використовуємо математику для перевірки цих випадків.

Магічне число 1.5154, яке зберігає довжину кожного префікса, було знайдено з допомогою сценарію Python шукати все десяткові довжини ≤7 з допомогою функцій cosh(, cos(і e^(.

Ще не зробили гольф, але двобайтові літери TI-BASIC і відсутність команд для маніпуляцій з рядками, як завжди, зашкодять оцінці програми.

Python 3, unpentquadium ( 156 155 154) байт

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

Замість того, щоб замінювати iiна iми, ми rstrip будь-які is, перш ніж братися за ium, оскільки це єдине можливе джерело подвійних is. Аналогічно знімаємо ns, перевіряючи на enn/nilвипадок.

Retina, 206 196 186 179 (Unseptennium) bytes ( Спробуйте в Інтернеті )

Дякуємо @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ), який навчав мене цій мові.

Завдяки @FryAmTheEggman за рубання 7 байт.

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: тут

Bnh-байтова версія: тут

CJam, 95 байт

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

Спробуйте в Інтернеті

Це конкурує в категорії "мови без регулярного вираження та лише з використанням символів для друку". ;) Насправді не очікував, що він буде таким коротким, як деякі з вже розміщених рішень, але мені було цікаво, як довго це все-таки закінчиться. А оскільки я отримав це зараз, я міг би також розмістити його.

Пояснення:

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.

Перейти, 322 байт (трибібіум)

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

Читає три символи від STDIN, більше ігнорується, менше призводить до збоїв. Так воно працює для кожного числа між unnilniliumта 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]})

Тут досить просто і сюрпризів тут немає. За винятком того, що я вирішив питання про використання великої літери, опустивши все, крім першої частини, і окремі частини вже були в заголовку. На сьогоднішній день агресивно накреслено, щоб уникнути втрати символів для голих змінних завдань.

Бонус після останньої зміни: Тепер працює і для довших номерів елементів:

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

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

Читає цифри з stdinта друкує результати до stdout. Покладається на sizeof(char*) == sizeof(int).

Безгольова версія:

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 байт)

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 байти від Nimi.

GNU sed, негексуній (161 байт)

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

Спочатку генерую символ, а потім приховую його в простір і створюю ім'я. Цикл - це гольфіст, ніж використання /gдля чотирьох і більше замін (у нас може бути лише одна iiта / або одна nnn, тому їм не потрібно бути всередині циклу, але це не шкодить). Нарешті, дістаньте та додайте утримуваний символ.

(NB: Я не бачив існуючої відповіді sed, коли я писав це)

Тестові справи

Ці вправи в iiі 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

І смішно, показуючи, наскільки більше цього коду дає порівняно з фізичним світом:

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

329 байт T-SQL

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

Відформатовано:

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 байт, unpentbium

Ну, принаймні PHP цього разу десь близько середнього.

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

Запускає форму командного рядка, як:

pentium.php 163

Вихід:

unhextrium Uht

Безумовно

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

Редагувати

• збережено 10 байт, замінивши всі (не лише один, duh ) array()-initializer на[]
• збережено 1 байт, додавши пробіл разом із 'ium 'замість цього, використовуючи додатковий конкатенацію.' '.

Perl, 109 (Unnilennium) байт

108 код + 1 перемикач

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'

Вводить дані STDIN як одне число на рядок.

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 (Бібієніум) 198 байтів без урахування

Трюк "n-'0" "- це спосіб перетворення з ascii в int. Char 9 = ASCII 57. Char 0 = ASCII 48, тому 57-48 = 9.

статична приватна рядок ToText (int v) {return (string.Join ("", v.ToString (). Виберіть ((char n) => "nil un bi tri quad pent hex sept oct enn" .Split () [n -'0 '])) + "ium"). Замінити ("nnn", "nn"). Замінити ("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;
    }

Цей підхід бере int, перетворюється на рядок, після чого виконує LINQ вибір символів, що вистрілює лямбда.

Лямбда генерує масив на льоту (менше символів, ніж визначає його), розділяючи рядок префіксів. Потім він витягує індекс префікса для використання, переглядаючи значення поточного символу int (вказаний вище трюк n-'0 ').

Все, що загорнуте в string.Join, який об'єднує всі результати LINQ разом. Клацніть на "ium", потім пару. Замініть заяви в кінці, щоб очистити nnn 'і ii.

Додано відсутній вихідний символ. Я думаю, що є більш ефективний спосіб, об'єднавши два LINQ, але це спосіб пізно продовжувати тикати на це.

C, 210 204 нерінненіум (199) байт

Для цього потрібен ASCII як набір символів виконання.

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

Я спробував рекурсивне рішення (яке дозволяє уникнути потреби pта o), але це вийшло довше.

Я особливо пишаюся / соромлюсь відповідника за регулярний вираз 90|[23]$, на який покладається 9і 0є найбільш віддаленими цифрами (і, отже, єдина пара, яка відрізняється на 9 - 39в коді є наслідком того, jщо це ціле значення і *nвсе ще є ASCII символу) і те 2і 3відрізняються лише останнім бітом, тому ділення на 2 співвідносить їх.

Розширений код:

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

Тестовий джгут:

#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 байт

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

Не найкраще ... але я все ще навчаюсь R, тому я подумав, що опублікую свою спробу. Будь-які пропозиції, щоб зробити це краще? Тепер, коли я думаю про це, можливо, можливо, підмножитися на nth-1 ряд, а не витрачати простір, створюючи назви рядків.

Приклад використання

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

Безумовно

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. Створіть ключ, перетворіть у кадр даних та встановіть як змінну k
2. Встановіть назви рядків як 0-9для легкої ідентифікації
3. Візьміть вхід x, перетворіть на символ, розділіть його (наприклад, 137 на "1" "3" "7")
4. Підмножина kна основі введеного розділеного числа та повернення записів
5. Об’єднайте їх разом і додайте -ium
6. Також підмножина, kвикористовуючи підрядку для витягування першої літери збігів. Це з'єднується з результатом кроку 5 з порожнім пробілом між ними
7. Використовуйте sub()для заміни nnnта iiшаблонів

Javascript - 169 байт

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

Як не дивно, мої спроби використовувати карту були довші, ніж цикл for.

EDIT: На жаль, забув перевірити дату.

PHP, 131 + 1 байт (унтріум)

ще жахливо довго:

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

Запуск труби з -nRабо спробувати його в Інтернеті .

Пітон, 154 байти

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