अपने प्रथम श्रेणी के गिनती अभ्यास को स्वचालित करें

Question

कोडगल्फ चैलेंज

PWSSHHHH! आप वर्ष 3000 में क्रायोजेनिक लैब में जागते हैं। असाइनमेंट ऑफिस में अपना कैरियर चिप प्राप्त करने के लिए एस्कॉर्ट होने पर, संभवतः डिलीवरी बॉय का, एक जांच से पता चलता है कि आप वर्ष 2000 से हैं। इस वजह से, और कुछ स्टीरियोटाइप्स, आपको आज के आधुनिक मानव की तुलना में बेवकूफ माना जाता है और ग्रेडस्कूल दोहराने के लिए मजबूर किया जाता है।

आप अपनी पहली कक्षा में प्रवेश करते हैं और शिक्षक एक असाइनमेंट दे रहा है। वह 50 तक की संख्या कहेगा या लिखेगा। यदि वह बोर्ड पर संख्या लिखती है (उदाहरण के लिए: 25) तो आपको उस संख्या तक के अंकों को "एक, दो, तीन, ..., पच्चीस कहना होगा।" "। यदि वह ज़ोर से संख्या कहती है (उदाहरण के लिए: "छह") तो, आपके टेबलेट पर, आपको उस संख्या तक संख्याएं लिखनी होंगी "1, 2, 3, 4, 5, 6"

यह बहुत थकाऊ हो जाता है और आप तय करते हैं कि आप अपने अभी भी कामकाज, अभी तक पुरातन, 21 वीं सदी के प्रोग्रामिंग ज्ञान के साथ प्रक्रिया को स्वचालित करेंगे।

---

उद्देश्य:

आपके प्रोग्राम को एक इनपुट लेना चाहिए। यह इनपुट या तो दशमलव संख्या ( 1 thru 50) या लिखित संख्या होगी ( one thru fifty)।

• यदि इनपुट एक दशमलव संख्या है, तो लिखित-आउट शैली का उपयोग करते हुए, आपका आउटपुट एक से उक्त संख्या तक गिना जाना चाहिए। (जैसे बत्तीस )

• यदि इनपुट एक लिखित संख्या है, तो आपके आउटपुट को दशमलव शैली का उपयोग करते हुए 1 से उक्त संख्या तक गिनना चाहिए। (उदाहरण 32 )

---

नियम:

इनपुट और आउटपुट आपके चुनने के किसी भी मामले में हो सकता है (ताकि आप एक ऐसा प्रोग्राम बना सकें जो केवल ऊपरी-मामले को स्वीकार करता है यदि वांछित हो)।

इनपुट दशमलव संख्याओं का एक नंबर प्रकार (उदाहरण के लिए) नहीं होना चाहिए, वे एक इनपुट स्ट्रिंग वाले नंबर (25 बनाम "25") हो सकते हैं। या तो ठीक है और आप अपना कार्यक्रम स्वीकार करना चाहते हैं, जिसे आप चुन सकते हैं। (आपके कार्यक्रम को दोनों को स्वीकार करने की आवश्यकता नहीं है)

लिखित शैली में यौगिक शब्दों के बीच एक हाइफ़न की आवश्यकता नहीं है, लेकिन आप चाहें तो कर सकते हैं।

आउटपुट वैल्यू को किसी न किसी रूप में अलग किया जाना चाहिए, कोई भी विभाजक ठीक नहीं है 1,2,3 1 2 3 etc

आप अतिरिक्त लाइब्रेरी जैसे संख्या 2 पासवर्ड (अजगर) आदि नहीं जोड़ सकते हैं (हालाँकि सिस्टम लाइब्रेरी ठीक हैं)

भले ही बैक-स्टोरी कहती है कि आप वर्ष 2000 से हैं, आप उस तिथि के बाद बनाई गई भाषाओं का उपयोग कर सकते हैं (lol)

---

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

Comments

क्या हमें अजगर के मामले में संख्या 2 पासवर्ड जैसे पुस्तकालयों का उपयोग करने की अनुमति है ।

— गुरुपद ममदापुर ३१'१ad को

@AlbertRenshaw लेकिन बिल्डरों के बारे में क्या है जो ऐसा करते हैं? (गणितज्ञ)

— पावेल

@ कॉर्डपंप या तो आप एक या दूसरे या दोनों को चुन सकते हैं। यह दोनों प्रकार के इनपुट्स को संभालने में सक्षम नहीं है

— अल्बर्ट रेनशॉ

"मेरे चमकदार धातु गधे काटो!" मैं खुद को नहीं

— गिनूंगा

मुझे लगता है कि शीर्षक "आपकी पहली (ग्रेड काउंटिंग)" है न कि "आपकी (पहली कक्षा की) गिनती"

— CAD97

Answer 1

पर्ल 6 , 119 113 बाइट्स

{my \n=<① ⑳ ㉑ ㉟ ㊱ ㊿>.map:{|map *.uniname.words[2..*].join,$^a..$^b}
/\d/??n[^$_]!!1..1+first $_,n,:k}

यूनिकोड डेटाबेस FTW!

