... साधारण संख्याएँ (या क्रमांक) क्रमिक क्रम में स्थिति या पद का प्रतिनिधित्व करने वाले शब्द हैं।

से विकिपीडिया ।

आपका कार्य 2 अलग-अलग कार्यक्रमों (जिनमें से 2 अलग-अलग भाषाओं से बनाया जा सकता है) का उपयोग करके, पहले से क्रमिक अनुक्रम का उत्पादन करना है nth। आप पूर्ण शब्द का secondविरोध करते हुए आउटपुट करेंगे 2nd।

विशेष रूप से इस प्रविष्टि में, क्रमिक संख्याओं की चुनौती को पहले लाया गया है । इस चुनौती में, नीचे दिए गए अद्वितीय परिस्थितियों को सुविधाजनक बनाने के लिए, अध्यादेश केवल एक वाहन हैं।

भाग 1

आपको एक प्रोग्राम बनाना चाहिए, जब कुछ भीn आउटपुट करना चाहिए । हमेशा एक सकारात्मक, गैर-शून्य पूर्णांक 999 से बड़ा नहीं होगा।
n

मान्य उत्पादन में शामिल हैं, लेकिन यह तक सीमित नहीं है :

stdout/ stderr/ आदि के लिए कोई भी उत्पादन
फ़ाइलों / फ़ोल्डरों / आदि का निर्माण
एक चित्रमय इंटरफ़ेस या किसी भी प्रकार की छवियां

कुछ भी हो जाता।

भाग 2

आपको एक प्रोग्राम बनाना चाहिए जो कि भाग 1 के कार्यक्रम के आउटपुट का उपयोग करता है, क्रमिक संख्याओं के अनुक्रम को आउटपुट करने के लिए, 1 (पहले) से शुरू होता है, जो nकि भाग 1 में पार्स किया गया था।

सामान्य परिस्थितियां:

भाग 2 के लिए कुल बाइट्स भाग 1 (कम से कम या बराबर) के लिए कुल बाइट्स से अधिक नहीं होनी चाहिए।

उत्पादन की स्थिति:

केस - संवे्दनशील नहीं।
आउटपुट में केवल क्रमिक अनुक्रम (केवल वर्ण aZ) और व्हाट्सएप (अनुमति दी गई newlines) होनी चाहिए।
किसी भी स्रोत के लिए आउटपुट किया जा सकता है, इसलिए जब तक यह निष्पादन के दौरान या बाद में दिखाई देता है।
कार्यक्रम को तब तक समाप्त करने की आवश्यकता नहीं है जब तक कि उसका आउटपुट सही न हो।
किसी भी व्याकरण के लिए आउटपुट की आवश्यकता नहीं है, लेकिन वैकल्पिक रूप से इसे शामिल कर सकते हैं (हाइफ़न, कॉमा, "और", आदि)। nine hundred ninety ninthबस के रूप में स्वीकार्य है nine hundred and ninety-ninth।

नमूना आउटपुट

जहां n8 है

FIRST SECOND THIRD FOURTH FIFTH SIXTH SEVENTH EIGHTH

स्कोरिंग

जीत की स्थिति की पदानुक्रम है:

भाग 1 में बाइट्स की सबसे कम संख्या

भाग 2 में बाइट्स की सबसे कम संख्या

Entry #1 | Part 1 = 32 bytes, Part 2 = 22 bytes
Entry #2 | Part 1 = 31 bytes, part 2 = 30 bytes

Entry #2 wins - Part 1 contains 31 bytes vs 32 bytes

---

Entry #1 | Part 1 = 21 bytes, Part 2 = 33 bytes
Entry #2 | Part 1 = 80 bytes, Part 2 = 70 bytes

Entry #2 wins - Entry #1 disqualified (Part 2 contains more bytes than Part 1)

---

Entry #1 | Part 1 = 50 bytes, Part 2 = 49 bytes
Entry #2 | Part 1 = 50 bytes, Part 2 = 50 bytes

Entry #1 wins - Part 1 is equal, Part 2 contains 49 bytes vs 50 bytes

code-golf

— BDM
स्रोत

5

