41

इनपुट के रूप में A से Z (J और K को छोड़कर) के किसी एक अक्षर को देखते हुए, उस अक्षर को अपने लिखित रूप में सबसे छोटे गैर-नकारात्मक पूर्णांक को आउटपुट करता है। मान लें कि संख्याओं में शब्द "और" कभी नहीं होता है, इसलिए 101"एक सौ एक" है, न कि "एक सौ एक"। अमेरिकी (लघु-पैमाने) की गिनती मान लें, तो एक मिलियन 10^6और एक अरब है 10^9।

a 1000                           one thousand
b 1000000000                     one billion
c 1000000000000000000000000000   one octillion
d 100                            one hundred
e 0                              zero
f 4                              four
g 8                              eight
h 3                              three
i 5                              five
j 
k
l 11                             eleven
m 1000000                        one million
n 1                              one
o 0                              zero
p 1000000000000000000000000      one septillion
q 1000000000000000               one quadrillion
r 0                              zero
s 6                              six
t 2                              two
u 4                              four
v 5                              five
w 2                              two
x 6                              six
y 20                             twenty
z 0                              zero

J और K इनपुट विनिर्देश का हिस्सा नहीं हैं, इसलिए आपका व्यवहार उनके लिए अपरिभाषित है। उपरोक्त पत्रों में से एक को देखते हुए, इसके बगल में (दशमलव) संख्या को आउटपुट करें। आप लोअरकेस या अपरकेस में इनपुट ले सकते हैं, लेकिन आपको आवश्यकता नहीं है कि कुछ इनपुट लोअरकेस और अन्य अपरकेस हो सकते हैं।

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

code-golf number kolmogorov-complexity

— स्टीफन
स्रोत

11

मुझे पूरा यकीन नहीं है कि इस चुनौती को इतना कम कर दिया गया है? जहाँ तक मैं देख सकता हूँ, यह स्पष्ट और विषय पर है। यकीन है कि यह सबसे अधिक संभावना है कि प्रत्येक पत्र को उसकी संबंधित संख्या के लिए एन्कोडिंग किया जा सकता है, लेकिन मुझे नहीं लगता कि यह 3 डाउनवोट्स को सही ठहराता है?

— caird coinheringaahing

2

@ जोना ने कहा, प्रतिक्रिया के लिए धन्यवाद

— स्टीफन

10

आप कह रहे हैं "एक बाजीगर" असली संख्या नहीं है?

— Jo King

2

@JoKing यह दशमलव प्रतिनिधित्व क्या है? :)

— स्टीफन

8

मुझे लगता है कि एक StackExchange उपयोगकर्ता जो सोचता है कि कश्मीर एक नंबर के नाम में प्रकट नहीं हो सकता है, बल्कि कल्पना में लाखांग है।

— एंड्रयू ग्रिम

16

जावास्क्रिप्ट (Node.js) , 78 75 74 73 बाइट्स

c=>(n=([x]=Buffer(c+'8>P7 $(#%  +;! MD &"$%"&4 '))[x-96]-53)<0?n+21:10**n

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

कैसे?

प्रत्येक मूल्य एक प्रिंट करने योग्य चरित्र के साथ एन्कोडेड है। हम ASCII रेंज का उपयोग करते हैं को एनकोड करने के लिए और रेंज को एनकोड करने के लिए । $[32..52]$ $n-32$ $[53..80]$ $10^{n-53}$

टिप्पणी की गई

c =>                                   // c = input character
  ( n =                                //
    ( [x] =                            // let x be the 1st byte of the
        Buffer(                        // buffer made of:
          c +                          //   c followed by
          '8>P7 $(#%  +;! MD &"$%"&4 ' //   the encoded values
        )                              //
    )[x - 96]                          // let n be the encoded value corresponding to c
    - 53                               // minus 53
  ) < 0 ?                              // if n is negative:
    n + 21                             //   return n + 21
  :                                    // else:
    10 ** n                            //   return 10 ** n

— Arnauld
स्रोत

7

रूबी , 65 बाइट्स

->n{i="CI[B?;7<:??4F>?XO?9=;:=9+?"[n.ord-65].ord-64;i>0?10**i:~i}

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

जीबी की टिप्पणी से प्रेरित सुधार।

रूबी , 70 बाइट्स

->n{i="ci}b@DHCE@@KfA@xo@FBDEBFT@"[n.ord-65].ord;i>96?10**(i-96):i-64}

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

— स्तर नदी सेंट
स्रोत

67 बाइट्स

— जीबी

@GB धन्यवाद, के लिए नकारात्मक मान रखने का विचार iउपयोगी था। अब डाउन टू 65.