हाई-केस लिखित-आउट संख्या बिना हाइपेन के उपयोग करता है, जैसे TWENTYTWO।
स्ट्रिंग्स, या संख्याओं की एक सूची देता है। (दोनों जब छपते हैं तो विभाजक के रूप में स्थान का उपयोग करते हैं put।)

Comments

बहुत चतुर आहाहा! इसे प्यार करें

— अल्बर्ट रेनशॉ

Answer 2

पायथन 3, 276 271 269 243 237 235 232 217 बाइट्स

@Sls perl सबमिशन से क्यू लेना ...

from unicodedata import*
o=[name(chr(k)).split(' ',2)[-1]for j in['①⑴','㉑㉠','㊱㋀']for k in range(ord(j[0]),ord(j[1]))]
i=input()
w=i in o
for i in range(w and o.index(i)+1or int(i)):print(w and i+1or o[i])

मुझे संदेह है कि इसे थोड़ा और आगे बढ़ाया जा सकता है।

यह unicodedataसंख्याओं के लिए नामों को देखने के लिए सिस्टम लाइब्रेरी का उपयोग करता है । इसमें FORTY TWOइनपुट के रूप में ऊपरी केस नंबर नामों (स्पेस से अलग :) या दशमलव पूर्णांक की आवश्यकता होती है ।

(यह मेरा पहला कोड गोल्फ सबमिशन है।)

