IUPAC onların dayanılmaz bilgeliğinde, yeni yaratılmış herhangi bir eleman için sistematik bir eleman adı yarattı. Bu, bir elemanın nihayet gerçek bir isim hakkında karar verinceye kadar geçici adıdır. Öyle çalışır: Bir eleman numarasının her basamağına, değerine göre bir önek atanır. Önekler sonunda 'ium' ile birleştirilir. Bu yapıldığında ve i 'i (ii) ya da üçlü n' i (nnn) ikiye katlarsanız, bunları i 'i ve i n' i ile değiştirin. Öğenin simgesi, birleştirilmiş ve sonuç büyük harf kullanılan her önek ilk harfidir. Kullanılan önekler aşağıdadır.

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

Bu nedenle, bu golf için, kodunuzun verilen bir tamsayı için hem eleman adını hem de sembolünü oluşturması gerekir. Kodunuzu 137 verildiği takdirde Yani, stdout veya iade hem yazdırmalısınız untriseptiumve Uts. En az 118 ila 558 arasında geçerli olmalıdır . Kodunuzun uzunluğunu arttırmazsa daha yüksek olanları geçerlidir.

Yöntemi gösteren Python örneği:

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 kadmiyum bayt ile kazandı!

Mathematica 10.1, indiyum (49) kadmiyum (48)

