43

मैं संख्या के लिए एक सकारात्मक पूर्णांक के क्रमिक प्रत्यय को उत्पन्न करना चाहता हूं (किसी फ़ंक्शन के वापसी परिणाम के रूप में, या बस एक कार्यक्रम के आउटपुट के रूप में) ।

नमूने:

1st  
2nd  
3rd  
4th  
...  
11th  
12th  
13th  
...  
20th  
21st
22nd
23rd
24th

और इसी तरह, प्रत्यय के साथ हर 10 में 100 तक शुरुआती 1-10 उपपट्ट को दोहराते हैं, जहां पैटर्न अंततः शुरू होता है।

इनपुट संख्या और आउटपुट होगा जैसा कि ऊपर दिखाया गया है।

इसके लिए सबसे छोटा एल्गोरिदम क्या है?

code-golf string number

— निकोल
स्रोत

हाय, NickC, और codegolf.SE में आपका स्वागत है! बस स्पष्ट करने के लिए, क्या आपका मतलब है कि हमें एक नंबर पढ़ना चाहिए जैसे 11इनपुट, और आउटपुट उदा 11th? क्या प्रत्येक संख्या एक अलग रेखा पर इनपुट में है, और क्या आउटपुट संख्या अलग-अलग रेखाओं पर भी होनी चाहिए? और क्या हमें इनपुट की एक से अधिक लाइन को संभालने की आवश्यकता है?

— इल्मरी करोनें

1

क्या आप सबसे छोटे एल्गोरिथ्म या सबसे छोटे कोड की तलाश कर रहे हैं?

— टोटो

@ इल्मारी मैं 11इनपुट और 11thआउटपुट के रूप में देख रहा हूँ । अगर यह कई लाइनों को संसाधित करता है, तो मुझे कोई आपत्ति नहीं है, लेकिन मेरे मन में जो कुछ था वह सिर्फ एक संख्या को संसाधित करता था।

— निकोल

@ M42 तुम्हें पता है, मुझे यकीन नहीं है। मुझे सख्त आवश्यकता नहीं है - लेकिन मैं शायद सबसे छोटी एल्गोरिथ्म सोच रहा था।

— निकोल

30

पर्ल, 37 + 1 वर्ण

s/1?\d\b/$&.((0,st,nd,rd)[$&]||th)/eg

यह एक regexp प्रतिस्थापन है जो किसी भी संख्या में उपयुक्त क्रमिक प्रत्यय को जोड़ता है जो $_पहले से ही एक पत्र द्वारा पीछा नहीं किया जाता है। इसे फ़ाइल इनपुट पर लागू करने के लिए, pकमांड लाइन स्विच का उपयोग करें, जैसे:

perl -pe 's/1?\d\b/$&.((0,st,nd,rd)[$&]||th)/eg'

यह एक पूर्ण पर्ल प्रोग्राम है जो स्टडिन से इनपुट पढ़ता है और संसाधित आउटपुट को स्टडआउट में लिखता है। वास्तविक कोड 37 वर्ण लंबा है, लेकिन pस्विच एक अतिरिक्त चरित्र के रूप में गिना जाता है ।

नमूना इनपुट:

This is the 1 line of the sample input...
...and this is the 2.
1 2 3 4 5 6 7 8 9 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
101 102 103 104 105 106 107 108 109 110

आउटपुट:

This is the 1st line of the sample input...
...and this is the 2nd.
1st 2nd 3rd 4th 5th 6th 7th 8th 9th 10th
11th 12th 13th 14th 15th 16th 17th 18th 19th 20th
21st 22nd 23rd 24th 25th 26th 27th 28th 29th 30th
101st 102nd 103rd 104th 105th 106th 107th 108th 109th 110th

अक्षरों के बाद पहले से मौजूद नंबरों को नजरअंदाज कर दिया जाएगा, इसलिए फ़िल्टर के माध्यम से आउटपुट को फिर से फीड करना इसे नहीं बदलेगा। संख्याओं के बीच रिक्त स्थान, अल्पविराम और अवधि विशेष रूप से व्यवहार नहीं की जाती हैं, इसलिए उन्हें किसी अन्य विराम चिह्न की तरह अलग संख्या मान लिया जाता है। इस प्रकार, जैसे 3.14159बन जाता है 3rd.14159th।

यह कैसे काम करता है?

