IUPAC dalam kebijaksanaannya yang tak tertahankan telah menciptakan nama elemen sistematis untuk setiap elemen yang baru dibuat. Ini adalah nama sementara elemen hingga mereka akhirnya memutuskan tentang nama sebenarnya. Ini berfungsi seperti itu: setiap digit nomor elemen diberi awalan berdasarkan nilainya. Awalan disatukan dengan 'ium' di bagian akhir. Ketika ini selesai dan jika Anda mendapatkan dua kali lipat i (ii) atau triple n (nnn), gantilah dengan i tunggal dan n ganda. Simbol untuk elemen adalah huruf pertama dari setiap awalan yang digunakan digabungkan dan hasilnya dikapitalisasi. Awalan yang digunakan di bawah ini.

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

Jadi untuk golf ini, kode Anda perlu menghasilkan nama elemen dan simbolnya untuk bilangan bulat positif yang diberikan. Jadi, jika kode Anda diberikan 137, harus mencetak ke stdout atau mengembalikan keduanya untriseptiumdan Uts. Itu harus valid dari setidaknya 118 hingga 558 . Yang lebih tinggi valid jika tidak menambah panjang kode Anda.

Contoh Python menunjukkan metode:

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 menang dengan byte kadmium!

Mathematica 10.1, indium (49) cadmium (48)

Solusi ini menggunakan pustaka bawaan elemen properti, termasuk nama dan singkatan IUPAC. (Saya belum melihat ini sebagai teknik yang harus dihindari dalam Golf. Tampaknya didorong. Tapi ini mungkin (mungkin lebih) tepi diterima - Mathematica mengimplementasikan perpustakaan ini (dan banyak lainnya) dengan mengunduh data dari Server Wolfram pertama kali Anda menggunakannya (dan saya kira sesekali memeriksa pembaruan).)

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

Bagaimana ini dibandingkan dengan menggunakan elements.py atau periodictable.py di Python?

Sunting: Berbulan-bulan kemudian: Melihat saya telah mengetikkan singkatan keluaran untuk 122. Saya telah menjalankan kembali kode dan memverifikasi bahwa saya membuat kesalahan ini, bukan Mathematica.

Python 3, Unhexseptium (167) byte

h=x='';r=str.replace
for i in input():s=r('nubtqphsoeinirueeecnl  ianxptn    dt t'[int(i)::10],' ','');h+=s;x+=s[0]
print(r(r(h+'ium\n','ii','i'),'nnn','nn')+x.title())

Ini adalah hasil ketika program dijalankan pada setiap angka dari 1 hingga 999 (inklusif)

Pip , Thorium Actinium Radon (86)

^{(Jangan menghirup entri ini, itu akan memberi Anda kanker paru-paru.)}

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

Mengambil nomor elemen sebagai argumen baris perintah dan menampilkan nama & singkatan pada baris terpisah.

Penjelasan (agak tidak ungolfed):

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

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

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

The iidan nnnpenanganan penggunaan pengganti regex dengan fungsi callback (ditambahkan dalam versi terbaru dari Pip): untuk setiap pertandingan ii|nnn, mengambil semua tapi karakter pertama dan digunakan sebagai pengganti.

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

Saya berasumsi tidak masalah bagaimana urutan nama dan simbol dikembalikan. Di sini, simbol yang lebih dulu:

$ seq 180 190 | sed -f iupac.sed 
Uon unoctnilium
Uou unoctunium
Uob unoctbium
Uot unocttrium
Uoq unoctquadium
Uop unoctpentium
Uoh unocthexium
Uos unoctseptium
Uoo unoctoctium
Uoe unoctennium
Uen unennilium
$ 

Mathematica, unhexunium 163 161 byte

sekarang menggunakan huruf besar simbol

Ini adalah Mathematica tanpa built-in ElementData.

f=StringReplace[##<>"ium, "<>{ToUpperCase@#1,##2}~StringTake~1&@@ToString/@nil[un,bi,tri,quad,pent,hex,sept,oct,enn][[IntegerDigits@#]],{"ii"->"i","nnn"->"nn"}]&

Tes pada 10 angka acak:

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

Kapitalisasi adalah bagian yang sulit. (Uji dalam FireFox)

Edit 3 byte disimpan 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) byte