भाग 1 में क्या बात है (जैसा कि, यह चुनौती सिर्फ भाग 2 के लिए कम से कम प्रस्तुत करने पर क्यों नहीं हो सकती है)? इसके अलावा, आपके दूसरे स्कोरिंग उदाहरण में, पहली प्रविष्टि अमान्य नहीं है (भाग 2> भाग 1), और यदि नहीं, तो क्या यह दूसरी प्रविष्टि को नहीं हराएगा? इसके अलावा, मैं अध्यादेशों को परिभाषित करने के लिए एक औपचारिक नियम के लिए कम से कम एक लिंक होने की सलाह देता हूं; उदाहरण के लिए, 111 one hundred and eleventhया कहने वाला है one hundred eleventh?

— हाइपरएनुट्रीनो

3

@HyperNeutrino मुझे लगता है कि विचार समान रूप से संभव के रूप में दोनों के बीच काम विभाजित करने के लिए है, जबकि गोल्फ की कोशिश करना है - अगर मैं p1 उत्पादन [30, 'second']के लिए 32तो p2 कम काम करने के लिए है अगर यह उत्पादन किया था, बस 32।

— जोनाथन एलन

4

शायद मुझे कुछ बेवकूफी याद आ रही है, लेकिन स्कोरिंग उदाहरणों में अंतिम दो प्रविष्टियों में से, 1 जीत क्यों दर्ज नहीं करता है? भाग 1 में एक ही बाइट्स है, भाग 2 दोनों के लिए भाग 1 से कम या बराबर है, और प्रविष्टि 1 भाग 2 में 2 भाग 2 से कम बाइट्स हैं।

— पैट्रिक रॉबर्ट्स

@PatrickRoberts क्योंकि भाग 2 में भाग 1 के बराबर या कम बाइट्स होने चाहिए । चूंकि भाग 1 21 बाइट्स है, लेकिन भाग 2 33 बाइट्स है, प्रविष्टि # 1 अयोग्य है। दुर्भाग्य से, उस जानकारी को हटा दिया गया है और इस समय स्पष्ट रूप से जीत की स्थिति में नहीं बताया गया है।

— क्रोनोसाइडल जूल

@PatrickRoberts यह महत्वपूर्ण है, क्योंकि अन्यथा आप एक ऐसी भाषा का उपयोग कर सकते हैं जो अंतर्निहित रूप से इनपुट को आउटपुट के रूप में

— लेती है,

14

स्लेजहैमर 0.5.1 / स्लेजहैमर 0.5.1, 10 बाइट्स

कार्यक्रम 1 (10 बाइट्स):

⣘⢷⠾⣃⢖⣎⢅⡨⠱⢳

इस वुल्फराम भाषा समारोह में शामिल हैं:

