X-illion को मानक रूप में परिवर्तित करें

Question

एक स्ट्रिंग को देखते हुए, एक उपसर्ग और फिर "illion" से मिलकर, इस संख्या को मानक रूप में परिवर्तित करता है।

उदाहरण के लिए:

"million" -> 10^6
"trillion" -> 10^12
"quattuordecillion" -> 10^45

इस कार्यक्रम को सेंटिलियन तक जाने वाले इनपुट को संभालने में सक्षम होना चाहिए, जो कि 10 ^ 303 है। नामों की सूची और उनके मानक फॉर्म मूल्य यहां देखे जा सकते हैं - ध्यान दें कि यह प्रत्येक 10 ^ 63 तक 10 ^ 3 वेतन वृद्धि के लिए मान देता है, लेकिन फिर उन्हें 10 ^ 30 वेतन वृद्धि में देता है, हालांकि पैटर्न काफी सीधा है।

कार्यक्रम को सभी 100 मामलों को संभालने की आवश्यकता है (यहां तक ​​कि प्रदान की गई वेबसाइट द्वारा स्पष्ट रूप से नहीं दिए गए) - यहां इसके कुछ उदाहरण दिए गए हैं:

"sexvigintillion" -> 10^81
"unnonagintillion" -> 10^276
"octotrigintillion" -> 10^117

इनपुट स्ट्रिंग के रूप में STDIN, फ़ंक्शन तर्क या हार्ड-कोड के माध्यम से दिया जा सकता है।

यह कोड-गोल्फ है, इसलिए सबसे छोटा कोड जीतता है!

Comments

10 ^ 70 क्या होगा?

— शिमोनस्टर

10 ^ 70 में एक प्रतिनिधित्व नहीं है क्योंकि 3 में 70 का कोई कारक नहीं है - लेकिन 10 ^ 69 सेक्सविगेंटिलियन होगा। 10 ^ 70 में 10 सेक्सविजिनिलियन होंगे।

— विलियम्स पर जेम्स विलियम्स

असल में, doevigintillion = 10 ^ 69, और sexvigintillion = 10 ^ 81।

— रेमी

@ दुश्मन मैं अनुमान लगाता हूं कि आप लंबे पैमाने का उपयोग करते हैं (यदि यह सही है)? ऐसा लगता है कि यह प्रश्न छोटे पैमाने का उपयोग करता है।

— कोल जॉनसन

@ कोले जॉनसन: सवालों की प्रदान की गई सूची में नामों की सूची vigintillion = 10 ^ 63 है, और यह दर्शाता है कि संयुक्त राष्ट्र- 3 को शक्ति में जोड़ता है, doe- 6 जोड़ता है, सेक्स- 18 जोड़ता है, आदि

— रेमी

Answer 1

अजगर 2 ( 384 368 365 348 347 बाइट्स)

def c(s):
 s=s[:-6].replace('int','');k=0;d=dict(un=1,doe=2,tre=3,quattuor=4,quin=5,sex=6,septen=7,octo=8,novem=9,b=3,tr=4,quadr=5,qu=6,sext=7,sept=8,oct=9,non=10,dec=11,vig=21,trig=31,quadrag=41,quinquag=51,sexag=61,septuag=71,octog=81,nonag=91,cent=101)
 for p in(s!='m')*list(d)*2:
    if s.endswith(p):s=s[:-len(p)];k+=3*d[p]
 return 10**(k or 6)

( ifलाइन एक टैब के साथ इंडेंट की जाती है, और बाकी सिंगल स्पेस के साथ।)

यहाँ c('million') == 10**6एक विशेष मामला होना चाहिए क्योंकि 'novem'यह भी समाप्त होता है 'm'।

उदाहरण:

c('million') == 10**6
c('trillion') == 10**12
c('quattuordecillion') == 10**45
c('novemnonagintillion') == 10**300
c('centillion') == 10**303

350 बाइट्स में इसे नीचे करने के लिए फल्को को धन्यवाद।

---

अभ्यास के लिए मैंने इसे एक-लाइनर के रूप में लंबोदा का उपयोग करके फिर से लिखने की कोशिश की। यह 404 398 390 384 380 379 बाइट्स है:

c=lambda s:(lambda t=[s[:-5].replace('gint',''),0],**d:([t.__setslice__(0,2,[t[0][:-len(p)],t[1]+3*d[p]])for p in 2*list(d)if t[0].endswith(p)],10**t[1])[1])(un=1,doe=2,tre=3,quattuor=4,quin=5,sex=6,septen=7,octo=8,novem=9,mi=2,bi=3,tri=4,quadri=5,qui=6,sexti=7,septi=8,octi=9,noni=10,deci=11,vii=21,trii=31,quadrai=41,quinquai=51,sexai=61,septuai=71,octoi=81,nonai=91,centi=101)

Comments

ओपी के विनिर्देशन के अभाव के लिए +1 कि क्या "10 ^ x" मुद्रित किया जाना चाहिए या क्या केवल संख्यात्मक मान वापस करना पर्याप्त है।

— इंगो बुर्क

धन्यवाद, हालांकि return'10^'+str(3*k)केवल 4 बाइट्स अधिक होगी।

— रेमी

चूंकि यह अजगर 2 है, आप पहले स्तर के लिए एक स्थान इंडेंट का उपयोग कर सकते हैं, और दूसरे के लिए टैब। आप कीवर्ड तर्कों के रूप में भी aऔर bफंक्शन में दोनों को स्थानांतरित कर सकते हैं ।

— FryAmTheEggman