Bu çözüm, IUPAC adları ve kısaltmaları içeren yerleşik bir element özellikleri kitaplığı kullanır. (Bunu Golf'te kaçınılması gereken bir teknik olarak görmemiştim. Teşvik edilmiş gibi görünüyor. Fakat bu kabul edilebilir bir sınırın üzerinde olabilir - Mathematica bu kütüphaneyi (ve diğerlerini) veri indirerek uygular. Wolfram sunucuları ilk kullanışınızda (ve zaman zaman güncellemeleri kontrol edeceğimi sanıyorum).)

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

Bu Python'da elements.py veya periodictable.py kullanmakla nasıl karşılaştırılır?

Düzenleme: Aylar sonra: 122 kısaltma çıktısını yazdığımı fark ettim. Kodu yeniden çalıştırdım ve bu hatayı Mathematica'da yaptığımı doğruladım.

Python 3, Unhexseptium (167) bayt

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

Bunlar, programın 1 ile 999 arası (dahil) her numarayla çalıştırıldığı sonuçlardır.

Pip , Toryum Aktinyum Radonu (86)

^{(Bu girişi solumayınız, size akciğer kanseri verecektir.)}

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

Öğe numarasını bir komut satırı argümanı olarak alır ve isim ve kısaltmayı ayrı satırlara verir.

Açıklama (biraz 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)

iiVe nnnkullanımlarını (Pip en son sürümünde eklenen) bir geri çağırma işlevi ile regex yedek taşıma: Her maç için ii|nnn, tüm alabilir ama yerine ilk karakter ve kullanım.

GNU sed, 171 (uneptunium)

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

Adın ve sembolün hangi sırada geldiği önemli değil, sanırım. Önce, sembol önce gelir:

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

şimdi sembol büyük harf

Bu yerleşik olmayan 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 rasgele sayı üzerinde test edin:

# -> 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 (heksodyum dışı) 171

Büyük harf kullanımı zor olan kısımdır. (FireFox'ta Test)

3 bayt düzenle, thx kullanıcısı olarak kaydedilmiş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>

Yakut - 163 156 147 143 134 (Untriquadium) bayt

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

Bu şekilde golf oynamayı umuyorum

Düzenleme: 9 bayt tıraş için @steveverrill için teşekkürler!

Edit2: Yine bir 4 bayt için @ steveverrill için teşekkürler! (Gerçekten akıllıca bir çözüm!)

Pyth, 67 bayt (Holmium)

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

Pyth Compiler / Executor'da çevrimiçi olarak deneyin .

Nasıl çalışır

            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 Bayt ( Biunnilium Binilbium)

@ Edc65 sayesinde eksi octium (8) bayt!

130 159 147 Bayt (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``

Gibi giriş f(324). Kendimi golf-y olarak hissettim.

CJam, 74 72 71 70 69 bayt (Thulium)

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

Kodun yazdırılamayan karakterler içerdiğini unutmayın.

İlk revizyonumdaki bir hataya dikkat çektiğiniz ve )/yaklaşımı önerdiğim için @ Sp3000'e teşekkürler .

Online Deneyin CJam tercüman: .

Nasıl çalışır

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)

Atlayabileceğiniz tüm girişler üzerinde çalışır, istediğiniz yere niliumkadar gidebilirsiniz. Ben var ennennennennennennennennennennennennennennennennennennennennennenniumben 9 tuşuna basarak ile bırakmadan önce.

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

Ve bir açıklama:

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

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 öğesi numarası 90'da biterse yalnızca üçlü "n", son rakam 2 veya 3 ise yalnızca iki "i" olabilir. Bu durumları kontrol etmek için matematiği kullanırız.

Sihirli sayı 1.5154her önek uzunluğunu depolar, işlevleri kullanarak uzunluktaki tüm ondalık sayıları ≤7 aramak için Python komut dosyasını kullanarak tespit edildi cosh(, cos(ve e^(.

Henüz golf yapmadı, ancak TI-BASIC'in iki baytlık küçük harfleri ve string manipülasyon komutlarının eksikliği, her zaman olduğu gibi, bu programın puanına zarar verecek.

Python 3, unpentquadium ( 156 155 154) bayt

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

Yerine değiştirme iiile iherhangi RStrip ibiz tack önce s iumçifte olası tek kaynağı olduğundan, is. Benzer şekilde, nbir enn/nildurumu kontrol ederek s soyuyoruz .

Retina, 206 196 186 179 (Unseptennium) bytes ( Çevrimiçi deneyin )

Bana bu dili öğrettiği için @ MartinBüttner'e ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner ) teşekkür ederiz .

7 bayt kesildiği için @FryAmTheEggman'e teşekkürler .

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-bayt versiyonu: burada

Bnh-byte versiyonu: burada

CJam, 95 bayt

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

Çevrimiçi deneyin

Bu, "düzenli olmayan ve yalnızca yazdırılabilir karakterleri kullanan diller" kategorisinde rekabet eder. ;) Önceden yayınlanan çözümlerden bazıları kadar kısa olmasını beklemiyordum, ama ne kadar süreceğini merak ediyordum. Ve şimdi aldığımdan beri, gönderebilirim de.

Açıklama:

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.

Git, 322 Bayt (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)}

STDIN'den üç karakter okur, daha fazlası dikkate alınmaz, çarpışmada daha az sonuç olur. Böylece unnilniliumve arasındaki her sayı için çalışır ennennennium.

PowerShell, 170 168 165 (Vekilsiz)

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

Oldukça basit ve burada sürpriz yok. Belki de bunun dışında büyük harfle ilgili sorunu, ilk kısım dışında kalan her şeyi daha az gizleyerek ve münferit kısımları zaten başlığında ele alarak çözdüm. Çıplak değişken atamaları için karakterleri kaybetmemek için şimdiye kadar agresif bir şekilde işaretlendi.

Son değişiklikten sonraki bonus: Artık daha uzun eleman numaraları için de çalışıyor:

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

X86, 192'deki C (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);}

Basamakları okur stdinve sonuçları basar stdout. Güveniyor sizeof(char*) == sizeof(int).

Ungolfed versiyonu:

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

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

Nimi sayesinde traşlanmış 34 bayt.

GNU sed, unhexunium (161 bayt)

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

Önce sembolü oluşturdum, sonra onu boşlukta tutup adı oluşturdum. Bir döngü, /gdört veya daha fazla değişiklik yerine kullanmaktan daha golfur (sadece bir iive / veya bir tane alabiliriz nnn, bu yüzden döngü içinde olmaları gerekmez, ama zarar vermez). Son olarak, tutulan sembolü alın ve ekleyin.

(NB bunu yazarken varolan sed cevabını görmedim)

Test durumları

Bunlar iive nnnözel kuralları uygular :

$ 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

Ve saçma bir kod, bu kodun fiziksel dünyaya kıyasla ne kadar fazla verdiğini gösteriyor:

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

T-SQL 329 bayt

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

biçimlendirilmiş:

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 bayt, unpentbium

En azından PHP bu sefer ortalama bir yerde.

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

Form komut satırını şöyle çalıştırır:

pentium.php 163

Çıktı:

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

Düzenle

• Tüm (sadece biri değiştirerek 10 bayt kaydedildi duh ) array()ile -initializer[]
• 'ium 'Ekstra bir birleştirme kullanarak boşlukla birlikte ekleyerek 1 bayt kaydedildi.' '.

Perl, 109 (Unnilennium) bayt

108 kod + 1 anahtarı

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'den gelen girişi satır başına bir sayı olarak alır.

Java 8 216Bytes

String f(int i){
String[] s = {"nil","un","bi","tri","quad","pent","hex","sept","oct","enn"};
return ((""+i).chars().mapToObj(y->s[y-48]).collect(Collectors.joining())+"ium").replace("ii","i").replace("nnn","n");
}

C # 229 (Bibiennium) 198 unennoctium bayt

"N-'0" hilesi, ascii'den int'ye dönüştürmenin bir yoludur. Char 9 = ASCII 57. Char 0 = ASCII 48, yani 57-48 = 9.

statik özel dize ToText (int v) {return (string.Join ("", v.ToString (). Seçin ((karakter))>> "nil unve quad pent hex sept oct enn" .Split () [n -'0 '])) + "ium"). ("Nnn", "nn") değiştirin. ("İi", "i") + "" + string.Join ("", v.ToString () öğesini değiştirin. .Seçin ((karakter 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;
    }

Bu yaklaşım int'yi alır, bir dizgeye dönüştürür, ardından bir lambdadan çıkan karakterlerin LINQ seçimini yapar.

Lambda, önek dizesini bölerek anında bir dizi (onu tanımlamaktan daha az karakter) oluşturur. Daha sonra, mevcut karakterin int değerine bakarak yukarıda kullanılacak n-'0 'numarasıyla kullanılacak önekin dizinini çeker.

Bütün bunlar bir LINQ sonucunun hepsini bir araya getiren bir dizgeye sarılır. "İum" u atın, sonra bir kaç nnn ve ii'yi temizlemek için sondaki ifadeleri yerleştirin.

Eksik sembol çıktısı eklendi. İki LINQ'u birleştirmenin daha etkili bir yolu olduğunu düşünüyorum, ancak buna devam etmenin geç bir yolu.

C, 210 204 unennennium (199) bytes

Bu çalışma zamanı karakter kümesi olarak ASCII gerektirir.

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

Ben (gereksinimini ortadan kaldırır bir özyinelemeli çözümü çalıştım pve o) ama bu artık ortaya çıktı.

Özellikle en uzak ayrılmış rakamlara 90|[23]$dayanan 9ve bunlara dayanan regexp'in eşleştiricisinden utanıyorum / utanıyorum 0(ve dolayısıyla 9'dan farklı olan tek çift - 39kodda jbir tamsayı değeri ve *nhala bir ASCII olmasının bir sonucudur) karakter) ve bu 2ve 3sadece son bitlerde farklılık gösterir, bu yüzden 2'ye bölmek onları bir araya getirir.

Genişletilmiş 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 */
}

Test kablo demeti:

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

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

En iyisi değil ... ama hala R öğreniyorum, bu yüzden girişimimi göndereceğimi düşündüm. Daha iyi yapmak için herhangi bir öneriniz var mı? Şimdi düşünüyorum ki, satır isimleri yaratarak yer açmak yerine, muhtemelen nth-1 sırasına alt kümelemek mümkündür.

Örnek kullanım

> 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. Bir anahtar oluşturun, veri çerçevesine dönüştürün ve değişken olarak ayarlayın k
2. Satır adlarını 0-9kolay tanımlama için ayarlayın
3. Girdiyi alın, xkaraktere dönüştürün, bölün (ör. 137 - "1" "3" "7")
4. kBölünmüş sayı girişine göre alt küme ve girdileri döndür
5. Onları bir araya getirin ve ekleyin -ium
6. Ayrıca k, eşleşmelerin ilk harfini çekmek için alt dize kullanarak altküme . Bu, 5. adımın çıktısına, aralarında bir boşluk bırakılarak birleştirilir.
7. Ve desenlerini sub()değiştirmek için kullanınnnnii

Javascript - 169 bayt

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

Tuhaf bir şekilde, harita kullanma girişimlerim for döngüsünden daha uzundu.

EDIT: Hata! Tarihi kontrol etmeyi unuttum.

PHP, 131 + 1 bayt (üçlü)

hala çok uzun:

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

Pipe ile çalıştırın -nRveya çevrimiçi deneyin .

Python, 154 bayt

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