— लेवल रिवर सेंट

6

/// , 125 बाइट्स

/:/\/\///T/000:d/100:a/d0:m/aT:b/aTT:q/bTT:p/qTTT:c/pT:e/0:f/4:g/8:h/3:i/5:l/11:n/1:o/0:r/0:s/6:t/2:u/4:v/5:w/2:x/6:y/20:z/0/

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

इनपुट को I / O मेटा के अनुसार कोड के अंत में जोड़ा जाता है । उपरोक्त TIO लिंक में मौजूद पाद लेख सभी अक्षरों का एक साथ परीक्षण करता है, एक एकल पंक्ति-सीमांकित स्ट्रिंग के रूप में, लेकिन एकल वर्ण इनपुट करते समय कोड भी ठीक काम करता है ।

— नकारात्मक सात
स्रोत

6

वोल्फ्राम भाषा (गणितज्ञ) , 50 बाइट्स

TIO पर परीक्षण करने पर प्रदर्शन कारणों से अक्षर b, c, m, p और q को छोड़ दिया जाता है।

(i=0;While[1>StringCount[IntegerName@i,#],i++];i)&

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

— कोई व्यक्ति
स्रोत

41 बाइट्स

— 1

6

स्टैक्स , 33 बाइट्स

º░¡µ?Äz*B╥╪╩ΓoΣ4ù↓|♂5%⌡ÿΩ²┼h{☻4O└

इसे चलाएं और डीबग करें

प्रक्रिया:

इनपुट से कोडपॉइंट निकालें।
[3, 5, 7, 9, 11, -6, 1, 0, -24, -15, 0, 6, 2, 4, 5, 2, 6, 20, 0, -3, -9, -27, -2, 0, 4, 8]कोडपॉइंट का उपयोग करके निरंतर सरणी में सूचकांक । (रैप-अराउंड के साथ)
यदि परिणाम नकारात्मक है, तो नकारात्मक और 10उस शक्ति को बढ़ाएं , अन्यथा जैसा है वैसा ही छोड़ दें।

— पुनरावर्ती
स्रोत

6

एक्सेल, 85 बाइट्स

=CHOOSE(CODE(A1)-96,1E3,1E9,1E27,100,,4,8,3,5,,,11,1E6,1,,1E24,1E15,,6,2,4,5,2,6,20,)

2 गोल्फ की बिट्स:

घातांक (जैसे 1E15) का उपयोग करना बचाता है 26 bytes।
डिफ़ॉल्ट CHOOSEजब कुछ भी नहीं दिया जाता है 0, बचाता है4 bytes

— Wernisch
स्रोत

4

05AB1E , 36 बाइट्स

•—ÃÅ¸usδtθ}™-5„©‘öæH•57в₆-sÇ`èD0‹iÄ°

पोर्ट ऑफ़ @recursive का स्टैक्स उत्तर ।
लोअरकेस में इनपुट।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

•—ÃÅ¸usδtθ}™-5„©‘öæH• # Push compressed integer 3133432551338094772548436198140408157771728287
 57в                  # Converted to base-57 as list: [39,41,43,45,47,30,37,36,12,21,36,42,38,40,41,38,42,56,36,33,27,9,34,36,40,44]
    ₆-                # Subtract 36 from each: [3,5,7,9,11,-6,1,0,-24,-15,0,6,2,4,5,2,6,20,0,-3,-9,-27,-2,0,4,8]
      sÇ`             # Swap to take the input, and convert it to its unicode value
         è            # Index it into the list (with automatic wraparound)
          D0‹i        # Create a copy, and if this is negative:
              Ä       #  Take the absolute value
               °      #  And then take 10 the power this value
                      # (implicitly output the top of the stack as result)

मेरा यह 05AB1E टिप देखें (अनुभाग कितना बड़ा पूर्णांक संपीड़ित करने के लिए? और संपीड़ित पूर्णांक सूचियों कैसे? ) को समझने के लिए क्यों •—ÃÅ¸usδtθ}™-5„©‘öæH•है 3133432551338094772548436198140408157771728287और •—ÃÅ¸usδtθ}™-5„©‘öæH•57вहै [39,41,43,45,47,30,37,36,12,21,36,42,38,40,41,38,42,56,36,33,27,9,34,36,40,44]।

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

2

32 । 05AB1E को स्टैक्स से हारना नहीं चाहिए!

— ग्रिमी

3

पर्ल 5 `-p` , 84 बाइट्स

$_=(1e3,1e9,1e27,100,0,4,8,3,5,1,1,11,1e6,1,0,1e24,1e15,0,6,2,4,5,2,6,20,0)[-65+ord]

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

— Xcali
स्रोत

@ जोकिंग के पर्ल 6 सॉल्यूशन से लुकिंग टेबल का उपयोग करते हुए 72 बाइट्स

— नाहुएल फौइउल

3

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

lambda x:(1000,10**9,10**27,100,0,4,8,3,5,0,0,11,10**6,1,0,10**24,10**15,0,6,2,4,5,2,6,20,0)[ord(x)-97]

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

— Jitse
स्रोत

3

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 77 74 68 बाइट्स

x=>((x="1‘Ʊ!  aƁñ"[x-65])&15)*Math.Pow(10,x>>4)

$a \times 10^b$ $a$ $b$

टिप्पणी की गई

x=>                                                 //Lambda taking in a char
  (x=                                         )     //Re-assign x to
     "1‘Ʊ!   aƁñ"[x-65]      //The character's value at index x-65
 (                                             &15) //Bitwise AND by 15                                
  * Math.Pow(10,x>>4)                               // Multiplied by 10**(floor(x/16))

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

— अज्ञान का अवतार
स्रोत

2

पर्ल 6 , 67 बाइट्स

{/\-/??10**-$_!!$_}o{'`ZHacgkfhccn]dcKTciegheiwc'.ords[.ord-97]-99}

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

एक लुकअप तालिका का उपयोग करता है जहां एक ऋणात्मक संख्या का अर्थ है कि प्रतिपादक का ऋणात्मक, अन्यथा यह संख्या स्वयं है।

— मजाक कर रहा है
स्रोत

2

05AB1E , 32 बाइट्स

•н“вüQ;æ¡ζæÀÛß%aÜ×₃t•56вsCè2‰`i°

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

•н“вüQ;æ¡ζæÀÛß%aÜ×₃t•56в  # compressed list:
# [31, 0, 12, 4, 8, 10, 4, 12, 40, 0, 7, 19, 55, 5, 0, 8, 16, 6, 10, 1, 1, 22, 13, 2, 0, 49]

s                         # swap so the input is at the top
 C                        # parse input as "binary" (a -> 36, b -> 37, ...)
  è                       # index (wraps around)
   2‰                     # divmod 2: [n / 2, n % 2]
     `                    # dump both on the stack
      i                   # if the modulo is 1:
       °                  #  10 ** the quotient
                          # implicit output

— ग्रिमी
स्रोत

मुझे अभी भी वह 'binary'बिलिन नहीं मिला है । xD लेकिन मुझे लगता है कि यह कभी-कभी इस तरह से उपयोगी हो सकता है। ;)

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