1000**kसे छोटा है 10**(3*k)। kद्वारा वृद्धि 3*d[p]भी समान रूप से कम है।

— xnor

if'm'==s:k=6;d=[]दूसरी लंबी returnस्टेटमेंट के बजाय शुरुआती निकास से बचकर आप कुछ पात्रों को बचा सकते हैं ।

— फल्को

Answer 2

जेएस (ईएस 6), 292 270

दी गई सूची में लिखे गए नंबरों को ही समझता है। ओपी दूसरों के बारे में स्पष्ट नहीं है।

z=b=>{a="M0B0Tr0Quadr0Quint0Sext0Sept0Oct0Non0Dec0Undec0Doedec0Tredec0Quattuordec0Quindec0Sexdec0Septendec0Octodec0Novemdec0Vigint0Trigint0Quadragint0Quinquagint0Sexagint0Septuagint0Octogint0Nonagint0Cent".split(0);for(i in a)if(~b.indexOf(a[i]))return"10^"+(20>i?3*i+6:93+30*(i-20))}

उदाहरण:

z("Billion") // "10^9"
z("Centillion") // "10^303"

Comments

आप स्ट्रिंग में शून्य को हटाने और जगह ले सकता है split(0)के साथ match(/[A-Z][a-z]*/g)उपयोग प्रत्येक स्ट्रिंग के मिलान regexes के लिए।

— निंजाबियरनोक

यह केवल "संयुक्त राष्ट्र, डो, ट्रे, आदि" के लिए उपसर्ग संभालता है। यह भी unvigintillion = 10 ^ 66 और novemnonagintillion = 10 ^ 300

— रेमी

आप ES6 फ़ंक्शन का उपयोग करके इसे छोटा कर सकते हैं =>।

— soktinpk

सुझावों के लिए धन्यवाद। @ दुश्मन क्या आपको यकीन है? ओपी पूछने के लिए प्रतीत नहीं होता है कि

— xem

मुझे स्पष्ट लगता है कि 3 के सभी गुणकों की आवश्यकता है: "... यह 10 ^ 63 तक हर 10 ^ 3 वेतन वृद्धि के लिए मान देता है, लेकिन फिर उन्हें 10 ^ 30 वेतन वृद्धि में देता है, हालांकि पैटर्न काफी सीधा है" ओपी। साथ ही ओपी एक टिप्पणी में "sexvigintillion" का उदाहरण देता है।

— feersum

Answer 3

सी, 235

सभी 100 मामलों को संभालता है। कार्यक्रम स्टडिन और स्टडआउट का उपयोग करता है।

ऊंट के मामले में बंटवारे के लिए किसकी जरूरत है?

char*Z="UUUi+W<)E(<7-7-++*)('&%$,*$&%$",u[999]="\0MBRilDriPtiNiUnOeReTtUiXTeCtVeCiGRigRaUagInquiXaXsexPtuOgOoNaCeCeK1",s[99],*U=u+67;
main(n){
for(gets(s);*--U;)
*U<95?
*U|=32,
n+=!!strstr(s,U)*(*Z++-35),
*U=0:
3;puts(memset(u+68,48,3*n)-1);
}

उदाहरण

octoseptuagintillion
1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

Comments

यह बात सी की तरह अब भी नहीं दिखती ... मैं हैरान हूं।

— क्वेंटिन

क्यों अंतरिक्ष ( *U<95 ?) और सभी newlines?

— टॉस

@tomsmeding अंतरिक्ष एक निरीक्षण था। Newlines कोड को "पठनीय" बनाते हैं और गिनती में शामिल नहीं होते हैं।

— feersum

Answer 4

क्लोजर, 381 377 बाइट्स

(defn c[x](let[l{"M"6"B"9"Tr"12"Quadr"15"Quint"18"Sext"21"Sept"24"Oct"27"Non"30"Dec"33"Undec"36"Doedec"39"Tredec"42"Quattuordec"45"Quindec"48"Sexdec"51"Septendec"54"Octodec"57"Novemdec"60"Vigint"63"Trigint"93"Googol"100"Quadragint"123"Quinquagint"153"Sexagint"183"Septuagint"213"Octogint"243"Nonagint"273"Cent"303}v(l(clojure.string/replace x #"illion$" ""))](Math/pow 10 v)))

उदाहरण:

(c "Septuagintillion") ;; 1.0E213

Answer 5

हास्केल, 204 बाइट्स (स्वरूपित स्ट्रिंग के लिए +9)

import Data.List
x s=10^(f$[a|k<-tails s,i<-inits k,(b,a)<-zip["ce","ad","un","do","b","mi","vi","tr","at","ui","x","p","oc","no","ec","g"]$100:4:1:2:2:[1..],b==i])
f[]=3
f(x:11:r)=30*x+f r
f(x:r)=3*x+f r

GHCi में:

*Main> x "decillion"
1000000000000000000000000000000000

एक और 9 बाइट्स जोड़ने के 10^(साथ प्रतिस्थापित करना "10^"++(show.:

import Data.List
x s="10^"++(show.f$[a|k<-tails s,i<-inits k,(b,a)<-zip["ce","ad","un","do","b","mi","vi","tr","at","ui","x","p","oc","no","ec","g"]$100:4:1:2:2:[1..],b==i])
f[]=3
f(x:11:r)=30*x+f r
f(x:r)=3*x+f r

GHCi में:

*Main> x "decillion"
"10^33"

संपादित करें: मैं सही करना पड़ा के लिए "quinquagintillion"जो होता है "qua"।