ИЮПАК в своей невыносимой мудрости создал систематическое название элемента для любого вновь созданного элемента. Это временное имя элемента, пока они, наконец, не примут решение о действительном имени. Это работает так: каждой цифре номера элемента присваивается префикс в зависимости от его значения. Префиксы объединяются с '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, он должен вывести на стандартный вывод или вернуть оба 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. (Я не рассматривал это как технику, которую следует избегать в Гольфе. Кажется, это поощряется. Но это может быть (возможно, более) приемлемым - 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 или periodtable.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 байт

теперь заглавные буквы

Это Mathematica без встроенного 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 (негексквадиум) 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>

Рубин - 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 байта! (Действительно умное решение!)

Pyth, 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 байта ( Biunnilium Binilbium)

Минус октия (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 байт (тулия)

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

Matlab, 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мы запускаем любые is перед тем ium, как связать их , так как это единственный возможный источник двойных is. Точно так же мы удаляем ns, проверяя enn/nilслучай.

Retina, 206 196 186 179 (Unseptennium) байт ( Попробуйте онлайн )

Спасибо @ 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-байтовая версия: здесь

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.

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

Хаскелл, бипентбий ( 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 байта благодаря Ними.

GNU sed, unhexunium (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, поэтому они не должны быть внутри цикла, но это не повредит). Наконец, найдите и добавьте удерживаемый символ.

(Примечание: я не видел существующего ответа 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

T-SQL 329 байт

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

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

редактировать

• сэкономил 10 байт, заменив все (не только один, duh ) array()-инициализатор на[]
• сэкономил 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 216 байт

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

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

статическая приватная строка ToText (int v) {return (string.Join ("", v.ToString (). Select ((char n) => "nil un bi tri quad pent hex sect oct enn" .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;
    }

Этот подход принимает int, преобразует в строку, затем выполняет выбор символов LINQ, который запускает лямбду.

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

Все, что заключено в строку. Соединение, которое объединяет все результаты LINQ вместе. Нажмите на «ium», а затем на несколько операторов .Replace в конце, чтобы очистить nnn 'и ii's.

Добавлен недостающий вывод символов. Я думаю, что есть более эффективный способ слияния двух LINQ, но слишком поздно, чтобы продолжать в этом ковыряться.

C 210 204 unennennium (199) bytes

Это требует 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"

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. Создать ключ, преобразовать в фрейм данных и установить в качестве переменной 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.

РЕДАКТИРОВАТЬ: Ой, забыл проверить дату.

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или попробуйте онлайн .

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