o=u='';gets.bytes{|c|k=%w[Nil un bI trI quad pent hex sept oct enN Ium][c%48];o+=k;u+=k[0]};puts o.tr_s('IN','in'),u[0..-2].capitalize

Saya berharap untuk bermain golf dengan cara ini

Sunting: Terima kasih untuk @steveverrill karena telah memangkas 9 byte!

Sunting2: Terima kasih untuk @steveverrill lagi untuk 4 byte lagi! (Solusi yang sangat pintar!)

Pyth, 67 byte (Holmium)

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

Cobalah online di Pyth Compiler / Executor .

Bagaimana itu bekerja

            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)

Minus octium (8) byte, terima kasih kepada @ 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``

Masukan seperti f(324). Ugh, aku merasa sangat golf-y.

CJam, 74 72 71 70 69 byte (Thulium)

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

Perhatikan bahwa kode tersebut mengandung karakter yang tidak dapat dicetak.

Terima kasih kepada @ Sp3000 karena menunjukkan kesalahan dalam revisi awal saya dan menyarankan )/pendekatannya.

Cobalah secara online di interpreter CJam: .

Bagaimana itu bekerja

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)

Bekerja pada semua input yang dapat Anda gunakan, mulai dari niliumhingga, sejauh yang Anda inginkan. Saya harus ennennennennennennennennennennennennennennennennennennennennennenniumsebelum saya menyerah dengan menekan tombol 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]);

Dan sebuah penjelasan:

%Create a 2D array of the prefixes transposed
l=['nubtqphsoe';'inirueeecn';'l  ianxptn';'    dt t  '];
%Grab the input number
i=input('','s')     %Request the input and convert to string
               -47; %Convert from ASCII into an array of indecies (1 indexed)
%Generate the short form
s=l(1,i);
%Capitalise first letter in short form
s(1)=s(1)-32;
%Extract required prefixes for long form
a=l(:,i);
%Now the fun bit:
                     a(a>32)'                                    %Combine the prefixes removing spaces and transpose into a string
                    [         'ium ']                            %Append 'ium ' to the string (the space is to separate the short form)
             strrep(                 ,'nnn','nn')                %Replace 'nnn' with 'nn'
      strrep(                                    ,'ii','i')      %Replace 'ii' with 'i'
disp([                                                     s]); %And display both full and short form strings together

TI-BASIC, 223 218 byte