(मैंने यह भी देखा कि मैं लंबाई (एन्कोडिंग) को मिस कर रहा था, इसलिए यह पहले की तुलना में कुछ बाइट्स कम है। मैंने केवल सबसे हालिया बाइट काउंट को ही अपडेट किया है।

Comments

PPCG में आपका स्वागत है!

— AdmBorkBork

वकालत में: unicodedataएक सिस्टम लाइब्रेरी है जो डिफ़ॉल्ट इंस्टॉलेशन के साथ आती है, न कि "अतिरिक्त" लाइब्रेरी जिसे अलग से इंस्टॉल करने की आवश्यकता होती है।

— उनायक

साइट पर आपका स्वागत है! आप अपने कोड से बहुत सारे स्थान हटा सकते हैं ।

— xnor

PPCG में आपका स्वागत है। आप एक forलूप के अंदर प्रिंट डालकर और प्रत्येक आउटपुट के बीच नए सिरे से 3 बाइट्स खो सकते हैं । print()परवाह नहीं है अगर यह एक पूर्णांक या एक स्ट्रिंग है। इसे ऑनलाइन आज़माएं!

— एलपीड्रो

मुझे लगता है कि आप बाइट के एक जोड़े को बचाने के import*बजाय कर सकते हैंimport name

— गेहूं जादूगर

Answer 3

आम लिस्प, 297 253 243 242 144 128

(lambda(s)(#1=dotimes(u(or(#1#(i 51)(if(equal(#2=format()"~R"i)s)(return i)))s))(#2#t"~[~:;, ~]~:[~R~;~D~]"u(stringp s)(1+ u))))

विवरण

(lambda (s) 
  (dotimes                         ; iterate...                                                                          
      (u                           ; for u from zero below ...                
       (or                         ; if s is a string, then                   
        (dotimes (i 51)            ;   parse s by iterating from 0 to 50      
          (if (equal               ;   until we find a match between          
               (format nil "~R" i) ;   the English word(s) for i              
               s)                  ;   and the given s                        
              (return i)))         ;   (exit loop)                            
        s))                        ; otherwise, use s, which is a number      
    (format t                      ; for each U, print to standard output     
            "~[~:;, ~]~:[~R~;~D~]" ; (see below for details)                  
            u                      ; ...                                      
            (stringp s)            ; ... arguments to format                  
            (1+ u))))              ; ...                                      

• ~[ 0 ~; 1 ~; ... ~:; else ~]एक स्विच है, जो अगले उपलब्ध तर्क के मूल्य पर आधारित है, जो उचित उप-नियंत्रण प्रारूप में कूदता है। यहां, मेरे पास केवल "0" और "और" के लिए एक मामला है। इसका उपयोग पहले नंबर को छोड़कर प्रत्येक संख्या से पहले एक विभाजक डालने के लिए किया जाता है, यू शून्य से शुरू होने के लिए।

• ~:[ FALSE ~; TRUE ~]एक सशर्त प्रारूप है; यहां हम चीजों को अलग तरीके से आउटपुट करते हैं कि इनपुट एस एक स्ट्रिंग है या नहीं।

• ~Rकार्डिनल अंग्रेजी नंबर के रूप में एक संख्या लिखें, जबकि ~Dबस संख्या को प्रिंट करता है।

उदाहरण

CL-USER> (test "five")
1, 2, 3, 4, 5

CL-USER> (test 32)
one, two, three, four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen, fourteen, fifteen, sixteen, seventeen, eighteen, nineteen, twenty, twenty-one, twenty-two, twenty-three, twenty-four, twenty-five, twenty-six, twenty-seven, twenty-eight, twenty-nine, thirty, thirty-one, thirty-two

Comments

मैं इस सवाल को समझता हूं, आपको दोनों शैलियों को पार्स करने में सक्षम होना चाहिए, न कि केवल एक, इसलिए आपके 55 बाइट समाधान मान्य नहीं हो सकते हैं। "आपके कार्यक्रम को दोनों को स्वीकार करने की आवश्यकता नहीं है" 25 बनाम "25" का जिक्र है, दशमलव एक संख्या के रूप में या एक स्ट्रिंग के रूप में।

— टॉम

@TomDevs धन्यवाद यह निश्चित रूप से भ्रमित करने वाला है। यह सुनिश्चित करने के लिए, अगर मैं fऐसा परिभाषित करता हूं कि "(f 2)" प्रिंट "एक, दो" और (f "two")"1, 2" प्रिंट करता है, तो क्या यह आपको अच्छा लगता है?

— coredump

हां, मुझे लगता है कि यह सही है।

— टॉम

@TomDevs धन्यवाद, मैंने इसे तय किया

— coredump

@AlbertRenshaw नहीं, केवल अंग्रेजी; इस सुविधा को पहले से ही ब्लोट माना जा सकता है, लेकिन चूंकि यह पहले से ही कुछ लिस्प्स में लागू किया गया था, इसलिए इसे मानकीकृत किया गया था।

— coredump

Answer 4

जावास्क्रिप्ट ईएस 6, 559 526 381 368 364 358 332 327 315 बाइट्स

a="one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve0thir10four10fif10six10seven10eigh10nine1".replace(/1/g,'teen').split(0),b="twenty0thirty0forty0fifty".split(0),c=(n,d=Array,e=b.forEach(i=>a=a.concat(i,a.slice(0,9).map(x=>i+x))))=>1/n?a.slice(0,n).join():d.from(d(a.indexOf(n)+1),(x,i)=>i+1).join();

1 / n चाल के लिए सरणी और अरनौलड को विभाजित करने के विचार के लिए क्रिस्सी लिथोस के लिए धन्यवाद।

a="one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve0thir10four10fif10six10seven10eigh10nine1".replace(/1/g,'teen').split(0),b="twenty0thirty0forty0fifty".split(0),c=(n,d=Array,e=b.forEach(i=>a=a.concat(i,a.slice(0,9).map(x=>i+x))))=>1/n?a.slice(0,n).join():d.from(d(a.indexOf(n)+1),(x,i)=>i+1).join();

console.log(c("twentyfive"));
console.log(c("fifty"));
console.log(c(50));

Comments

आप इसे हटा varसकते हैं और आप सरणी ['one,'two',..]को बदल सकते हैं"one0two0three0...".split(0)

— Kritii Lithos

निरर्थक व्हाट्सएप पर null, Array(n)।

— यति

आप !isNaN(n)द्वारा प्रतिस्थापित कर सकते हैं 1/n। यह आपको NaNएक स्ट्रिंग (मिथ्या), एक गैर-शून्य पूर्णांक के लिए एक गैर-शून्य पूर्णांक (सत्य), या Infinity0 के लिए (सत्य भी) देता है।

— अरनौलद

हर कोड लाइन के 4 रिक्त स्थान जोड़ें

— sagiksp

@sagiksp हाँ, पोस्ट एडिट करते समय कुछ गड़बड़ हो गई होगी, अब ठीक कर लेना चाहिए :)

— टॉम

Answer 5

पायथन 2 , 503 499 494 490 479 बाइट्स

-5 के साथ @JonathanAllan को धन्यवाद

l='one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#'.replace('#','teen ').split()
m='twenty','thirty','forty','fifty'
i,z,R=raw_input(),' ',range
try:n=int(i);p=(n/10)-2;o=(l+sum([[m[x]]+[m[x]+z+l[y]for y in R(9)]for x in R(p)],[])+[m[p]]+[m[p]+z+l[y]for y in R(n%10)],l[:n])[n<20]
except:j=i.split();o=map(str,R(1,(m.index(j[0])+2)*10+l.index(j[1])+2if z in i else l.index(i)+2if i in l else(m.index(i)+2)*10+1))
print','.join(o)

इसे ऑनलाइन आज़माएं!

इनपुट या तो एक संख्या या एक स्थान की एक अलग वर्तनी है।

थोड़ा कम गोल्फ वाला और अधिक पठनीय संस्करण:

l='one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen'.split()
m='twenty','thirty','forty','fifty'
i=raw_input()
try:
 n=int(i)
 if n<20:
  o=l[0:n]
 else:
  o=l
  for x in range((n/10)-2):
   o+=[m[x]]+[m[x]+' '+l[y]for y in' '*9]
  p=m[(n/10)-2]
  o+=[p]+[p+' '+l[y]for y in' '*n%10]
except:
 if' 'in i:
  t=i.split()
  s=((m.index(t[0])+2)*10)+l.index(t[1])+2
 else:
  s=l.index(i)+2 if i in l else((m.index(i)+2)*10)+1
 r=range(1,s)
 o=map(str,r)
print','.join(o)

Comments

6 बाइट के साथ बचाl="one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nin#".replace("#","teen ").split()

— जोनाथन एलन

... उफ़ 5, याद eसे nineteen।

— जोनाथन एलन

क्या कोई कारण है जिसे आपको पायथन 2 का उपयोग करने की आवश्यकता है, इसके बिना प्रिंट अधिक लंबा होगा, लेकिन रॉ_इनपुट सिर्फ इनपुट हो सकता है? (आपके अन्य उत्तर के लिए एक ही प्रश्न)

— nedla2004

@ nedla2004 - इसके अलावा और कोई कारण नहीं है कि मैंने अपने लेटेस्ट लैपटॉप पर पायथन 3 को स्थापित करने के लिए अभी तक राउंड नहीं लिया है :-)

— एलपेड्रो

Answer 6

योजना, 161 , 152 , 149

(define (c x)(let((r(string->number x)))(let l((i 1))(let((n (format #f "~r" i)))(display(if r n i))(newline)(or(eq? r i)(equal? x n)(l (+ i 1)))))))

असम्पीडित:

(define (count limit)
  (let ((numerical-limit (string->number limit)))
    (let l ((i 1))
      (let ((current-number (format #f "~r" i)))
        (display (if numerical-limit current-number i))
        (newline)
        (or (eq? numerical-limit i)
            (equal? limit current-number)
            (l (+ i 1)))))))

Comments

कैसे आप "चार" से 4 में परिवर्तित करते हैं? मुझे यकीन नहीं है कि मैंने string->numberऐसा किया है, मैंने जल्दी से जाँच की है और इसे स्ट्रिंग "4"से संख्या में परिवर्तित करने के लिए उपयोग किया जा रहा है 4।

— coredump

@ सही है कि सही है। (string->number "four")लौटता है #f।

— माइकल व्हील्स

आप कौन सी योजना चला रहे हैं?

— coredump

@ कॉर्डम्प गुइल 2.0.9

— माइकल

Answer 7

PHP - 397 372 349 344 329 बाइट्स

से प्रेरित टॉमडेव्स जेएस समाधान

द्वारा प्रतिस्थापित $a=[...]करके 25 बाइट्स सहेजे गए$a=explode(...)

स्ट्रिंग teenडेलिमिटर के बिना एक सरणी में वापस स्विच करके और एक चर में स्टोर करके एक और 23 बाइट्स सहेजे गए , धन्यवाद @ user59178

(int)टाइपकास्टिंग को हटाकर एक और 5 बाइट्स बचाए

छोड़ने से एक और 15 बाइट्स सहेजा $b, $iमें forकरने के लिए @ user59178 फिर घोषणाओं, और घुंघराले ब्रेसिज़, धन्यवाद

$a=[one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir.$t=teen,four.$t,fif.$t,six.$t,seven.$t,eigh.$t,nine.$t];foreach([twenty,thirty,forty,fifty] as$c){$a[]=$c;for($i=0;$i<9;)$a[]=$c.'-'.$a[$i++];}if($argv[1]!=0)for($i=0;$i<$argv[1];)echo$a[$i++].' ';else for($i=1;$i<=array_search($argv[1],$a)+1;)echo$i++.' ';

अधूरा:

$a =[one,two,three,four,five,six,seven,eight,nine,ten,eleven,‌​twelve,thir.$t=teen,‌​four.$t,fif.$t,six.$‌​t,seven.$t,eigh.$t,n‌​ine.$t];
foreach ([twenty,thirty,forty,fifty] as $c){
    $a[] = $c;
    for ($i=0;$i<9;)
        $a[] = $c . '-' . $a[$i++];
}
if( $argv[1] !=0 )
    for ($i=0;$i<$argv[1];)
        echo $a[$i++] . ' ';
else
    for ($i=1;$i<=array_search($argv[1], $a)+1;)
        echo $i++ . ' ';

इनपुट स्ट्रिंग के लिए या इनपुट नंबर के लिए इसे आज़माएं

Comments

जब गोल्फ आप किसी भी उद्धरण के बिना सीधे कई तार का उपयोग कर सकते हैं, जिसमें आपके द्वारा उपयोग किए जाने वाले सभी नंबर शामिल हैं। यह एक नोटिस का कारण बनता है लेकिन इसे नजरअंदाज किया जा सकता है। इसके अतिरिक्त यह teenहर बार दोहराने के बजाय एक चर में स्टोर करने के लिए कम (2 पूरे बाइट्स) है । जैसे कि यह बन जाएगा:$a=[one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir.$t=teen,four.$t,fif.$t,six.$t,seven.$t,eigh.$t,nine.$t];

— user59178

उस के बारे में सोचा नहीं था, धन्यवाद;)

— roberto06

आप 7 और बाइट्स को $bसीधे छोड़ सकते हैं और दूसरी सरणी को सीधे फॉर्च में डाल सकते हैं, 6 और बाइट्स को सभी घुंघराले ब्रेसिज़ को गिराकर (हालांकि आपको $a=$cलूप के सेटअप में डालने की ज़रूरत है ) और 6 और बाइट्स पोस्ट-इन्क्रीमेंटिंग द्वारा $iजब आप इसे छोरों के लिए 'आफ्टर बिट' के बजाय प्रयोग करते हैं।

— user59178

छह लाइन बाइट्स (दो प्रति लूप) को पोस्ट-इन्क्रीमेंट से निम्नलिखित पंक्ति में ले for ($i=0;$i<9;)$a[]=$c.'-'.$a[$i++];

— जाकर बचाएं

ओहो, क्षमा करें, अभी देखा कि @ user59178 ने एक ही बात का सुझाव दिया ...

— एलेक्स हावन्सकी

Answer 8

पायथन 2, 262 बाइट्स

x="one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#".replace("#","teen ").split()
x+=[a+"ty"+b for a in"twen","thir","for","fif"for b in['']+x[:9]]
v=input()
for s in range(1,x.index(v)+2)if v>50else x[:v]:print s

repl.it

इनपुट और आउटपुट स्ट्रिंग्स लोअर केस और कॉन्सेटेनेटेड * होते हैं, इसलिए एक स्ट्रिंग इनपुट एंटर को टेस्ट करने के लिए, उदाहरण के लिए, "thirtyfive"प्रॉम्प्ट पर।

सभी शब्दों की सूची बनाता है (प्लस "fiftyone"से "fiftynine"), xफिर परीक्षण करता है कि inputक्या प्रॉक्सी के साथ एक शब्द है v>50(स्ट्रिंग पायथन 2 में संख्या से अधिक है, और विनिर्देश से वैध इनपुट रेंज में सभी संख्याएं हैं <=50) और printउपयुक्त है मानों की सूची को कम करके x[:v], या पूर्णांकों की एक सीमा का निर्माण करके range(1,x.index(v)+2),।

* 11 बाइट्स दोनों लागत पर हायफ़नेशन जोड़ा जा रहा है, की जगह a+"ty"bके साथ a+"ty"+'-'*(b>'')+b।

Answer 9

वोल्फ्राम भाषा, 92 बाइट्स

If[NumberQ@#, Do[Print@IntegerName@i, {i, #}], 
  Do[Print@i, {i, Interpreter["SemanticNumber"]@#}]] &

(मैं इसके लिए नया हूं, मुझे बताएं कि क्या मैंने कुछ गलत किया है)

Comments

-10 बाइट्स:Do[Print@If[#>0,i,,IntegerName@i],{i,If[#>0,#,,Interpreter["SemanticNumber"]@#]}]&

— जुंगह्वान मिन

Answer 10

जावास्क्रिप्ट (ईएस 6), 261 बाइट्स

नोट: z को निर्दिष्ट स्ट्रिंग के साथ एन्कोड किया गया है atob। एन्कोडेड स्ट्रिंग में 11 बाइट्स होते हैं जिन्हें मैं इस साइट पर पोस्ट नहीं कर सकता, भले ही वे जावास्क्रिप्ट स्ट्रिंग में मान्य वर्ण हों। इसलिए मैंने फॉर्म \ xHH में हेक्स एस्केप का उपयोग किया। इनमें से हर एक भाग को 1 बाइट के रूप में गिना जाता है।
मूल असम्पीडित स्ट्रिंग कम गोल्फ वाला संस्करण है।

x=>(z=btoa('ö\x89ÞöÜ(öØkyï_¢êý~+Þöȱöǯz\x7f^\x8a\x08möx§{Û^\x9f×¥z÷§öÜ\x1e\x96÷½¶\x18«÷×â\x7fß}z(!÷Ûpz\x7f}~\x8aý').split(9),o=(0+z.map((v,i)=>i<20?i<13?v:(v||z[i-10])+'teen':z.slice(0,10).map(d=>(z[i]||z[i-8]||z[i-18])+'ty'+d))).split`,`,p=o.indexOf(x),o.slice(1,-~x+p+!~p).map((x,i)=>~p?i+1:x))

कम गोल्फ वाला

x => (
  z = '9one9two9three9four9five9six9seven9eight9nine9ten9eleven9twelve9thir99fif999eigh99twen99for9'
      .split(9),
  o = (0 + // 0 + array to build a comma separated string
       z.map( (v, i) => 
         i < 20 
         ? i < 13 
           ? v // 1 to 13 are 'as is'
           : (v||z[i-10])+'teen' // compose for 14 to 19
         : z.slice(0,10).map(d=>(v||z[i-8]||z[i-18])+'ty'+d)) // 20s, 30s, 40s, 50s
      ).split`,`, // from comma separated to array again
  // o contains strings from one to fiftynine
  p = o.indexOf(x), // look for input
  o.slice(1, -~x+p+!~p).map((x,i) => ~p?i+1:x)
)

परीक्षा

F=
x=>(z=btoa('ö\x89ÞöÜ(öØkyï_¢êý~+Þöȱöǯz\x7f^\x8a\x08möx§{Û^\x9f×¥z÷§öÜ\x1e\x96÷½¶\x18«÷×â\x7fß}z(!÷Ûpz\x7f}~\x8aý').split(9),o=(0+z.map((v,i)=>i<20?i<13?v:(v||z[i-10])+'teen':z.slice(0,10).map(d=>(v||z[i-8]||z[i-18])+'ty'+d))).split`,`,p=o.indexOf(x),o.slice(1,-~x+p+!~p).map((x,i)=>~p?i+1:x))

function update() {
  var i=I.value
  O.textContent = F(i)
}  

update()

<input id=I value=25 oninput='update()'><pre id=O></pre>

Comments

ö\x89ÞöÜ(öØ...यह सामान महान हाहा है

— अल्बर्ट रेनशॉ

: अपने शीर्ष टिप्पणी के लिए प्रासंगिक meta.stackoverflow.com/questions/342546/...

— अल्बर्ट रेंशाव

Answer 11

पायथन 3 , 305 303 बाइट्स

@ Nedla2004 से सलाह के बाद अजगर 3 में परिवर्तित। अब इनपुट या आउटपुट पर लिखित संख्याओं के बीच कोई स्थान नहीं है जैसे कि twentytwo दर्ज करें

l='one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#'.replace('#','teen ').split()
m='twenty','thirty','forty','fifty'
i,R=input(),range
l+=sum([[m[x]]+[m[x]+l[y]for y in R(9)]for x in R(3)],[])
for x in R(1,l.index(i)+2)if i in l else l[:int(i)]:print(x)

यह ऑनलाइन 3 की कोशिश करो!

पायथन 2 , 327 320 313 308 बाइट्स

l='one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#'.replace('#','teen ').split()
m='twenty','thirty','forty'
i,R=raw_input(),range
l+=sum([[m[x]]+[m[x]+l[y]for y in R(9)]for x in R(3)],[])+['fifty']
for x in R(1,l.index(i)+2)if i in l else l[:int(i)]:print x

यह ऑनलाइन 2 की कोशिश करो!

163 170 177 बाइट्स मेरे मूल उत्तर से कम हैं इसलिए मैं इसे एक विकल्प के रूप में पोस्ट कर रहा हूं। यह forसंख्याओं के सभी स्ट्रिंग निरूपणों की पूरी सूची बनाने के लिए दो सूचियों का उपयोग करता है, फिर सूची में सही एक को पहचानता है और मूल्य या सूचकांक के आधार पर सब कुछ प्रिंट करता है। प्रत्येक मान के लिए एक नई लाइन आउटपुट करता है।

Answer 12

पायथन 2, 432 422 416 403 बाइट्स

मुझे यकीन है कि इस पर सुधार किया जा सकता है। बहुत कम से कम यदि मैं हार्डकोडिंग के साथ काम कर सकता हूं, तो उस पर काम करने के लिए मान की जरूरत नहीं है और न ही किसी फ़ंक्शन की आवश्यकता है जिसे मैं 20 बचा सकता हूं। पाठ इनपुट में शब्दों को अलग करने के लिए स्थान की आवश्यकता होती है। ElPedro के जवाब पर JonathanAllan की टिप्पणी के लिए 6 बाइट्स को धन्यवाद दिया गया, गणित को पुनर्व्यवस्थित करने के लिए 4।

def z(f):
 a,b,i,d="one two three four five six seven eight nine ten eleven twelve thir#four#fif#six#seven#eigh#nine#".replace("#","teen ").split()+[""],"twenty thirty forty fifty".split(),1,f>50
 if d:f=f.split();f=a.index(f[-1])+21+b.index(f[-2])*10 if len(f)>1 else b.index(f[-1])*10+20 if f[-1]in b else a.index(f[-1])+1
 while i<=f:s=i if d else a[i-1]if i<20 else b[i//10-2]+a[i%10-1];print s;i+=1

(NB: इसका वास्तविक संस्करण रिक्त स्थान के बजाय इंडेंट करने के लिए टैब का उपयोग करता है। QPaysTaxes ने एक एकल स्थान जोड़ा क्योंकि यह ठीक से रेंडर नहीं कर रहा था, यह सुनिश्चित करने के लिए कि दिए गए कोड संकलित करते हैं। यह बाइट काउंट को नहीं बदलना चाहिए।)

Comments

@ ElPedro के जवाब पर जोनाथनअल्लन की टिप्पणी यहाँ भी काम करती है -6

— क्रिस एच।

len(`f`)>2...`f`[2:]एक और 3 के लिए हो सकता है मुझे विश्वास है। ( ...बैकस्टिक्स को ठीक से काम करने के लिए अनदेखा नहीं कर सकते हैं)

— जोनाथन एलन

वास्तव में अजगर 2 में आप f>506. के लिए जा सकते हैं (और उपयोग न करके एक और d)

— जोनाथन एलन

@JonathanAllan जो पूर्णांक के रूप में संख्याओं को पारित करने के लिए काम नहीं करता है, जो मैं वर्तमान में करता हूं TypeError: 'int' object has no attribute '__getitem__':। यदि मैं संख्यात्मक इनपुट को एक स्ट्रिंग के रूप में पास करता हूं, तो पास f[2:]हो जाता है , लेकिन फिर भी फेल हो जाता है जब एक बूलियन के रूप में विभाजित किया जाता है ( print f[2:] and Trueयदि रिक्त पंक्ति को लेन (f) <2, नहीं Trueया नहीं False)

— क्रिस एच

@JonathanAllan f>50काम करता है, धन्यवाद। छोड़ना dइतना सरल नहीं है क्योंकि मैं हमेशा लूप के अंतिम मूल्य को f8 पंक्ति में रखता हूं, if f>50इसे बदला नहीं जा सकता क्योंकि यह कभी भी सच नहीं होगा।

— क्रिस एच

Answer 13

सी ++ 11, 484 480 477 बाइट्स

#import<iostream>
#import<cstdlib>
#import<vector>
using namespace std;f(){int j,i=2;string s="teen";vector<string>v={"","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve"};for(;i++<9;)v.push_back(v[i]+s);v[13]="thir"+s;v[15]="fif"+s;v[18]="eigh"+s;for(i=19;i++<50;){string n[4]={"twenty","thirty","forty","fifty"};v.push_back(n[i/10-2]+v[i%10]);}cin>>s;if(i=atoi(s.c_str()))for(j=0;j++<i;)cout<<v[j]<<" ";else while(v[i++]!=s)cout<<i<<" ";}

हाइफ़न के बिना निचले मामले में पाठ इनपुट।

Answer 14

पॉवरशेल , 362 बाइट्स

$z=0..50|%{("0twenty0thirty0forty0fifty"-split0)[+(($b="$_"[0])-gt49)*($_-gt19)*(+"$b"-1)]+($x=(("0one0two0three0four0five0six0seven0eight0nine0ten0eleven0twelve"-split0)+(-split'thir four fif six seven eigh nine'|%{$_+'teen'})))[($_%10)*($_-gt19)]+$x[$_*($_-le19)]}
if(($n=-split$args)[0][0]-in48..57){$z[$n[0]..$n[2]]}else{$z.IndexOf($n[0])..$z.IndexOf($n[2])}

इसे ऑनलाइन आज़माएं! शब्द इनपुट या संख्या इनपुट

यह एक सही गड़बड़ है, और मैं इससे बहुत खुश नहीं हूँ, लेकिन यहाँ यह है। गोल्फ सुझाव का स्वागत करते हैं।

पहली पंक्ति $zमें पूर्ण अंग्रेजी शब्दों की एक सरणी है। आप -split0संख्याओं के 1लिए 12, और लूप को सभी teens के निर्माण के लिए देख सकते हैं , और फिर सब कुछ ठीक करने के लिए तर्क का एक गुच्छा है। इसे ऑनलाइन आज़माएं!

दूसरी पंक्ति कुछ तर्क से शुरू होती है। हम इनपुट लेने $args(एक स्ट्रिंग के रूप में), -splitखाली स्थान के पर, में संग्रहीत $nबाद में, उपयोग के लिए पहले ले [0]शब्द है, और पहले [0]इस बात का चरित्र है, और अगर यह होता है की जाँच -inएक सीमा 48..57(यानी, ASCII 0करने के लिए 9)। इसलिए, हम जाँच रहे हैं कि क्या हमारे पास दशमलव इनपुट या अंग्रेजी इनपुट है। इसे ऑनलाइन आज़माएं!

पहले मामले में, हम दशमलव इनपुट के आधार पर एक सीमा बनाते हैं $n[0]..$n[2]और उस अनुक्रम में इसका उपयोग करते हैं $z[...]। दूसरे मामले में, हम .indexOf()पहले शब्द और अंतिम शब्द को खोजते हैं, और उस से सिर्फ एक संख्यात्मक सीमा बनाते हैं। या तो स्थिति में, अब हमारे पास पाइपलाइन (या तो तार या पूर्णांक) पर वस्तुओं की एक सरणी है, और Write-Outputकार्यक्रम पूरा होने पर एक निहितार्थ हमें तत्वों के बीच एक नई रेखा देता है।

Answer 15

स्विफ्ट 3, 402 बाइट्स

let f=["one","two","three","four","five","six","seven","eight","nine"]
let g=["twenty","thirty","forty","fifty"]
let v=[f,["ten","eleven","twelve"],["thir","four","fif","six","seven","eigh","nine"].map{$0+"teen"},[g[0]],f.map{g[0]+$0},[g[1]],f.map{g[1]+$0},[g[2]],f.map{g[2]+$0},[g[3]]].flatMap{$0}
func c(s:String){if let i=Int(s){print(v.prefix(upTo:i))}else{for j in 1...v.index(of:s)!+1{print(j)}}}

Ungolfed:

let f = ["one","two","three","four","five","six","seven","eight","nine"]
let g = ["twenty","thirty","forty","fifty"]

let values = [f,["ten","eleven","twelve"],["thir","four","fif","six","seven","eigh","nine"].map{$0+"teen"},
              [g[0]], f.map{g[0]+$0},
              [g[1]], f.map{g[1]+$0},
              [g[2]], f.map{g[2]+$0},
              [g[3]]].flatMap{$0}

func count(s:String){
    if let i = Int(s) {
        print(values.prefix(upTo: i))
    } else {
        for j in 1...values.index(of: s)!+1{
            print(j)
        }
    }
}

count(s:"29")
count(s:"twentyeight")

यहां कुछ भी विशेष नहीं है, बस लिखित संख्याओं का बैकअप लेने के लिए एक सरणी का उपयोग करना है।

मैंने मूल रूप से इस समाधान का उपयोग valuesसरणी की गणना करने के लिए इस अन्य तरीके से सोचा था :

let values = f + ["eleven","twelve"]
    + ["thir","four","fif","six","seven","eigh","nine"].map{$0+"teen"}
    + [g[0]] + f.map{g[0]+$0}
    + [g[1]] + f.map{g[1]+$0}
    + [g[2]] + f.map{g[2]+$0}
    + [g[3]]

जिस पर गोल्फ किया जा सकता है:

let v=f+["eleven","twelve"]+["thir","four","fif","six","seven","eigh","nine"].map{$0+"teen"}+[g[0]]+f.map{g[0]+$0}+[g[1]]+f.map{g[1]+$0}+[g[2]]+.map{g[2]+$0}+[g[3]]

गोल्‍ड कोड में तीसरी पंक्ति की जगह

मैं 381 बाइट्स बना सकता था, लेकिन, एक संकलक त्रुटि है जो कहती है: "उचित समय में हल करने के लिए अभिव्यक्ति बहुत जटिल थी", त्रुटि पर अधिक जानकारी यहां पाई जा सकती है

Comments

यहाँ तेजी से देखकर प्यार करता हूँ, जब मैं वापस आता हूँ तो मुझे इसे और अधिक देखना होगा

— अल्बर्ट रेनशॉ

Answer 16

आर, 452 430 424 बाइट्स

o=c("","one","two","three","four","five","six","seven","eight","nine") 
t=gsub(0,"teen",c("ten","eleven","twelve","thir0","four0","fif0","six0","seven0","eigh0","nine0"))
s=c("twenty","thirty","forty") 
p=""
for(i in s){for(j in o){p=paste0(p,i,j," ")}}
as.data.frame(t(d<-1:50))
names(d)=c(o[-1],t,as.vector(strsplit(p," ")[[1]]),"fifty")
f=function(x){if(is.numeric(x)){names(d)[1:x]}else{matrix(d[1:d[x]],dimnames=NULL)}}

#> f(5)
#[1] "one"   "two"   "three" "four"  "five" 

#> f('five')
#     [,1]
#[1,]    1
#[2,]    2
#[3,]    3
#[4,]    4
#[5,]    5

कॉलम नाम के रूप में लिखित-आउट संख्याओं के साथ डेटा.फ्रेम में संख्याओं को रखता है, जिससे दोनों के बीच अनुवाद (और बाद में मुद्रण) बहुत आसान हो जाता है।

गोल्फिंग में मुख्य प्रयास 20-49 के लिए लिखित-आउट संख्या बनाने में था, शायद यहां गोल्फ के लिए और अधिक।

मैंने as.matrixडेटा के साथ प्रिंट करने का प्रयास किया था। केवल संख्याओं के साथ फ़िक्स करें, लेकिन अभी भी मैट्रिक्स हेडर के साथ बचा हुआ है। उम्मीद है कि ठीक है।

Ungolfed:

ones <- c("","one","two","three","four","five","six","seven","eight","nine") 
teens <- c("ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen")
tens <- c("twenty","thirty","forty") 

p=""
for(i in tens){
  for(j in ones){
    p=paste0(p, i, j," ")
  }
}

nums <- 1:50
as.data.frame(t(nums))
names(nums) <- c(ones[-1], teens, as.vector(strsplit(p, " ")[[1]]), "fifty")
f <- function(x){
  if(is.numeric(x)){
    names(nums)[1:x]
  } else {
    matrix(nums[1:nums[x]], dimnames = NULL)
  }
}

Comments

359 बाइट्स के लिए थोड़ा सा सुधार:o=c("","one","two","three","four","five","six","seven","eight","nine") ; v=c("ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"); w=c("twenty","thirty","forty"); a=data.frame(0:50, c(o,v, sapply(w[1:3],function(y) sapply(o,function(x) paste0(y,x))),"fifty")); b=which(a==i); a[if(b<52) 2:b else 2:(b-51),ifelse(b<52,2,1)]

— गिनती

@ एक बड़ा सुधार जैसा दिखता है! मुझे यह पता नहीं लग सकता है कि फ़ंक्शन कहाँ है, हालाँकि, या जहाँ आप एक तर्क लेंगे।

— BLT

Answer 17

सी, 342 331 बाइट्स

char*x[]={"teen","one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thir","four","fif","twenty","thirty","fourty","fifty"};void main(int z,char**i){for(z=1;z<=atoi(i[3]);z++)printf("%s%s%s\n",z<16?x[z]:z<20?z^18?x[z-10]:"eigh":x[z/10+14],z>20&&z%10?"-":z>12&&z<20?*x:"",z>20&&z%10?x[z%10]:"");}

इसे ऑनलाइन आज़माएं!

Comments

मेरी पसंदीदा भाषा :)

— अल्बर्ट रेनशॉ

आपको वास्तव में 1 या एक थ्रू की आवश्यकता नहीं है; इस सभी कोडगॉल्फ को आपके तीसरे तर्क की आवश्यकता है। पहले दो हमेशा "1 और थ्रू" (या "एक और थ्रू") होंगे

— अल्बर्ट रेनशॉ

@AlbertRenshaw अच्छी कॉल! धन्यवाद :)

— अहमोन

Answer 18

एसएएस, 179

%macro c(n);%let f=words.;%if%length(&n)>2%then%do;%do c=1%to 50;%if%qsysfunc(putn(&c,&f))=&n%then%let n=&c;%end;%let f=2.;%end;%do i=1%to &n;%put%sysfunc(putn(&i,&f));%end;%mend;

आउटपुट को newlines द्वारा अलग किए गए लॉग को लिखा जाता है। एसएएस में अंकों को शब्दों में बदलने के लिए एक अंतर्निहित प्रारूप है, जो इस चुनौती के लिए एक बड़ा लाभ है, लेकिन झुंझलाहट में इसके विपरीत करने के लिए एक सूचना का अभाव है।