{Range[#1], "Ordinal"} &

कार्यक्रम 2 (7 बाइट्स):

⡾⡁⢚⣷⣬⠤⣾

इस वुल्फराम भाषा समारोह में शामिल हैं:

StringRiffle[IntegerName @@ #1, " "] &

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

— lirtosiast
स्रोत

9

आर ( `english`पैकेज के साथ ), 16 बाइट्स / 16 बाइट्स

भाग 1, 16 बाइट्स

f=function(n)1:n

भाग 2, 16 बाइट्स

english::ordinal

englishपैकेज की आवश्यकता है (जो टीआईओ पर स्थापित नहीं है, दुर्भाग्य से)।

english::ordinal(f(22))आउटपुट first second third fourth fifth sixth seventh eighth ninth tenth eleventh twelfth thirteenth fourteenth fifteenth sixteenth seventeenth eighteenth nineteenth twentieth twenty first twenty second।

बेशक, भाग 1 को बहुत कम किया जा सकता है (3 बाइट्स:) seq, लेकिन यह बाधा के खिलाफ जाएगा कि भाग 2 को अब भाग 1 से अधिक नहीं होना चाहिए।

— रॉबिन राइडर
स्रोत

@ गुइसेपे ज़रूर। हालांकि मैं तर्क दूंगा कि CRAN पैकेज R का हिस्सा हैं, और जब तक हम उन्हें लोड करने और संलग्न करने के लिए आवश्यक वर्णों को गिनते हैं, तब तक उन्हें अनुमति दी जानी चाहिए।

— रॉबिन राइडर

मेरा मानना है कि मेटा सर्वसम्मति यह है कि बाहरी पुस्तकालय का उपयोग अनिवार्य रूप से "दूसरी भाषा" के रूप में होता है; उदाहरण के लिए इस पोस्ट को देखें जो संकलक झंडे के बारे में है, लेकिन पायथन बाहरी पुस्तकालयों के बारे में एक नोट है। यहाँ उत्तर कई उदाहरणों के साथ शिक्षाप्रद है लेकिन मैं निश्चित विवरण को खोजने के लिए मेटा पर खोज फ़ंक्शन का उपयोग नहीं कर सकता।

— ग्यूसेप

@Giuseppe चैट में जारी है: chat.stackexchange.com/transcript/message/51052875#51052875

— रॉबिन राइडर

8

वोल्फ्राम भाषा (गणितज्ञ) (दोनों भाग), १ Language बाइट्स / १५ बाइट्स

-5 / -1 के लिए धन्यवाद lirtosiast

भाग 1, 18 बाइट्स

Range@#|"Ordinal"&

भाग 2, 15 बाइट्स

IntegerName@@#&

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

दो कार्य जो रिटर्न वैल्यू के माध्यम से आउटपुट करते हैं।

— attinat
स्रोत

2

Range@#|"Ordinal"&छोटा है, और IntegerNameपहले तर्क पर वेक्टर करता है। मुझे लगता है कि अंतरिक्ष-अलग आउटपुट की आवश्यकता हो सकती है, हालांकि।

— lirtosiast

4

पायथन 3 (भाग 1 और भाग 2)

दुर्भाग्य से Nodebox बहुत चिंताजनक है ... गोल्फिंग के लिए बहुत जगह नहीं है।

भाग 1 76 बाइट्स

for  i  in  range  (  1 ,  int  (  input  (  ) ) + 1 ) : print ( i ,end=" ")

भाग 2 ( NodeBox लाइब्रेरी का उपयोग करता है ) 76 बाइट्स

import en.number as n
for i in input().split():print(n.ordinal(n.spoken(i)))

— ए
स्रोत

5

आपका उत्तर मान्य होना चाहिए; इस स्थिति में, आपका भाग 2 आपके भाग 1 से अधिक लंबा है, जो अमान्य है। आप एक उत्तर को "गैर-प्रतिस्पर्धा" के रूप में चिह्नित नहीं कर सकते हैं और एक अवैध जमा प्रस्तुत कर सकते हैं; "नॉन-कॉम्पिटिशन" लेबल उन भाषाओं या भाषा संस्करणों में प्रस्तुत चुनौतियों के लिए एक पदावनत किया गया लेबल है जो चुनौती को स्थगित करते हैं, जिसे आमतौर पर अस्वीकृत किया जाता था, लेकिन दिलचस्प सबमिशन के लिए "गैर-प्रतिस्पर्धात्मक" स्थिति के तहत अनुमति दी जाती थी।

— हाइपरएनुट्रीनो

1

@HyperNeutrino क्षमा करें, मुझे लगा कि भाग 2 की अपेक्षा नियमों को भाग 2 से छोटा होना चाहिए। मैंने इसे गैर-प्रतिस्पर्धा के रूप में चिह्नित किया क्योंकि इस समस्या को हल करने के लिए इसने एक पुस्तकालय का उपयोग किया।

— A

2

तकनीकी रूप से, बाहरी पुस्तकालयों का उपयोग करना ठीक लगता है: codegolf.meta.stackexchange.com/q/188

— जोनो 2906

1

import en.number as nआपको प्रत्येक भाग में चार बाइट्स बचाता है।

— खुल्द्रेसथ ना'बरिया

1

जावास्क्रिप्ट (Node.js), 47 बाइट्स / 47 बाइट्स

एक ही Node.js वातावरण में दो कार्य, जैसे किए गए g(f(n))। Npm पैकेज नंबर-से-शब्दों का उपयोग करता है ।

भाग 1, 47 बाइट्स (40 बाइट्स + 7 स्थान)

n=>H=>{for(i=0;i<n;)console.log(H(++i))}

भाग 2, 47 बाइट्स

F=>F(require("number-to-words").toWordsOrdinal)

इसे Runkit पर आज़माएं!

जावास्क्रिप्ट (Node.js), 48 बाइट्स / 43 बाइट्स

भाग 1, 48 बाइट्स

n=>[n,require("number-to-words").toWordsOrdinal]

भाग 2, 43 बाइट्स

([n,F])=>{for(i=0;i<n;)console.log(F(++i))}