Input N
"nil un  bi  tri quadpenthex septoct enn→Str4
"int(10fPart(N/10^(X→Y₁
"sub(Str4,1+4Y₁,int(3fPart(e^(Y₁)1.5154)+2^not(X=2 and .9=fPart(N%) or X=1 and 1=int(5fPart(.1N→Y₂
"ium,"+sub("UBTQP",int(N%),1
For(X,1,3
Y₂+Ans+sub(Y₂(3-X),1,1
End
sub(Ans,1,length(Ans)-1

Elemen nomor N hanya dapat memiliki tiga "n" jika berakhir dengan 90, dan hanya dapat memiliki dua "i" jika digit terakhir adalah 2 atau 3. Kami menggunakan matematika untuk memeriksa kasus-kasus tersebut.

Angka ajaib 1.5154, yang menyimpan panjang setiap awalan, ditemukan menggunakan script Python untuk mencari semua desimal panjang ≤7 menggunakan fungsi cosh(, cos(dan e^(.

Belum bermain golf, tetapi huruf kecil dua byte TI-BASIC dan kurangnya perintah manipulasi string, seperti biasa, akan merusak nilai program ini.

Python 3, unpentadium ( 156 155 154) byte

n=e=""
for c in input():s="nil un bi tri quad pent hex sept oct enn".split()[int(c)];n+=s[c<"1"<"nn"==n[-2:]:];e+=s[0]
print(n.strip("i")+"ium",e.title())

Alih-alih mengganti iidengan ikita rstrip apapun isebelum kita memperbaiki ium, karena itu satu-satunya sumber double is yang mungkin. Demikian pula, kami menghapus ndengan memeriksa suatu enn/nilkasus.

Retina, 206 196 186 179 (Unseptenium) byte ( Cobalah online )

Terima kasih kepada @ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ) karena mengajari saya bahasa ini.

Terima kasih kepada @FryAmTheEggman untuk memotong 7 byte.

T`d`nubtq\p\hs\oe
.+
$&, $&
(?<=,.*n)
il
(?<=,.*e)n?
nn
(?<=,.*u)
n
(?<=,.*b)
i
(?<=,.*t)
ri
(?<=,.*q)
uad
(?<=,.*p)
ent
(?<=,.*h)
ex
(?<=,.*s)
ept
(?<=,.*o)
ct
r`i?$
ium
T`l`L`^.

Versi byte-byte: di sini

Versi byte-byte: di sini

CJam, 95 byte

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

Cobalah online

Ini bersaing dalam kategori "bahasa tanpa regex, dan hanya menggunakan karakter yang dapat dicetak." ;) Tidak benar-benar mengharapkannya sesingkat beberapa solusi yang sudah diposting, tapi saya penasaran berapa lama akhirnya akan berakhir. Dan karena saya mendapatkannya sekarang, saya mungkin juga mempostingnya.

Penjelasan:

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

Membaca tiga karakter dari STDIN, lebih banyak diabaikan, kurang menghasilkan crash. Jadi itu berfungsi untuk setiap angka antara unnilniliumdan 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]})

Cukup mudah dan tidak ada kejutan di sini. Kecuali mungkin saya memecahkan masalah kapitalisasi dengan casing yang lebih rendah semuanya kecuali bagian pertama dan memiliki bagian-bagian individu sudah dalam judul-kasus. Agresif diuraikan sekarang untuk menghindari kehilangan karakter untuk tugas variabel telanjang.

Bonus setelah perubahan terakhir: Sekarang berfungsi untuk nomor elemen yang lebih lama juga:

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

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

Membaca angka dari stdindan mencetak hasilnya stdout. Mengandalkan sizeof(char*) == sizeof(int).

Versi tidak disatukan:

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

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

Dicukur 34 byte, terima kasih kepada 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

Saya menghasilkan simbol terlebih dahulu, kemudian menyimpannya di ruang pegang dan membuat nama. Sebuah loop lebih golf daripada menggunakan /guntuk empat atau lebih penggantian (kita hanya dapat memiliki satu iidan / atau satu nnn, sehingga mereka tidak perlu berada di dalam loop, tetapi tidak sakit). Akhirnya, ambil dan tambahkan simbol yang ditahan.

(NB Saya belum melihat jawaban sed yang ada ketika saya menulis ini)

Uji kasus

Ini menerapkan iidan nnnaturan khusus:

$ 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

Dan yang konyol, menunjukkan berapa banyak yang diberikan kode ini, dibandingkan dengan dunia fisik:

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

T-SQL 329 byte

creat proc x(@a char(3))as select replace(replace((select a.b as[text()]from(select left(@a,1)a union select substring(@a,2,1)union select right(@a,1))z join(values(0,'nil'),(1,'un'),(2,'bi'),(3,'tri'),(4,'quad'),(5,'pent'),(6,'hex'),(7,'sept'),(8,'oct'),(9,'enn'))a(a,b)on z.a=a.a for xml path(''))+'ium','ii','i'),'nnn','nn')

Diformat:

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

Yah, setidaknya PHP berada di sekitar rata-rata saat ini.

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

Menjalankan formulir perintah seperti:

pentium.php 163

Keluaran:

unhextrium Uht

Tidak disatukan

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

Sunting

• menghemat 10 byte dengan mengganti semua (tidak hanya satu, duh ) array()-initializer dengan[]
• menghemat 1 byte dengan menambahkan spasi putih dan 'ium 'bukannya menggunakan gabungan tambahan.' '.

Perl, 109 (Unnilennium) byte

108 kode + 1 sakelar

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'

Mengambil input dari STDIN sebagai satu nomor per baris.

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

Trik "n-'0 '" adalah cara untuk mengkonversi dari ascii ke int. Char 9 = ASCII 57. Char 0 = ASCII 48, jadi 57-48 = 9.

static private string ToText (int v) {return (string.Join ("", v.ToString (). Pilih ((char n) => "nil un bi tri quad hex pent sept ok enn" .Split () [n -'0 '])) + "ium"). Ganti ("nnn", "nn"). Ganti ("ii", "i") + "" + string.Join ("", v.ToString () .Pilih ((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;
    }

Pendekatan ini mengambil int, mengkonversi ke string, kemudian melakukan pemilihan karakter LINQ yang melepaskan lambda.

Lambda menghasilkan array dengan cepat (lebih sedikit karakter daripada mendefinisikannya) dengan memisahkan string awalan. Itu kemudian menarik indeks awalan untuk digunakan dengan melihat nilai int karakter saat ini (trik n-'0 'yang disebutkan di atas).

Semua yang dibungkus dalam string. Bergabunglah yang menggabungkan semua hasil LINQ bersama-sama. Tack pada "ium", kemudian beberapa. Ganti pernyataan di akhir untuk membersihkan nnn 'dan ii's.

Menambahkan output simbol yang hilang. Saya pikir ada cara yang lebih efisien dengan menggabungkan dua LINQ, tapi ini cara terlambat untuk terus menyodoknya.

C, 210 204 unennenium (199) byte

Ini membutuhkan ASCII sebagai set karakter runtime.

f(char*n,char*s){char*c="NilUnBiTriQuadPentHexSeptOctEnn",*p,*o=n,i,j;for(;*n;){for(j=i=*n-48,p=c;*p&32||i--;++p);for(*s++=*n=*p+32;*++p&32;)*s++=*p;s-=*n++-j==39||j/2-*n==1;}*o-=32;strcpy(s,"ium");}

Saya memang mencoba solusi rekursif (yang menghindari kebutuhan untuk pdan o) tetapi ternyata lebih lama.

Saya sangat bangga / malu dengan korek api untuk regexp 90|[23]$, yang mengandalkan 9dan 0menjadi digit terpisah terjauh (dan oleh karena itu satu-satunya pasangan yang berbeda dengan 9 - 39dalam kode adalah konsekuensi dari jmenjadi nilai integer dan *nmasih ASCII karakter) dan itu 2dan 3hanya berbeda pada bit terakhir, jadi bagi dengan 2 konfigurasikan.

Kode yang diperluas:

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

Uji harness:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
    char buf[1024];
    while (*++argv) {
        f(*argv, buf);
        printf("%s %s\n", *argv, buf);
    }
    return EXIT_SUCCESS;
}

R, 278 byte

g<-function(x){k<-data.frame(c("nil","un","bi","tri","quad","pent","hex","sept","oct","enn"));row.names(k)<-0:9;n<-unlist(strsplit(as.character(x),""));return(sub("nnn","nn",sub("ii","i",paste(c(as.vector(k[n,]),"ium"," ",sapply(k[n,],function(x)substr(x,1,1))),collapse=""))))}

Bukan yang terbaik ... tapi saya masih belajar R jadi saya pikir saya akan memposting upaya saya. Ada saran untuk membuatnya lebih baik? Sekarang saya berpikir tentang hal itu mungkin untuk subset pada baris ke-1 daripada membuang-buang ruang untuk menciptakan nama-nama baris.

Contoh penggunaan

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

Tidak disatukan

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. Buat kunci, konversikan ke bingkai data, dan tetapkan sebagai variabel k
2. Tetapkan nama baris 0-9untuk memudahkan identifikasi
3. Ambil input x, konversikan ke karakter, pisahkan (mis. 137 ke "1" "3" "7")
4. Subset kberdasarkan input angka split dan mengembalikan entri
5. Gabungkan keduanya bersama-sama dan tambahkan -ium
6. Juga subset kmenggunakan substring untuk menarik huruf pertama dari pertandingan. Ini digabungkan dengan output dari langkah 5 dengan ruang kosong di antara mereka
7. Gunakan sub()untuk mengganti nnndan iipola

Javascript - 169 byte

n=>eval(`q='nil0un0bi0tri0quad0pent0hex0sept0oct0enn'.split(0);for(b of (_=$='')+n){c=q[b];$+=q[b];_+=(_?c:c.toUpperCase())[0]}$.replace(/i$()|n(nn)/g,'$1$2')+'ium '+_`)

Anehnya, upaya saya untuk menggunakan peta lebih lama dari pada for loop.

Sunting: Ups, lupa memeriksa tanggal.

PHP, 131 +1 byte (untriunium)

masih sangat panjang:

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

Jalankan sebagai pipa dengan -nRatau coba online .

Python, 154 byte

import re
n=input('')
for c in n:
 print(re.sub('ii','i',re.sub('nnn','nn',['nil','un','bi','tri','quad','pent','hex','sept','oct','enn'][int(c)]+'ium')))