तत्व नाम 118 से ऊपर


46

उनके अपर्याप्त ज्ञान में 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 तक मान्य होना चाहिए । यदि यह आपके कोड की लंबाई नहीं बढ़ाता है तो कोई भी मान्य है।

पायथन उदाहरण विधि दिखा रहा है:

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

एरिक टॉवर्स कैडमियम बाइट्स के साथ जीतता है!


34
मैं अपने IUPAC व्यवस्थित तत्व नाम से बोरॉन को कॉल करना शुरू करने जा रहा हूं: "पेंटियम"
माइकल


1
क्या हमारे पास सही मामला होना चाहिए?
lirtosiast

6
@BetaDecay लेकिन क्या यह "पांचवां तत्व" मल्टीपास का समर्थन करता है ?
दामियन येरिक

जवाबों:


22

गणित १०.१, इंडियम (४ ९) कैडमियम ( , )

यह समाधान IUPAC नामों और संक्षिप्तीकरण सहित, तत्वों की निर्मित लाइब्रेरी का उपयोग करता है। (मैंने इसे गोल्फ में टाले जाने वाली तकनीक के रूप में नहीं देखा है। यह प्रोत्साहित करने के लिए लगता है। लेकिन यह स्वीकार्य होने के किनारे पर (शायद खत्म हो सकता है) - मैथमेटिका इस पुस्तकालय (और कई अन्य) से डेटा डाउनलोड करके लागू करता है वुल्फ्राम के सर्वर पहली बार जब आप इसका उपयोग करते हैं (और मैं कभी-कभी अपडेट के लिए जांच करता हूं)।)

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

यह पाइथन में एलिमेंट्स या पीरियडडिक्टेबल ओडीएम का उपयोग करने की तुलना कैसे करेगा?

संपादित करें: महीने बाद: अधिसूचित मैंने 122 के लिए संक्षिप्त नाम आउटपुट टाइप किया था। मैंने कोड को फिर से चलाया है और सत्यापित किया है कि मैंने यह त्रुटि की है, न कि गणितज्ञ ने।


9
जब मैं चुनौती लिख रहा था, मैंने सोचा "क्या मुझे कार्यों में निर्मित को रोकना चाहिए? नाह, इसकी संभावना किसी भी भाषा में निर्मित नहीं है। रुको, गणितज्ञ के पास हो सकता है।" लेकिन मुझे नहीं पता था कि इसे कैसे जांचना है और फिर तुरंत इसके बारे में भूल गए।
स्थिति

7
पवित्र माता-पिता, बैटमैन! वह पैराग्राफ कुछ ऐसा दिखता है, जिसे मैं लिख सकता था (मैं, भी, मेरी वाचालता को कम करने के प्रयास में माता-पिता के रूप में उपयोग करने का दोषी हूं - वे आमतौर पर इस तरह से बन जाते हैं, हालांकि)।
कोल

1
आप आंतरिक आवेदन का उपयोग करके और fखुद को एक शुद्ध कार्य करके एक और बाइट बचा सकते हैं f=ElementData@@@{{#,"Abbreviation"},{#,"Name"}}&:।

क्या यह कोड 118 के लिए अमान्य हो जाएगा यदि प्रश्न में तत्व आधिकारिक नाम प्राप्त करता है?

1
@ ais523: विनिर्देश के अनुसार "तो इस गोल्फ के लिए, आपके कोड को दिए गए सकारात्मक पूर्णांक के लिए तत्व नाम और उसके प्रतीक दोनों को उत्पन्न करने की आवश्यकता है।" यदि तत्व का कोई नाम या प्रतीक है, तो उस नाम या प्रतीक को सूचित किया जाना चाहिए। आपके मीट्रिक द्वारा, फिर, इस पृष्ठ पर प्रत्येक अन्य प्रस्तुतिकरण विनिर्देश को पूरा करने में विफल हो जाएगा यदि परमाणु संख्या> = 118 के साथ किसी भी तत्व को एक व्यवस्थित प्रतीक या नाम मिलता है।
एरिक टावर्स

27

पायथन 3, अनहेक्सिप्टियम (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 तक हर नंबर पर चलाया जाता है (समावेशी)


30
आपका हेडर अब मुझे चाहता है कि हर कोई उस तरह से बाइट की संख्या को सूचीबद्ध करे।
स्थिति

4
@ स्टैटस सुनो, सुनो। यह उन लोगों को बहुत दुखी कर रहा है ... :)
बीकर

1
@ बीकर मैं निराश हूं कि आपका प्रोफ़ाइल चित्र बीकर नहीं है ;)
बीटा

4
@ बेताडेय ने किया।
बीकर

6
@ स्टैटस: यदि कोई इसे 112 बाइट्स से कम में प्रबंधित करता है, तो उनके पास शीर्षक में एक शास्त्रीय तत्व नाम हो सकता है :) जैसे रदरफोर्डियम । या सोना
vsz