2

बैश , 129 100 बाइट्स

A=xDVw04835zzbA10SJ0624526k0
c=$[64#${A:$[64#$1-10]:1}]
[ $c -gt 30 ]&&printf 1%0$[c-30].0f||echo $c

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

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

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

A=xDVw04835zzbA10SJ0624526k0

$ A: Base64 ने "a" - "z" एन्कोड किया: 100 से कम संख्याएं सीधे संग्रहीत की जाती हैं। बड़ी संख्या को शून्य +30 की संख्या के रूप में एन्कोड किया गया है। (उदा: 1,000 = 33, 100 = 32, आदि)

c=$[64#${A:$[64#$1-10]:1}]

$ 1 से स्थिति में एक पत्र निकालें तर्क $ 1 में निर्दिष्ट (base64 डिकोड किया गया, -10 'ऑफ' के ऑफसेट के लिए खाते में)। बेस 64 उस चरित्र को डिकोड करता है और सी में स्टोर करता है।

[ $c -gt 30 ]&&printf 1%0$[c-30].0f||echo $c

यदि $ c 30 से अधिक है, तो "1" $ c-30 शून्य के साथ गद्देदार प्रिंट करें। और, $ c प्रिंट करें।

— spuck
स्रोत

2

स्लेजहैमर , 17 बाइट्स

तकनीकी रूप से, यह 133 बिट लंबा है, लेकिन यह वास्तव में 16.625 बाइट्स नहीं करता है, जैसा कि कंप्रेसर का दावा है।

⣜⢍⢞⢹⡱⡋⣽⡱⡆⢺⢦⡽⡐⡌⢗⠈⣵

यह शायद डिकोड करता है

x1 = Input[]; x2 = 0; While[StringFreeQ[IntegerName[x2], x1], x2++]; Print[x2]

(लगभग मेरे गणितज्ञ के उत्तर के समान), हालांकि मैं मुश्किल से इसे मिला (यह ऐसा प्रतीत होता है जैसे कि मेरे पीसी में सब कुछ के साथ संगतता मुद्दे हैं), इसलिए सौभाग्य से इसे फिर से जांचने के लिए डिकोड किया गया। एनकोडर का उपयोग करते समय मैंने कुछ गलतियाँ की होंगी, इसलिए सावधान रहें।

— कोई व्यक्ति
स्रोत

1

जेली , 36 बाइट्स

Oị“[@ịẆþĊ`o&÷ḲḞṘḂỊP¥t’b48¤_⁹⁵*ɗ¹>?20

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

एक निम्न लिंक पत्र को अपने तर्क के रूप में और एक पूर्णांक वापस करते हुए एक विवादास्पद लिंक। रिटर्न 0के लिए jऔर k।

व्याख्या

O                       | Convert to code point
 ị          ¤           | Index into following as a nilad (wraps around):
  “[...t’               | - Integer 5370441668223940717846370165240010583188867 (stored base 250)
         b48            | - Convert to base 48
                 ɗ >?20 | If >20, following as a dyad using 20 as right argument:
             _⁹         | - Subtract right argument (20)
               ⁵*       | - 10 to the power of this
                  ¹     | Else: leave unchanged (identity function)

— निक केनेडी
स्रोत

1

रेटिना 0.8.2 , 89 बाइट्स

^
$'
T`l`111104835__111011062452620`^.
T`abcm\pq`139285
\d$
$*0$&$*0$&$*0
d
00
T`\lyl`10_

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

^
$'

इनपुट डुप्लिकेट करें।

T`l`111104835__111011062452620`^.

प्रासंगिक परिणाम की पहली प्रति (प्रथम) अंक में बदलें।

T`abcm\pq`139285

यदि संख्या में 3 अनुगामी शून्य का गुणक है, तो उस संख्या को अभी प्राप्त करें।

\d$
$*0$&$*0$&$*0

और वास्तव में इसे अनुगामी शून्य की प्रासंगिक संख्या में परिवर्तित करें। (ध्यान दें कि यह *3*0रेटिना 1 में सरल होगा )

d
00

ठीक करना d।

T`\lyl`10_

ठीक करें lऔर yकिसी भी शेष पत्र को हटा दें।

— नील
स्रोत

1

PHP , 104 बाइट्स

<?=A<($a='^FX]0483500GC10UL0624526P0'[ord($argn)-97])?20==($b=ord($a)%30)||11==$b?$b:str_pad(1,$b,0):$a;

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

मेरे पास एक स्ट्रिंग है ^FX]0483500GC10UL0624526P0जो "ए" से "जेड" तक हर इनपुट पत्र के लिए एक एकल चरित्र रखती है। मैं इनपुट के आधार पर इस चरित्र को निकालता हूं और इसे स्टोर करता हूं $a। यदि चरित्र एक अंक नहीं है, तो इसका ASCII कोड mod 30 में संग्रहीत किया जाएगा $b।

यदि $aकोई अंक है, तो एक ही अंक मुद्रित किया जाता है, यह किसी भी इनपुट के लिए उपयोग किया जाता है जिसे 0 और 9 (जैसे "ई", "एफ", आदि) के बीच आउटपुट की आवश्यकता होती है।

यदि $b२० या ११ के बराबर है, तो समान संख्या में प्रिंट किया जाता है, इसका उपयोग "एल" और "वाई" के लिए किया जाता है।

"अंक" के $bसाथ गद्देदार "1" अंक छपा है। उदाहरण के लिए "ए" के इनपुट के लिए, चरित्र "^" है, जिसमें 94 का एएससीआईआई कोड है। 94 % 30 = 4"1" के साथ "1" 4 के लिए पैडेड "1000" होगा।

— Night2
स्रोत

प्रत्येक पत्र के लिए पहला नंबर

जावास्क्रिप्ट (Node.js) , 78 75 74 73 बाइट्स

कैसे?

टिप्पणी की गई

रूबी , 65 बाइट्स

रूबी , 70 बाइट्स

/// , 125 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 50 बाइट्स

स्टैक्स , 33 बाइट्स

प्रक्रिया:

एक्सेल, 85 बाइट्स

05AB1E , 36 बाइट्स

पर्ल 5 -p , 84 बाइट्स

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

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 77 74 68 बाइट्स

पर्ल 6 , 67 बाइट्स

05AB1E , 32 बाइट्स

बैश , 129 100 बाइट्स

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

स्लेजहैमर , 17 बाइट्स

जेली , 36 बाइट्स

व्याख्या

रेटिना 0.8.2 , 89 बाइट्स

PHP , 104 बाइट्स

पर्ल 5 `-p` , 84 बाइट्स