सबसे पहले, यह एक वैश्विक रेगेक्स रिप्लेसमेंट ( s///g) है। मिलान किया जा रहा है 1?\d\b, जहां \dकिसी भी अंक से मेल खाता है और \bएक अल्फ़ान्यूमेरिक और एक गैर-अल्फ़ान्यूमेरिक वर्ण के बीच की सीमा से मेल खाता शून्य-चौड़ाई का दावा है। इस प्रकार, 1?\d\bकिसी भी संख्या के अंतिम अंक से मेल खाता है, और यदि ऐसा होता है तो पिछले अंक से 1।
प्रतिस्थापन में, जिसे /eस्विच के कारण पर्ल कोड के रूप में मूल्यांकन किया जाता है , हम मिलान किए गए स्ट्रिंग सेगमेंट ( $&) और परिशिष्ट ( .) को प्रत्यय के $&रूप में सूची में पूर्णांक सूचकांक के रूप में उपयोग करके प्राप्त करते हैं (0,st,nd,rd); यदि यह प्रत्यय शून्य या अपरिभाषित है (अर्थात जब $&शून्य या तीन से अधिक है), तो ||ऑपरेटर इसे बदल देता है th।

संपादित करें: यदि इनपुट एकल पूर्णांक तक सीमित है, तो यह 35 वर्ण समाधान पर्याप्त होगा:

s/1?\d$/$&.((0,st,nd,rd)[$&]||th)/e

— इल्मरी करोनें
स्रोत

1

gयदि आप निर्दिष्ट करते हैं कि प्रत्येक संख्या को स्वयं की रेखा पर होना चाहिए, तो प्रतिस्थापन को बंद करने में सक्षम होना चाहिए। इसके अलावा, यह आपको शब्द सीमा को बदलने देता है $। लेकिन कुल मिलाकर, +1, बहुत चालाक समाधान है।

— श्री लामा

@ गीगावाट: वास्तव में, मैंने इनपुट प्रारूप के बारे में मेरे प्रश्न का उत्तर देने से पहले कोड लिखा था, इसलिए मैंने इसे यथासंभव सामान्य बना दिया।

— इल्मरी करोनें

38

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

lambda n:`n`+'tsnrhtdd'[n%5*(n%100^15>4>n%10)::4]

एक अनाम फ़ंक्शन। एक पूरा कार्यक्रम 55 बाइट्स में गिना जाएगा।

'tsnrhtdd'[i::4]0 से 3 के th st nd rdमानों के लिए प्रत्ययों को एनकोड करता iहै। इसे देखते हुए, हमें nकेवल इसी प्रत्यय के सूचकांक के मानों को मैप करने का एक तरीका है i। एक सरल अभिव्यक्ति जो काम करती है (n%10)*(n%10<4 and 10<n%100<14)। हम आसानी से लघुकोष्ठकों के पहले सेट को गिराकर और विशेष प्रत्यय के साथ मूल्यों के लिए n%5परिणाम के रूप में एक ही परिणाम देते हुए इसे छोटा कर सकते हैं। परीक्षण और त्रुटि का एक सा के साथ, एक भी कम हो सकता है करने के लिए है, जो और भी अधिक बाइट्स को बचाने के लिए अन्य सशर्त साथ श्रृंखलित जा सकता है।n%10n10<n%100<14n%100^15>4

— xsot
स्रोत

3

यह कुछ काला जादू यहीं है c:

— बिल्ली

terminally-incoherent.com/blog/wp-content/uploads/2012/08/...

— मॉर्गन Thrapp

मुझे नहीं मिला। क्या कोई समझा सकता है कि यहाँ क्या हो रहा है?

— पावेल

@Pavel मैंने अपने उत्तर को स्पष्टीकरण के साथ अद्यतन किया है।

— xsot

बहुत बढ़िया! सोचने का शानदार तरीका ...

— बेनिसन सैम

10

अजगर, 68 वर्ण

i=input()
k=i%10
print"%d%s"%(i,"tsnrhtdd"[(i/10%10!=1)*(k<4)*k::4])

— गैरेथ
स्रोत

4

यह वास्तव में देर हो चुकी है, लेकिन आप 7 बाइट्स कर सकते हैं `i`+"tsnrhtdd"। अन्यथा, यह सटीक समाधान है जो मुझे अभी मिला है।

— DLosc

10

गणितज्ञ 39 45 बाइट्स

नोट: मैथेमेटिका के हाल के संस्करणों में , जहां अपरिभाषित है, के nthभाग के लिए पूछना , एक त्रुटि संदेश उत्पन्न करता है, लेकिन फिर भी सही उत्तर देता है। मैंने त्रुटि संदेश को मुद्रण से रोकने के लिए जोड़ा है।ppQuiet

Quiet@StringSplit[SpokenString[p[[#]]]][[2]]&

प्रयोग

Quiet@StringSplit[SpokenString[p[[#]]]][[2]] &[31]

31

Quiet@StringSplit[SpokenString[p[[#]]]][[2]] &/@Range[21]

"" 1 "," 2nd "," 3rd "," 4th "," 5th "," 6th "," 7th "," 8th "," 9th "," 10th "," 11th "," 12th "," 13 वें "," 14 वें "," 15 वें "," 16 वें "," 17 वें "," 18 वें "," 19 वें "," 20 वें "," 21 वें "}

यह काम किस प्रकार करता है

SpokenStringकिसी भी मान्य मैथमैटिक अभिव्यक्ति को लिखता है क्योंकि वह बोली जा सकती है। स्पोकेनस्ट्रिंग के लिए प्रलेखन से दो उदाहरण नीचे दिए गए हैं ,

SpokenString[Sqrt[x/(y + z)]]

"मात्रा y से अधिक x का वर्गमूल y प्लस z" *)

SpokenString[Graphics3D[Sphere[{{0, 0, 0}, {1, 1, 1}}]], "DetailedGraphics" -> True]

"एक त्रि-आयामी ग्राफिक जिसमें इकाई क्षेत्र शामिल है, 0, 0, 0 और 1, 1, 1 पर केंद्रित है"

अब, उदाहरण के लिए,

Quiet@SpokenString[p[[#]]] &[31]

"पी का 31 वां तत्व"

शब्दों की सूची के रूप में उपरोक्त स्ट्रिंग का प्रतिनिधित्व करते हैं:

StringSplit[%]

{"द", "31 वां", "तत्व", "का", "पी"}

और दूसरा तत्व लें ...

%[[2]]

31

— DavidC
स्रोत

मैं उलझन में हूं; कहाँ pपरिभाषित किया गया है? संपादित करें: कोई बात नहीं, मैं देख रहा हूँ कि आप इसका उपयोग कैसे कर रहे हैं; दुर्भाग्य से यह मेरे सिस्टम पर काम नहीं करता है। : - /

— Mr.Wizard

यह v.9.0.1 पर काम करता है। (मुझे याद है कि आप 7.0 का उपयोग कर रहे हैं।) हां, पी को परिभाषित करने की आवश्यकता नहीं है।

— डेविड

मैं अब समझ गया हूं। हालाँकि, v7 में मुझे SpokenString @ p[[117]]आउटपुट से मिलता है " part 117 of p"।

— श्री। छिपकली

इसलिए SpokenStringसमय-समय पर संशोधित होता रहता है। मुझे आश्चर्य नहीं होगा कि यह कोड ( codegolf.stackexchange.com/questions/8859/… ) भी v। पर काम नहीं करता है। 7. BTW, यह एक स्थायी समाधान नहीं था।

— डेविड

हह, मैंने उस उत्तर को पहले नहीं देखा था।

— Mr.Wizard

7

रूबी, ६०

यह पर्ल प्रविष्टि के रूप में अच्छा नहीं है, लेकिन मुझे लगा कि मैं अपने रूबी कौशल पर काम करूंगा।

def o(n)n.to_s+%w{th st nd rd}[n/10%10==1||n%10>3?0:n%10]end

फ़ंक्शन एक पूर्णांक तर्क लेता है n, और क्रमिक रूप में एक स्ट्रिंग लौटाता है।

निम्नलिखित तर्क के अनुसार काम करता है:
यदि दहाई का अंक 1 है या अंक का अंक 3 से अधिक है, तो प्रत्यय 'थ' का उपयोग करता है; अन्यथा अंक से प्रत्यय को ['th', 'st', 'nd', 'rd'] अंतिम अंक के रूप में सूचकांक के रूप में उपयोग करें।

— श्री लामा
स्रोत

o(113)है "113rd", होना चाहिए "113th"। दहाई अंकों की जाँच में दो अंकों से अधिक संख्याओं का हिसाब नहीं होता है।

— हमार

ठीक है, %10क्षतिपूर्ति करने के लिए दूसरे में पिच की गई । 3 वर्ण जोड़े गए। (मुझे लगता है कि %10ऐसा लगता है जहां इसे किसी भी तरह छोटा किया जाना चाहिए, लेकिन मैं एक समाधान के बारे में नहीं सोच सकता)

— श्री लामा

आप पर्ल को कभी भी भयानक

— असंगत

एक चर सेट करें 10?

— wizzwizz4 17

मुझे लगता है कि एक चर सेट n%10करना बेहतर है।

— कैलकुलेटर

6

जावास्क्रिप्ट (ES6) 50 44 बाइट्स (गैर-प्रतिस्पर्धात्मक)

a=>a+=[,"st","nd","rd"][a.match`1?.$`]||"th"

आपको संभवतः एक नोटिस जोड़ना चाहिए कि यह उत्तर गैर-प्रतिस्पर्धात्मक है, क्योंकि ES6 मौजूद नहीं था जब चुनौती पोस्ट की गई थी।

— user2428118

5

जावास्क्रिप्ट, 68 71

function o(n){return n+([,'st','nd','rd'][~~(n/10%10)-1?n%10:0]||'th')}

ItsCosmo के साथ संयुक्त प्रयास।

संपादित करें: संख्या> 100 के साथ ठीक से काम नहीं कर रहा था

— aebabis
स्रोत

आप इसे 62 के साथ function o(n)n+([,'st','nd','rd'][~~(n/10%10)-1?n%10:0]||'th')नीचे ला सकते हैं : और आप इसे 54 से नीचे ला सकते हैं यदि आप वसा तीर संकेतन का उपयोग करने के लिए खुश हैं:o=n=>n+([,'st','nd','rd'][~~(n/10%10)-1?n%10:0]||'th')

— WallyWest

@WallyWest किसी कारण से, मुझे वास्तव में पसंद है कि मेरा समाधान आधुनिक ब्राउज़रों में काम करता है। बेझिझक अपना जवाब पोस्ट करें; मुझे लगता है कि यह पर्याप्त रूप से अलग है।

— ऐनाबिस

नहीं वह ठीक है! बस कुछ विकल्प प्रदान कर रहे हैं!

— वैलीवेस्ट

3

गोल्फस्क्रिप्ट, 34 अक्षर

~.10/10%1=!1$10%*.4<*'thstndrd'2/=

— Hammar
स्रोत

3

हास्केल, 95 वर्ण

h=foldr g"th".show
g '1'"th"="1st"
g '2'"th"="2nd"
g '3'"th"="3rd"
g '1'[x,_,_]='1':x:"th"
g a s=a:s

परिक्षण:

*Main> map h [1..40]
["1st","2nd","3rd","4th","5th","6th","7th","8th","9th","10th","11th","12th","13t
h","14th","15th","16th","17th","18th","19th","20th","21st","22nd","23rd","24th",
"25th","26th","27th","28th","29th","30th","31st","32nd","33rd","34th","35th","36
th","37th","38th","39th","40th"]

-XNoMonomorphismRestriction के साथ लोड किया जाना चाहिए।

— विल नेस
स्रोत

3

जावास्क्रिप्ट, 64 अक्षर (ES3) या 47 अक्षर (ES6)

ES3 (64 अक्षर):

function(n){return n+=[,'st','nd','rd'][n%100>>3^1&&n%10]||'th'}

ईएस 6 (47 अक्षर):

n=>n+=[,'st','nd','rd'][n%100>>3^1&&n%10]||'th'

व्याख्या

अंक के साथ n % 100 >> 3 ^ 1किसी भी सकारात्मक nअंत के लिए अभिव्यक्ति 0 का मूल्यांकन करती है 08- 15। इस प्रकार, किसी भी n mod 100अंत में 11, 12या 13, सरणी लुकअप रिटर्न undefined, के एक प्रत्यय के लिए अग्रणी th।

किसी भी सकारात्मक के लिए nके अलावा अन्य अंक में समाप्त 08- 15, अभिव्यक्ति n % 100 >> 3 ^ 1एक सकारात्मक पूर्णांक के लिए मूल्यांकन करता है, अभिव्यक्ति लागू n % 10, सरणी देखने के लिए वापस आ रहा st, ndया rdके लिए nके साथ समाप्त होता है जो 1, 2, या 3। अन्यथा, th।

— टॉमस लैंगकास
स्रोत

के साथ एक बाइट बचाओ n+=[,'st','nd','rd'][n%100>>3^1&&n%10]||'th'।

— झबरा

@ शैगी, धन्यवाद, जैसा कि सुझाव दिया गया है।

— टॉमस लैंगकास

1

FYI करें github.com/guest271314/SpeechSynthesisSSMLParser/blob/master/... , github.com/guest271314/SpeechSynthesisSSMLParser/blob/master/...

— guest271314

@ guest271314, इस कोड का उपयोग करने के लिए मजेदार है। ध्यान दें कि यह केवल सकारात्मक संख्याओं के लिए काम करता है, एक और विकल्प है n+=[,"st","nd","rd"][(((n<0?-n:n)+90)%100-10)%10]||"th", इस पद से अनुकूलित ।

— टॉमस लैंगकास

3

एपीएल (डायलॉग यूनिकोड) , 38 36 बाइट्स

बाइट गिनती को बनाए रखते हुए बग को ठीक करने के लिए धन्यवाद।

बेनामी tacit उपसर्ग समारोह। आवश्यकता है ⎕IO( I ndex O rigin) 0, जो कई प्रणालियों पर डिफ़ॉल्ट है। यहां तक कि 0 के लिए भी काम करता है!

⍕,{2↑'thstndrd'↓⍨2×⊃⍵⌽∊1 0 8\⊂10↑⍳4}

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

{… } गुमनाम लंबोदर; ⍵तर्क है:

⍳4 पहले चार four ndices;[0,1,2,3]

10↑ उस से पहले दस तत्वों को लें, शून्य के साथ पैडिंग: [0,1,2,3,0,0,0,0,0,0]

⊂ एकल तत्व के रूप में माना जाता है; [[0,1,2,3,0,0,0,0,0,0]]

1 0 8\ एक प्रति, एक प्रोटोटाइप प्रतिलिपि (सभी-शून्य), आठ प्रतियों का विस्तार;
[[0,1,2,3,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0],
[0,1,2,3,0,0,0,0,0,0],
[0,1,2,3,0,0,0,0,0,0],
More (5 और)
[0,1,2,3,0,0,0,0,0,0]]

∊ fl nlist (समतल);
[0,1,2,3,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,1,2,3,0,0,0,0,0,0,
0,1,2,3,0,0,0,0,0,0,
More (50 अधिक)
0,1,2,3,0,0,0,0,0,0]

⍵⌽ तार्किक रूप से संकेत के रूप में कई चरणों के रूप में चक्रवात को छोड़ दिया

⊃ पहला नंबर चुनें (यानी तर्क-आधुनिक -100 नंबर)

2× कि से गुणा दो (देता है 0, 2, 4, या 6)

'thstndrd'↓⍨इस तार से कई अक्षर ड्रॉप करें

2↑ शेष पात्रों में से पहले दो को लें

⍕, कड़े हुए तर्क को उस तक पहुंचाना

— एडम
स्रोत

"31th"?

— NGN

⍕,{2↑'thstndrd'↓⍨2×⊃⍵⌽∊1 0 8\⊂10↑⍳4}

— ngn

क्षमा करें, मैं उल्लेख करना भूल गया ⎕io←0। मैं देख सकता हूँ कि आप अनुमान लगा सकते हैं, लेकिन कुछ 1,2,3,4,0,0 हैं ... जो 0,1,2,3,0,0 होना चाहिए ...

— ngn

@ng फिक्स्ड। और 0 के लिए भी काम करता है!

— आदम

2

पॉवरशेल, 92

process{"$_$(switch -r($_){"(?<!1)1$"{'st'}"(?<!1)2$"{'nd'}"(?<!1)3$"{'rd'}default{'th'}})"}

इनपुट की प्रति पंक्ति एक संख्या के साथ काम करता है। इनपुट पाइपलाइन के माध्यम से दिया जाता है। यह केवल एक ही संख्या के लिए काम कर आकार को कम नहीं करता है।

— एक छोटा सा सिक्का
स्रोत

2

जे - 44 चार

जे में कुछ भी नहीं? यह एक आक्रोश है!

(":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:])

समझाया (ध्यान दें कि 1जम्मू में बूलियन सच है और 0गलत है):

10 10(...)/@#:]- पहले हम तर्क लेते हैं ( ]) और दसियों और अंकों को पाते हैं ( 10 10 #:)। फिर, हम (...)दोनों के बीच इंसर्ट करेंगे ।
(]*[(~:*])4>])- इस सबडिप्रेशन में, लेकिन अंतरतम एक नहीं, ]अंक और [दहाई अंक की ओर इशारा करेगा ।
[(~:*])4>]- ~:J "न के बराबर" के लिए है, इसलिए इसका परिणाम होता है 4>](यानी एक अंक 4 से कम है या नहीं) और इसके परिणाम से गुणा करता है tens ~: (4>])। कोई यह क्यूँ करेगा? निम्नलिखित को धयान मे रखते हुए:
- हम 10, 11, 12, 13 की जाँच कर रहे हैं, तो tensहै 1(हम किशोरावस्था में कर रहे हैं) और ones4 से कम है, तो tens ~: (4>])गलत है और परिणाम है 0*1= 0।
- यदि हम {X0, X1, X2, X3} में से कोई एक हैं, तो स्पष्ट रूप tens ~: (4>])से सच है और हम बाहर निकलते हैं 1*1= 1।
- यदि onesचार से अधिक है, तो यह 4>]था 0और इससे कोई फर्क नहीं पड़ता कि अब क्या होता है, हम 0परवाह किए बिना बाहर निकल जाएंगे ।
- तो संक्षेप में, [(~:*])4>]यह है 1कि क्या हम {X0, X1, X2, X3} में हैं, लेकिन किशोर अवस्था में नहीं, और 0अन्यथा।
]*- अंत में हम उस अंक को गुणा करते हैं। तो यह उत्पाद होगा 0यदि संख्या एक 'th'प्रत्यय के योग्य है , अन्यथा इसका मूल्य।
th`st`nd`rd{::~- हम प्रत्यय की सूची को इंडेक्स करने के लिए ऊपर से संशोधित वाले अंकों का उपयोग करते हैं। 0हो जाता है 'th', 1हो जाता है 'st', और इतने पर।
":,- अंत में, मूल संख्या लें, इसे एक स्ट्रिंग में परिवर्तित करें ( ":), और फिर इसे प्रत्यय से जोड़ दें।

उपयोग स्पष्ट है, हालांकि जैसा कि यह है कि क्रिया केवल एक अध्यादेश ले सकती है, सूची नहीं।

   (":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:]) 112         NB. single use
112th
   (":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:]) 1 2 3 4 5   NB. doing it wrong
|length error
|       (":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:])1 2 3 4 5
   NB. i.5 10   makes a 5x10 grid of increasing integers
   NB. &.>      to operate on each integer separately, and box the result after
   (":,th`st`nd`rd{::~10 10(]*[(~:*])4>])/@#:])&.> i.5 10   NB. all better
+----+----+----+----+----+----+----+----+----+----+
|0th |1st |2nd |3rd |4th |5th |6th |7th |8th |9th |
+----+----+----+----+----+----+----+----+----+----+
|10th|11th|12th|13th|14th|15th|16th|17th|18th|19th|
+----+----+----+----+----+----+----+----+----+----+
|20th|21st|22nd|23rd|24th|25th|26th|27th|28th|29th|
+----+----+----+----+----+----+----+----+----+----+
|30th|31st|32nd|33rd|34th|35th|36th|37th|38th|39th|
+----+----+----+----+----+----+----+----+----+----+
|40th|41st|42nd|43rd|44th|45th|46th|47th|48th|49th|
+----+----+----+----+----+----+----+----+----+----+

— algorithmshark
स्रोत

2

सी #, 62 बाइट्स

n=>n+(n/10%10==1||(n%=10)<1||n>3?"th":n<2?"st":n<3?"nd":"rd");

पूर्ण कार्यक्रम और सत्यापन:

using System;

namespace OutputOrdinalNumbers
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<int,string>f= n=>n+(n/10%10==1||(n%=10)<1||n>3?"th":n<2?"st":n<3?"nd":"rd");

            for (int i=1; i<=124; i++)
                Console.WriteLine(f(i));
        }
    }
}

— adrianmp
स्रोत

आप को बदलने के द्वारा दो बाइट्स से यह गोल्फ कर सकते हैं ||करने के लिए |।

— केविन क्रूज़सेन 12

2

गणितज्ञ 29 + 5 = 34 बाइट्स

SpokenStringDump`SpeakOrdinal

+5 बाइट्स क्योंकि Speakइस बिल्ट-इन का उपयोग करने से पहले फ़ंक्शन को बुलाया जाना चाहिए।

प्रयोग

SpokenStringDump`SpeakOrdinal[1]

"1st "

SpokenStringDump`SpeakOrdinal[4707]

"4,707th "

— जंगवान मिन
स्रोत

1

PHP, 151

मुझे पता है कि यह कार्यक्रम दूसरों के लिए तुलनीय नहीं है। बस एक समाधान देने की तरह महसूस किया।

<?$s=explode(' ',trim(fgets(STDIN)));foreach($s as$n){echo$n;echo(int)(($n%100)/10)==1?'th':($n%10==1?'st':($n%10==2?'nd':($n%10==3?'rd':'th')))."\n";}

— l0n3sh4rk
स्रोत

आप का उपयोग करके कुछ वर्ण बचा सकता हैforeach($s as $n){echo$n;

— कार्तिक

1

स्काला 86

def x(n:Int)=n+{if(n%100/10==1)"th"else(("thstndrd"+"th"*6).sliding(2,2).toSeq(n%10))}

स्केल 102:

def x(n:Int)=if((n%100)/10==1)n+"th"else if(n%10<4)n+("thstndrd".take(n+1)%5*2.drop(n%5*2))else n+"th"

साथ ही 102:

def x(n:Int)=if((n%100)/10==1)n+"th"else if(n%10<4)n+("thstndrd".sliding(2,2).toSeq(n%10))else n+"th"

ungolfed:

def x (n: Int) =
  n + { if (((n % 100) / 10) == 1) "th" 
        else (("thstndrd"  + ("th"  * 6)).sliding (2, 2).toSeq (n % 10))
      }

— अज्ञात उपयोगकर्ता
स्रोत

1

OCaml

मैं OCaml के लिए बहुत नया हूं, लेकिन यह सबसे छोटा है जो मुझे मिल सकता है।

let n x =
   let v = x mod 100 and string_v = string_of_int x in
   let z = v mod 10 in
   if v=11 || v=12 || v=13 then string_v^"th" 
   else if v = 1 || z = 1 then string_v^"st" else if v = 2 || z = 2 then string_v^"nd" else if v = 3 || z = 3 then string_v^"rd" else string_v^"th";;

मैंने एक फ़ंक्शन n बनाया जो एक पैरामीटर के रूप में एक संख्या लेता है और काम करता है। इसका लंबा लेकिन सोचा कि यह एक कार्यात्मक उदाहरण के लिए बहुत अच्छा होगा।

— जोसेफ एलसीड
स्रोत

इनपुट: 11 उत्पादन होगा:

हाँ, आप सही हैं .. मैंने सुधार किया है। धन्यवाद

— यूसुफ एलसिड

मैंने अभी-अभी आपके कोड पर फ़ॉर्मेटिंग के बारे में बताया है। कोड ब्लॉक के रूप में पहचाने जाने के लिए प्रत्येक पंक्ति को चार स्थानों से पहले होना चाहिए।

— गारेथ

यदि आपका चेक पहले छोटा नहीं होगा if v>10 && v<14? मैं ओसमल से परिचित नहीं हूं, लेकिन क्या string_vचर का इतना लंबा होना जरूरी है ?

— गफी

नहीं, यह आवश्यक नहीं है, मैं w या x चुन सकता था। बस कुछ सार्थक चाहिए था। लेकिन आप सही कह रहे हैं, इससे कोड थोड़ा छोटा हो जाता।

— जोसेफ एल्सीड

1

के - 44 चार

ऐसा होता है कि यह जे के समान है, और लगभग उसी तरह से काम करता है।

{x,$`th`st`nd`rd@{y*(y<4)*~1=x}.-2#0,.:'x$:}

व्याख्या की:

x$:- सबसे पहले, हम ऑपरेंड xको एक स्ट्रिंग में बदलते हैं , और फिर उसे वापस असाइन करते हैं x। हमें बाद में इसके स्ट्रिंग रिपीट की आवश्यकता होगी, इसलिए ऐसा करने से अब अक्षर बच जाते हैं।
.:'- कन्वर्ट ( .:) प्रत्येक ( ') अंक एक संख्या में वापस।
-2#0, - अंकों की सूची के सामने 0 (एकल-अंकों की संख्या के मामले में) को जोड़ें, और फिर अंतिम दो को लें।
{y*(y<4)*~1=x}.- उपयोग तर्क के रूप में दो अंक xऔर yजो रिटर्न इस आंतरिक कार्य करने के लिए, yयदि y4 से कम है और xनहीं है 1 के बराबर है, अन्यथा 0।
`th`st`nd`rd@ - इस परिणाम द्वारा प्रत्ययों की सूची को अनुक्रमित करें।
x,$ - प्रत्यय को प्रतीक से स्ट्रिंग में परिवर्तित करें, और इसे मूल संख्या में जोड़ें।

उपयोग:

  {x,$`th`st`nd`rd@{y*(y<4)*~1=x}.-2#0,.:'x$:} 3021
"3021st"
  {x,$`th`st`nd`rd@{y*(y<4)*~1=x}.-2#0,.:'x$:}' 1 2 3 4 11 12 13 14  /for each in list
("1st"
 "2nd"
 "3rd"
 "4th"
 "11th"
 "12th"
 "13th"
 "14th")

— algorithmshark
स्रोत

1

C - 95 83 वर्ण

main(n,k){scanf("%d",&n);k=(n+9)%10;printf("%d%s\n",n,k<3?"st\0nd\0rd"+3*k:"th");}

Degolfed:

main(n,k)
{
    scanf("%d",&n);
    k=(n+9)%10; // xx1->0, xx2->1, xx3->2
    printf("%d%s\n",n,k<3?"st\0nd\0rd"+3*k:"th");
}

हम k=(n-1)%109 को जोड़ने के बजाय कर सकते थे , लेकिन n = 0 के लिए हमें एक गलत व्यवहार मिलेगा, क्योंकि C में (-1)%10मूल्यांकन -1 से है, 9 से नहीं।

— pawel.boczarski
स्रोत

1

जावास्क्रिप्ट, 75

function s(i){return i+'thstndrd'.substr(~~(i/10%10)-1&&i%10<4?i%10*2:0,2)}

— wolfhammer
स्रोत

1

PHP, 98 बाइट्स

function c($n){$c=$n%100;$s=['','st','nd','rd'];echo$c>9&&$c<14||!$s[$c%10]?$n.'th':$n.$s[$c%10];}

11-13 बिट मुझे यहाँ मार रहा है। किसी भी पूर्णांक के लिए काम करता है $n >= 0।

किसी भी पूर्णांक के लिए $n:

PHP, 103 बाइट्स

function c($n){$c=abs($n%100);$s=['','st','nd','rd'];echo$c>9&&$c<14||!$s[$c%10]?$n.'th':$n.$s[$c%10];}

— ricdesi
स्रोत

1

पायथन, 88 84 बाइट्स

lambda x:x+((('th','st','nd','rd')+('th',)*6)[int(x[-1])]if('0'+x)[-2]!='1'else'th')

Ungolfed:

def y(x):
    return x + (('th', 'st', 'nd', 'rd') + ('th', ) * 6)[int(x[-1])] if ('0' + x)[-2] != '1' else 'th')

lambda xपैरामीटर के साथ एक अनाम फ़ंक्शन को परिभाषित करता है x। ((('th','st','nd','rd')+('th',)*6)[int(x[-1])]10 से कम संख्याओं के लिए अंत का एक tuple परिभाषित करता है, 0-thतत्व के लिए है 0, और आगे। if ('0'+x)[-2] != '1'जांच करता है कि वहाँ है 11, 12है, या एक 13ठीक करने के लिए, और फिर जोड़ता else 'th'कहते हैं thबजाय st, rd, या nd।

— यहाँ कोई नहीं हे
स्रोत

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

— wizzwizz4 17

ठीक है मैं करूँगा। क्या मुझे एक गैर-गोल्फ उत्तर भी जोड़ना चाहिए?

— NoOneIsHere

यह एक अलग जवाब नहीं होना चाहिए ... आपने जो किया है वह ठीक है, अच्छा किया है। यदि आप कोई और चुनौती चाहते हैं, तो मैं कुछ सिफारिशें दे सकता हूं।

— wizzwizz4 17

ठीक। आप कोशिश कर सकते हैं ... अपनी कुर्सी को समायोजित करें , या आपके दोस्त कहां बैठेंगे । या आप मेरी कुछ चुनौतियों को आजमा सकते हैं , जैसे कि द नाइट्स नेक्स्ट टूर । यदि ये आपकी तरह की चुनौतियाँ नहीं हैं, तो बस कहिए।

— wizzwizz4

1

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

जवाब में सुधार के लिए @KevinCruijssen को श्रेय

n=>n+=[,'st','nd','rd'][~~(n/10%10)-1?n%10:0]||'th'

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

स्पष्टीकरण:

n =>                      // input
    n+=[,'st','nd','rd']     // the array of suffices add everything to n
        [~~(n/10%10)-1?n%10:0] // the full magic 
    || 'th'               // works for everything except 1 , 2 , 3 just like what you want

1

आर , 79 76 बाइट्स

चूंकि अभी तक कोई आर समाधान नहीं है ... यहां कोई चाल नहीं है, बुनियादी वेक्टर अनुक्रमण, ग्यूसेप के लिए 3 वर्ण नीचे दिए गए हैं। पहले की कोशिश सूचकांक: [1+(x%%10)-(x%%100==11)]और [1+(x%%10)*(x%%100!=11)]।

function(x)paste0(x,c("th","st","nd","rd",rep("th",6))[1+x%%10*!x%%100==11])

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

साथ substr, 79 बाइट्स:

function(x,y=1+2*min(x%%10-(x%%100==11),4))paste0(x,substr("thstndrdth",y,y+1))

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

— Jayce
स्रोत

1

1+x%%10*!x%%100==11सूचकांक के लिए?

— ग्यूसेप

@Giuseppe मुझे कोष्ठक पर शांत होने की आवश्यकता है :)। !अभिव्यक्ति की जगह अभिव्यक्ति के सामने चतुर प्रयोग !=।

— JayCe

1

हाँ, संचालकों में अजीब मिसाल है; ^है वास्तव में उच्च है, तो %%प्रकार ऑपरेटरों, तो */और +-और मुझे लगता है कि ==और &|अगले आता है। !इसमें काफी कम पूर्वता है ताकि आप इसे संचालन के बीच विभाजक के रूप में उपयोग कर सकें।

— Giuseppe

0

पायथन 2.7, 137 चार्ट

def b(n):
 for e,o in[[i,'th']for i in['11','12','13']+list('4567890')]+[['2','nd'],['1','st'],['3','rd']]:
  if n.endswith(e):return n+o

n एक तार होना चाहिए

मुझे पता है कि मैं यहां प्रतियोगिता से पहले ही हार चुका हूं, लेकिन मैंने सोचा कि मैं अपना विचार वैसे भी प्रदान करूंगा

यह मूल रूप से कुंजी की एक सूची, संख्या के साथ मूल्य जोड़े (एक स्ट्रिंग के रूप में) समाप्त होता है eऔर क्रमिक उत्पन्न करता है o। यह पहले 'वें' से मेल खाने का प्रयास करता है (इसलिए मैंने एक शब्दकोष का उपयोग क्यों नहीं किया), ताकि यह गलती से 'सेंट' पर न लौट आए, उदाहरण के लिए, जब इसे 'वें' होना चाहिए। यह किसी भी सकारात्मक पूर्णांक के लिए काम करेगा

— रंगीन जाकेट
स्रोत

n[-1]==e5 n.endswith(e)

— चार्ट

0

C: 95 अक्षर

एक हास्यास्पद लंबा समाधान:

n;main(){scanf("%d",&n);printf("%d%s",n,n/10%10-1&&(n=n%10)<4&&n?n>2?"rd":n<2?"st":"nd":"th");}

इसे और अधिक मंगाने की जरूरत है।

— Fors
स्रोत

एक उपयोगकर्ता ने यह कहते हुए ध्वजांकित किया "यह गलत है: बिल्कुल भी लूप नहीं करता है, अर्थात यह किसी दिए गए नंबर के लिए काम करता है, न कि इसके नीचे की सभी संख्याएँ। ideone.com/pO6UwV देखें।" यह ध्वज लगाने का एक कारण नहीं है क्योंकि मध्यस्थता शुद्धता का न्याय नहीं करती है, लेकिन यह एक मुद्दा हो सकता है।

— dmckee

प्रश्न निर्माता की इस टिप्पणी के आधार पर: "@ इल्मारी मैं इनपुट के रूप में 11 और आउटपुट के रूप में 11 वें के लिए देख रहा हूं। मुझे कोई आपत्ति नहीं है अगर यह कई लाइनों को संसाधित करता है, लेकिन जो मेरे मन में था वह केवल एक ही संख्या में प्रसंस्करण कर रहा था। - NickC Jan 21:00 पर 20 '12 "यह वही कर रहा है जो इसे करना चाहिए। यानी यह केवल एक ही नंबर को प्रोसेस करना चाहिए।

— फोर्स

उस झंडे के लिए खेद है; मैंने आवश्यकता को गलत बताया, और सीधे टिप्पणी करने के लिए उस समय पर्याप्त प्रतिनिधि नहीं था। दोबारा माफी चाहूंगा। :)

— विल नेस

0

जावास्क्रिप्ट, 75

function o(s){return s+((0|s/10%10)==1?"th":[,"st","nd","rd"][s%10]||"th")}

— Inkbug
स्रोत

0

Oracle SQL 11.2, 101 बाइट्स

SELECT:1||DECODE(ROUND(MOD(:1,100),-1),10,'th',DECODE(MOD(:1,10),1,'st',2,'nd',3,'rd','th'))FROM DUAL

— Jeto
स्रोत

0

जावास्क्रिप्ट ईएस 6, 52 वर्ण

n=>n+(!/1.$/.test(--n)&&'snr'[n%=10]+'tdd'[n]||'th')

— Qwertiy
स्रोत

आउटपुट क्रमिक संख्याएँ (प्रथम, द्वितीय, तृतीय)

पर्ल, 37 + 1 वर्ण

नमूना इनपुट:

आउटपुट:

यह कैसे काम करता है?

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

अजगर, 68 वर्ण

गणितज्ञ 39 45 बाइट्स

रूबी, ६०

जावास्क्रिप्ट (ES6) 50 44 बाइट्स (गैर-प्रतिस्पर्धात्मक)

टिप्पणियाँ

जावास्क्रिप्ट, 68 71

गोल्फस्क्रिप्ट, 34 अक्षर

हास्केल, 95 वर्ण

जावास्क्रिप्ट, 64 अक्षर (ES3) या 47 अक्षर (ES6)

ES3 (64 अक्षर):

ईएस 6 (47 अक्षर):

व्याख्या

एपीएल (डायलॉग यूनिकोड) , 38 36 बाइट्स

पॉवरशेल, 92

जे - 44 चार

सी #, 62 बाइट्स

गणितज्ञ 29 + 5 = 34 बाइट्स

PHP, 151

स्काला 86

OCaml

के - 44 चार

C - 95 83 वर्ण

जावास्क्रिप्ट, 75

PHP, 98 बाइट्स

PHP, 103 बाइट्स

पायथन, 88 84 बाइट्स

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

स्पष्टीकरण:

आर , 79 76 बाइट्स

C: 95 अक्षर

जावास्क्रिप्ट, 75

Oracle SQL 11.2, 101 बाइट्स

जावास्क्रिप्ट ईएस 6, 52 वर्ण