15

पिप , थोरियम एक्टिनियम रेडॉन (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का उपयोग करता है एक कॉलबैक फ़ंक्शन (पिप का नवीनतम संस्करण में जोड़ा) के साथ एक regex प्रतिस्थापन से निपटने: के हर मैच के लिए ii|nnn, सभी लेकिन लेने के पहले अक्षर और एक स्थानापन्न के रूप में उपयोग के।


Protip: जबकि अन्य प्रविष्टियों को साँस लेना आपको फेफड़ों का कैंसर नहीं दे सकता है , फिर भी वे शायद आपके स्वास्थ्य के लिए सबसे अच्छे नहीं हैं।
साइओस

14

ग्नू सेड, 171 (अनसेप्टुनियम)

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
$ 

4
मुझे नहीं लगता कि आखिरी दो की जरूरत है g; केवल मामलों होगा biium/ triiumऔर ennnil, सभी जिनमें से केवल 1000 के नीचे की संख्याओं में एक बार हो सकता है
PurkkaKoodari

8

मैथेमेटिका, अनहेक्सुनियम 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

8

जावास्क्रिप्ट (ईएस 6) 164 (अनएक्सक्लेडियम) 171

पूंजीकरण मुश्किल हिस्सा है। (फ़ायरफ़ॉक्स में टेस्ट)

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>


कुछ भी नहीं है कि के *eniumबजाय रिटर्न*ennium*9
DankMemes

Unhexhexium संस्करण: n => [([... n] .map (c => (c = 'nil, un, bi, tri, quad, pent, hex, sept, oct, enn'.split`), [] ग], मैं = ग [0], एस = रों रों + मैं:। i.toUpperCase (), ग), एस = ''।) join`` + 'ium') की जगह (/ ii | NNN / जी , r => r.slice (1)), s]
मामा फन रोल

@molarmanful [...n]एक int पैरामीटर के लिए विफल हो जाएगा। चुनौती के बारे में हैa given positive integer
edc65

यदि आप अपने 'रिप्लेस' कॉल को बदल देते हैं तो आप बेहिचक पा सकते हैंreplace(/i(i)|n(nn)/g,'$1$2')
आशा है कि मैं

@ user2786485 thx मैंने कैप्चर का उपयोग करने के बारे में सोचा लेकिन सही तरीका नहीं मिला
edc65

7

रूबी - 163 156 147 143 134 (अतिक्रमण) बाइट्स

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

मैं इस तरह से नीचे गोल्फ की उम्मीद कर रहा हूँ

संपादित करें: 9 बाइट्स बंद करने के लिए @steveverrill के लिए धन्यवाद!

Edit2: एक और 4 बाइट के लिए @steveverrill फिर से धन्यवाद! (वास्तव में चतुर समाधान!)


1
1. इसके बजाय each_charआप उपयोग कर सकते हैं chars। आधिकारिक रूबी प्रलेखन के अनुसार यह "पदावनत" है (लेकिन कोडगॉल्फ में नहीं!) आप शायद इसके साथ बेहतर करेंगे each_byteया bytesफिर c.to_iउदाहरण के लिए बन जाएंगे i%48। 2. इसके अलावा संयोग \nसे ascii कोड 10 है, इसलिए हो सकता है कि आप छुटकारा पाएं chopऔर iumअपने सरणी में शामिल करें (तत्व नाम के लिए महान काम करता है, लेकिन iतत्व प्रतीक के लिए एक शानदार जोड़ता है ।)
स्तर नदी सेंट

1
आप tr_sइस तरह से एक और 5 बाइट्स बचा सकते हैं :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].downcase.capitalize
लेवल रिवर सेंट

u.chopसे छोटा है u[0..-2]। हो सकता है कि मुझे अपना जवाब पोस्ट करना चाहिए था, लेकिन मेरा प्रारंभिक विचार यह करना था कि जैसा आपने किया था। हालांकि यह आपको गोल्फ में मदद करने में मज़ा आया है। मैं पूरी तरह से याद किया है कि आप downcaseसे पहले की जरूरत नहीं है capitalize
लेवल रिवर सेंट

7

पायथ, 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)

6

जावास्क्रिप्ट ( ईएस 6) , 210 202 बाइट्स ( बायुनिलियम बिनीबिलियम)

माइनस ऑक्टियम (8) बाइट्स, @ edc65 की बदौलत!

१३० १५ (१४ 130 बाइट्स (अनट्रिनिलियम अनएपेन्डेनिअम अनक्वाडेप्टियम)

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)। ऊ, मुझे लगा कि गोल्फ-वाई है।


@ edc65 ने तीनों समस्याओं का समाधान किया।
कॉनर ओ'ब्रायन

1
ठीक। अब, टेम्प्लेट स्ट्रिंग्स का उपयोग करके आप कुछ कोष्ठकों से बच सकते हैं और शायद 8 बाइट्स codegolf.stackexchange.com/a/52204/21348
edc65

6

सीजाम, 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".

3
मजेदार तथ्य: टंगस्टन का उपयोग अक्सर नकली सोने की छड़ों और सिक्कों में किया जाता है, इसकी वजह यह है कि यह सोना के अत्यधिक घनत्व और इसके सस्ते सस्तेपन के कारण है।
lirtosiast

1
लुटेटियम एक तत्व के लिए एक बेतुका शांत नाम है।
टी। सर - मोनिका

@ThalesPereira भले ही Ytterbium से ठंडा हो?
बीटा डेके

मजेदार तथ्य: एर्बियम, टेर्बियम, येट्रियम, और यट्रबियम सभी एक ही स्थान के नाम पर हैं
२०:११

5

मतलाब, 170 (अनसेप्टिलियम)

उन सभी इनपुटों पर काम करता है जिन पर आप इसे फेंक सकते हैं, 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

5

टीआई-बेसिक, 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, जो प्रत्येक उपसर्ग की लंबाई को संग्रहीत करता है, पायथन लिपि का उपयोग करके फ़ंक्शन , और cosh(, का उपयोग करके लंबाई im7 के सभी दशमलव को खोजने के लिए पाया गया था ।cos(e^(

अभी तक गोल्फ नहीं किया गया है, लेकिन TI-BASIC के दो-बाइट लोअरकेस अक्षर और स्ट्रिंग हेरफेर कमांड्स की कमी, हमेशा की तरह, इस कार्यक्रम के स्कोर को चोट पहुंचाएगी।


मैं इसे नीचे गोल्फिंग पर काम करूँगा। ^ _ ^ मैं आपको बताता हूं कि मैं क्या लेकर आया हूं।
कॉनर ओ'ब्रायन

मुझे नहीं लगता कि किसी के लिए भी यह संभव है कि यह ११ for या उससे कम हो, लेकिन अगर कोई इसका प्रबंधन करता है, तो मैं ५०० प्रतिनिधि दूंगा।
lirtosiast

दो प्रश्न: N% क्या है और "and" और "N" क्या हैं?
कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ क्षमा करें,% एक दो-बाइट टोकन है जिसे आप अपने कैलकुलेटर में टाइप नहीं कर सकते हैं। Cemetech के SourceCoder या TI के टूल का उपयोग इसे स्रोत में संपादित करने के लिए करें, या मेरे द्वारा दी गई फ़ाइल का उपयोग करें।
lirtosiast

@ C @O'Bʀɪᴇɴ ᴏɴᴏʀ सबस्क्रिप्ट 10 है; मैंने इसे एक नियमित 10.
lirtosiast

2

पायथन 3, अनपैकडियम ( 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())

इसके बजाय हम किसी भी s rstrip को बदलने iiसे पहले हम पर iसौदा iकरते हैं ium, क्योंकि यह डबल is का एकमात्र संभावित स्रोत है । इसी तरह, हम nएक enn/nilमामले की जाँच करके एस पट्टी करते हैं ।


2

रेटिना, 206 196 186 179 (अनसेप्टेनियम) बाइट्स ( इसे ऑनलाइन आज़माएं )

@ MartinBüttner ( https://codegolf.stackexchange.com/users/8478/martin-b%C3%BCttner) का धन्यवादइस भाषा को सिखाने ) का ।

7 बाइट्स काटने के लिए @FryAmTheEggman को धन्यवाद ।

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 संस्करण: यहां

बान-बाइट संस्करण: यहाँ


2

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.

1
बस संदर्भ के लिए, डेनिस केवल 6 बाइट्स को उस सभी आधार एनकोडिंग के साथ बचाता है: पी
Sp3000 19

1

गो, 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)}

एसटीडीआईएन के तीन पात्रों को पढ़ता है, अधिक अनदेखा किया जाता है, एक दुर्घटना में कम परिणाम। इसलिए यह प्रत्येक संख्या के बीच unnilniliumऔर के लिए काम करता है ennennennium


इसके अलावा, 322 बाइट्स के लिए तत्व ट्राइबिनियम नहीं होना चाहिए? 321 ट्रिब्यूनियम है।
Mateon1

धिक्कार है, मुझे "आई" जोड़ने पर वह याद आया। अब सब कुछ क्रम में होना चाहिए
फेबियन शेंगलर

1

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

1

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)

Ungolfed संस्करण:

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

1

हास्केल, बिपेंटबियम ( 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 बाइट्स काट दिया।


1
आप को हार्डकोड कर सकते हैं nnnऔर iiमें मामलों r, यानी r('i':'i':a)='i':r a;r('n':'n':'n':a)="nn"++r a;r(x:a)=x:r a;r x=xऔर तर्क के बिना इसे कहते: t=r.m.p
nimi

उस के लिए @nimi चीयर्स!
jkabrg

1
को बचाने के लिए कुछ और बाइट्स: concatMapहै >>=, यानीp n=(n>>=(words"..."!!))++"ium "
nimi

@ निम्मी चियर्स फिर से।
jkabrg

1

ग्नू सेड, अनहेक्सुनियम (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

1

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

1

PHP, 152 153 163 बाइट्स, अनबॉम्बियम

खैर, कम से कम 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 बाइट्स बचाया डुह ) array()के साथ -initializer[]
  • 'ium 'एक अतिरिक्त संयोजन का उपयोग करने के बजाय व्हाट्सएप को जोड़कर 1 बाइट बचाया.' '.

0

पर्ल, 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 से प्रति पंक्ति एक नंबर के रूप में इनपुट लेता है।


आपका मतलब है अन n ilseptium :)
CompuChip

आह, यह इंगित करने के लिए धन्यवाद कि :) अब इसे ठीक कर दिया गया
svsd

0

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

3
प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! 1. आपका कोड, एक पूर्ण कार्यक्रम या फ़ंक्शन के रूप में, पूर्णांक को इनपुट के रूप में स्वीकार करना चाहिए और उचित नाम उत्पन्न करना चाहिए। 2. यह iiऔर के लिए खाता नहीं है nnn, जैसा कि प्रश्न में समझाया गया है। 3. कोड गोल्फ का उद्देश्य कोड को यथासंभव छोटा बनाना है। जवाब में शीर्षक में अपना स्कोर होना चाहिए। आप व्हॉट्सएप को खत्म करके और चर नाम को छोटा करके अपने स्कोर को कम कर सकते हैं।
डेनिस

@ डेनिस धन्यवाद! लेकिन व्हॉट्सएप की गिनती क्यों? यह कोड को और भी अधिक अपठनीय बनाता है।
Rnet

3
@Rnet कोड को पठनीय बनाने का लक्ष्य नहीं है। ;) इसके अलावा कुछ व्हाट्सएप महत्वपूर्ण हो सकते हैं, इसलिए यह स्पष्ट नहीं है कि कौन सा व्हाट्सएप गिनती करने के लिए और कौन सा नहीं। इसलिए, उत्तर को यथासंभव व्हाट्सएप को हटा देना चाहिए और बस उस संस्करण के बाइट्स को गिनना चाहिए। यदि आप उचित इंडेंटेशन के साथ एक पठनीय संस्करण प्रदान करना चाहते हैं, तो आप हमेशा गिने हुए कोड के नीचे ऐसा कर सकते हैं। मेटा पर प्रासंगिक सहमति देखें।
मार्टिन एंडर

0

C # 229 (Bibiennium) 198 unennoctium बाइट्स

"N-'0 '" ट्रिक, अस्सी से इंट में बदलने का एक तरीका है। चार 9 = एएससीआईआई 57। चार 0 = एएससीआईआई 48, इसलिए 57-48 = 9।

स्थिर निजी स्ट्रिंग ToText (int v) {वापसी (string.Join ("", v.ToString) () चुनें। (char n) => "nil un bi tri quad pent hex sept oct enn" .Sitit () [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;
    }

यह दृष्टिकोण इंट ले जाता है, एक स्ट्रिंग में परिवर्तित हो जाता है, फिर एक अक्षर का चयन करता है जो एक लैम्बडा से फायर करता है।

लैम्ब्डा उपसर्गों की स्ट्रिंग को विभाजित करके मक्खी पर एक सरणी उत्पन्न करता है (इसे परिभाषित करने से कम वर्ण)। यह तब उपसर्ग के सूचकांक को वर्तमान चरित्र के अंतर मान (ऊपर उल्लिखित n-'0 'चाल) को देखकर उपयोग करता है।

वह सब एक तार में लिपटा हुआ है। जो कि LINQ के सभी परिणामों को एक साथ जोड़ देता है। "Ium" पर टिक करें, फिर nnn और ii's को साफ करने के लिए अंत में एक .Replace स्टेटमेंट की एक जोड़ी।

लापता प्रतीक आउटपुट जोड़ा गया। मुझे लगता है कि दो LINQs को मर्ज करके एक और अधिक कुशल तरीका है, लेकिन इसे देर तक रखने का तरीका है।


इसके बजाय n-'0', क्यों नहीं n-30?
अंडरग्राउंडोरेल

अच्छी कॉल, लेकिन यह चरित्र सेट पर निर्भर करता है। 48 मेरे लिए काम करता है;)
रिक वे

0

सी, 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) लेकिन वह लंबे समय तक निकला।

मैं regexp के लिए मिलान करने वाले पर विशेष रूप से गर्व / शर्मिंदा हूं 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;
}

0

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

सबसे अच्छा नहीं ... लेकिन मैं अभी भी आर सीख रहा हूं इसलिए मैंने सोचा कि मैं अपना प्रयास पोस्ट करूंगा। इसे बेहतर बनाने के लिए कोई सुझाव? अब जब मुझे लगता है कि इसके बारे में यह संभव है कि जगह बनाने वाले पंक्ति नामों को बर्बाद करने के बजाय 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()को बदलने के लिए उपयोग करेंnnnii

आप प्रतीक के पहले अक्षर को भुनाना भूल गए। उदाहरण के लिए, यह "यूओओ" होना चाहिए, न कि "यूओओ", 118 के लिए।
अलेक्जेंडर रेवो

0

जावास्क्रिप्ट - 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 '+_`)

विचित्र रूप से, मानचित्र का उपयोग करने के मेरे प्रयास लूप के लिए अधिक लंबे थे ।

संपादित करें: ओह, तारीख की जांच करना भूल गया।



-1

पायथन, 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')))

यह कोड अमान्य आउटपुट उत्पन्न करता है।
अलेक्जेंडर रेवो
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.