अंतर्निर्मित या पुस्तकालयों के बिना अंग्रेजी को संख्या में परिवर्तित करें

Question

यह चुनौती इस अन्य के समान है , हालांकि मैंने एक प्रतिबंध (नीचे बोल्ड टेक्स्ट देखें) कि मुझे लगता है कि यह बहुत अलग और (मुझे उम्मीद है) मजेदार बना देगा।

चुनौती

किसी भी प्रोग्रामिंग भाषा में एक प्रोग्राम या एक फ़ंक्शन लिखें जो इनपुट के रूप में लेता है एक सकारात्मक पूर्णांक के अंग्रेजी नाम से nअधिक नहीं है 100और nपूर्णांक के रूप में वापस आता है ।

मानक कमियां निषिद्ध हैं और आप किसी भी अंतर्निहित फ़ंक्शन, बाहरी उपकरण, या लाइब्रेरी का उपयोग नहीं कर सकते हैं जो पहले से ही यह काम करता है ।

बाइट्स जीत में सबसे छोटा स्रोत कोड।

परीक्षा

यहाँ सभी input->outputमामले हैं:

one              -> 1
two              -> 2
three            -> 3
four             -> 4
five             -> 5
six              -> 6
seven            -> 7
eight            -> 8
nine             -> 9
ten              -> 10
eleven           -> 11
twelve           -> 12
thirteen         -> 13
fourteen         -> 14
fifteen          -> 15
sixteen          -> 16
seventeen        -> 17
eighteen         -> 18
nineteen         -> 19
twenty           -> 20
twenty-one       -> 21
twenty-two       -> 22
twenty-three     -> 23
twenty-four      -> 24
twenty-five      -> 25
twenty-six       -> 26
twenty-seven     -> 27
twenty-eight     -> 28
twenty-nine      -> 29
thirty           -> 30
thirty-one       -> 31
thirty-two       -> 32
thirty-three     -> 33
thirty-four      -> 34
thirty-five      -> 35
thirty-six       -> 36
thirty-seven     -> 37
thirty-eight     -> 38
thirty-nine      -> 39
forty            -> 40
forty-one        -> 41
forty-two        -> 42
forty-three      -> 43
forty-four       -> 44
forty-five       -> 45
forty-six        -> 46
forty-seven      -> 47
forty-eight      -> 48
forty-nine       -> 49
fifty            -> 50
fifty-one        -> 51
fifty-two        -> 52
fifty-three      -> 53
fifty-four       -> 54
fifty-five       -> 55
fifty-six        -> 56
fifty-seven      -> 57
fifty-eight      -> 58
fifty-nine       -> 59
sixty            -> 60
sixty-one        -> 61
sixty-two        -> 62
sixty-three      -> 63
sixty-four       -> 64
sixty-five       -> 65
sixty-six        -> 66
sixty-seven      -> 67
sixty-eight      -> 68
sixty-nine       -> 69
seventy          -> 70
seventy-one      -> 71
seventy-two      -> 72
seventy-three    -> 73
seventy-four     -> 74
seventy-five     -> 75
seventy-six      -> 76
seventy-seven    -> 77
seventy-eight    -> 78
seventy-nine     -> 79
eighty           -> 80
eighty-one       -> 81
eighty-two       -> 82
eighty-three     -> 83
eighty-four      -> 84
eighty-five      -> 85
eighty-six       -> 86
eighty-seven     -> 87
eighty-eight     -> 88
eighty-nine      -> 89
ninety           -> 90
ninety-one       -> 91
ninety-two       -> 92
ninety-three     -> 93
ninety-four      -> 94
ninety-five      -> 95
ninety-six       -> 96
ninety-seven     -> 97
ninety-eight     -> 98
ninety-nine      -> 99
one hundred      -> 100

Comments

एक बिल्ट-इन के बारे में आधा काम क्या करता है, उदाहरण के लिए एक कोडपॉइंट का यूनिकोड नाम खोजना।

— ब्रैड गिल्बर्ट 21

@ ब्रैडगिल्बर्ब २गिल्स नहीं, यह ठीक नहीं है।

— बॉब

Answer 1

सी, 160 बाइट्स

g(char*s){char i=1,r=0,*p="k^[#>Pcx.yI<7CZpVgmH:o]sYK$2";for(;*s^'-'&&*s;r+=*s++|9);r=r%45+77;for(;*p!=r;p++,i++);return((*s^'-')?0:g(s+1))+(i<21?i:10*(i-18));}

झसे आज़माओ

int main ()
{
    char* w[] = {"", "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", "thirty-three", "thirty-four", "thirty-five", "thirty-six", "thirty-seven", "thirty-eight", "thirty-nine", "forty", "forty-one", "forty-two", "forty-three", "forty-four", "forty-five", "forty-six", "forty-seven", "forty-eight", "forty-nine", "fifty", "fifty-one", "fifty-two", "fifty-three", "fifty-four", "fifty-five", "fifty-six", "fifty-seven", "fifty-eight", "fifty-nine", "sixty", "sixty-one", "sixty-two", "sixty-three", "sixty-four", "sixty-five", "sixty-six", "sixty-seven", "sixty-eight", "sixty-nine", "seventy", "seventy-one", "seventy-two", "seventy-three", "seventy-four", "seventy-five", "seventy-six", "seventy-seven", "seventy-eight", "seventy-nine", "eighty", "eighty-one", "eighty-two", "eighty-three", "eighty-four", "eighty-five", "eighty-six", "eighty-seven", "eighty-eight", "eighty-nine", "ninety", "ninety-one", "ninety-two", "ninety-three", "ninety-four", "ninety-five", "ninety-six", "ninety-seven", "ninety-eight", "ninety-nine", "one hundred"};

    int n;
    for (n = 1; n <= 100; n++)
    {
        printf ("%s -> %d\n", w[n], g(w[n]));
        if (n != g(w[n]))
        {
            printf ("Error at n = %d", n);
            return 1;
        }
    }
    return 0;
}

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

कुछ प्रयासों के बाद, मैं एक समारोह है कि नक्शे "असाधारण" संख्या पाया one, two, three, four, five, six, seven, eight, nine, ten, eleven, twelve, thirteen, fourteen, fifteen, sixteen, seventeen, eighteen, nineteen, twenty, thirty, forty, fifty, sixty, seventy, eighty, ninety, one hundred, प्रिंट योग्य ASCII वर्ण के लिए k, ., [, <, *, , c, K, w, y, e, (, S, _, -, C, ), 7, =, 4, &,o, ], s, Y, g, m, N, क्रमशः।

यह समारोह है:

char hash (char* s)
{
    char r = 0;

    while (*s)
    {
        r += *s|9;
        s++;
    }

    return r%45+77;
}

गॉल्फर्ड प्रोग्राम hashइनपुट के कार्य की गणना तब तक करता है जब तक कि यह स्ट्रिंग या वर्ण के अंत तक नहीं पहुंच जाता -। फिर यह हैश को स्ट्रिंग में खोजता है k.[<* cKwye(S_-C)7=4&o]sYgmNऔर इसी संख्या को निर्धारित करता है। यदि इनपुट स्ट्रिंग का अंत नंबर तक पहुंच गया था, यदि इसके बजाय -पहुंच गया था, तो यह नंबर वापस कर दिया गया है और बाकी इनपुट स्ट्रिंग पर लागू किए गए गोल्फ प्रोग्राम का परिणाम है।

Comments

मैं सोच रहा हूं, अगर सी का एक गोल्फ संस्करण था, तो यह वास्तव में सीजम पाइथ जप्ट आदि जैसी भाषाओं को हरा सकता है ...

— बसुकक्सुआन

Answer 2

जावास्क्रिप्ट (ईएस 6), 175 166 163 156 153 147 बाइट्स

7 बाइट्स @Neil की बदौलत सहेजे गए

a=>+a.replace(/.+te|.*el|y$/,x=>x[1]?'on-'+x:'-d').split(/ |-|dr/).map(x=>"un|d,on|le,w,th,fo,f,x,s,h,i,".split`,`.findIndex(y=>x.match(y))).join``

इसे यहां सत्यापित करें:

f=a=>+a.replace(/.+te|.*el|y$/,x=>x[1]?'on-'+x:'-d').split(/ |-|dr/).map(x=>"un|d,on|le,w,th,fo,f,x,s,h,i,".split`,`.findIndex(y=>x.match(y))).join``;

document.body.innerHTML="<pre>"+["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","thirty-three","thirty-four","thirty-five","thirty-six","thirty-seven","thirty-eight","thirty-nine","forty","forty-one","forty-two","forty-three","forty-four","forty-five","forty-six","forty-seven","forty-eight","forty-nine","fifty","fifty-one","fifty-two","fifty-three","fifty-four","fifty-five","fifty-six","fifty-seven","fifty-eight","fifty-nine","sixty","sixty-one","sixty-two","sixty-three","sixty-four","sixty-five","sixty-six","sixty-seven","sixty-eight","sixty-nine","seventy","seventy-one","seventy-two","seventy-three","seventy-four","seventy-five","seventy-six","seventy-seven","seventy-eight","seventy-nine","eighty","eighty-one","eighty-two","eighty-three","eighty-four","eighty-five","eighty-six","eighty-seven","eighty-eight","eighty-nine","ninety","ninety-one","ninety-two","ninety-three","ninety-four","ninety-five","ninety-six","ninety-seven","ninety-eight","ninety-nine","one hundred"].map((x,y)=>'f("'+x+'") === '+f(x)+"? "+(f(x)===y+1)).join("<br>")+"</pre>"

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

मूल विचार प्रत्येक संख्या को उसके अंकों-शब्दों में विभाजित करना है, फिर प्रत्येक शब्द को संबंधित अंक में मैप करना है। लगभग सभी शब्दों को एक सरल रीगेक्स के साथ ठीक से मिलान करने के लिए सेट किया गया है, लेकिन कुछ विसंगतियाँ हैं:

• elevenके माध्यम से nineteen: अगर शब्द एक होता है el, या एक teमध्य (से बचने के लिए ten), हम एक जोड़ने के on-आरंभ में, करने के लिए इन बदलते on-elevenके माध्यम से on-nineteen।
• twenty, thirty, आदि .: पीछे की जगह yके साथ -dपरिवर्तन इन करने के लिए twent-d, thirt-dआदि

अब हम हाइफ़न, स्पेस और drएस में विभाजित हो गए । यह 11 से 99 तक के सभी अंकों को अपने संबंधित अंकों-शब्दों में विभाजित करता है, और "one hundred"में [one,hun,ed]। फिर हम इन शब्दों में से प्रत्येक को रेगेक्स की एक सरणी के माध्यम से मैप करते हैं, और पहले से मेल खाने वाले के सूचकांक को रखते हैं।

0: /un|d/ - This matches the "hun" and "ed" in 100, as well as the "d" we placed on the end of 20, 30, etc.
1: /on|le/ - Matches "one" and the "on" we placed on the beginning of 11 through 19, along with "eleven".
2: /w/ - Matches "two", "twelve", and "twenty".
3: /th/ - Matches "three" and "thirty".
4: /fo/ - Matches "four" and "forty".
5: /f/ - "five" and "fifty" are the only words by now that contain an "f".
6: /x/ - "six" and "sixty" are the only words that contain an "x".
7: /s/ - "seven" and "seventy" are the only words by now that contain an "s".
8: /h/ - "eight" and "eighty" are the only words by now that contain an "h".
9: /i/ - "nine" and "ninety" are the only words by now that contain an "i".
10: /<empty>/ - "ten" is the only word left, but it still has to be matched.

अब तक, प्रत्येक और प्रत्येक इनपुट उचित अंकों का सरणी होगा। बस हमें उनके साथ जुड़ना होगा join``, एक नंबर के साथ यूरीरी में बदलना होगा +, और हम कर रहे हैं।

Comments

कृपया समझाएँ।

— बॉब

@ याकूब ज़रूर, स्पष्टीकरण जोड़ा गया।

— ETHproductions

.findIndex(y=>x.match(y))काम नहीं करता है?

— नील

@ नील मुझे एहसास नहीं था कि होगा, लेकिन यह करता है, धन्यवाद!

— ETHproductions

मुझे पूरा यकीन है कि तुम उर्फ ​​हो सकते हो replace।

— मामा फन रोल

Answer 3

श + कोरुटिल्स, 112 बाइट्स

एक बार में सभी टेस्टेसिस पर चलाया जा सकता है, प्रति पंक्ति एक।

sed -r "`awk '$0="s/"$0"/+"NR"/g"'<<<"on
tw
th
fo
fi
si
se
ei
ni
te|lv
el"`
s/ /y0/
s/y/*10/
s/^\+|[a-z-]//g"|bc

व्याख्या

बैकटाइप स्क्रिप्ट का awkमूल्यांकन करता हैsed

s/on/+1/g       # one, one hundred
s/tw/+2/g       # two, twelve, twenty
s/th/+3/g       # three, thirteen, thirty
s/fo/+4/g       # ...
s/fi/+5/g
s/si/+6/g
s/se/+7/g
s/ei/+8/g
s/ni/+9/g
s/te|lv/+10/g   # ten, -teen, twelve
s/el/+11/g      # eleven

जो संख्याओं के कुछ हिस्सों को उनके संख्यात्मक प्रतिनिधित्व में बदल देता है।

fife            ->    +5ve
ten             ->    +10n
eleven          ->    +11even
twelve          ->    +2e+10e
sixteen         ->    +6x+10en
thirty-seven    ->    +3irty-+7ven
forty-four      ->    +4rty-+4ur
eighty          ->    +8ghty
one hundred     ->    +1e hundred

सिड स्क्रिप्ट की अतिरिक्त लाइनें

s/ /y0/
s/y/*10/

-tyएस और का ख्याल रखना one hundred।

+3irty-+7ven    ->    +3irt*10-+7ven
+4rty-+4ur      ->    +4rt*10-+4ur
+8ghty          ->    +8ght*10
+1e hundred     ->    +1ey0hundred      ->    +1e*100hundred

अंत में, अग्रणी +s और जो कुछ भी नहीं है +, *या एक अंक निकालें ।

s/^\+|[a-z-]//g"

केवल गणित के भाव रह गए हैं

fife            ->    5
sixteen         ->    6+10
forty-four      ->    4*10+4
eighty          ->    8*10
one hundred     ->    1*100

और में पाइप किया जा सकता है bc।

Answer 4

पायथ, 79 76 75 68 बाइट्स

7 बाइट्स के लिए @ETHproductions को धन्यवाद दें।

?}"hu"z100sm*+hxc."ewEСBu­["2<d2?|}"een"d}"lv"dTZ?}"ty"dT1cz\-

मूल रूप से पहले 100 के कोने के मामले की जांच करता है, फिर इनपुट के शब्दार्थ निर्धारित करने और प्रत्यय ("-ty" और "-इंटर" के अनुसार मूल्य को संशोधित करने के लिए 0 से 11 के पहले दो अक्षरों की एक सरणी का उपयोग करता है;) lv "12 में एक और कोने का मामला है)।" पहले इनपुट को शब्दों की सूची में विभाजित करता है, फिर प्रत्येक को एक मान में मैप करता है, और उन्हें योग करता है।

पायथोनिक स्यूडोकोड में:

                           z = input()    # raw, unevaluated
                           Z = 0
                           T = 10
?}"hu"z                    if "hu" in z:  # checks if input is 100
  100                        print(100)
                           else:
sm                           sum(map( lambda d: # evaluates each word, then sum
  *                            multiply(
   +hxc."ewEСBu­["2<d2           plusOne(chop("ontwth...niteel",2).index(d[:2])) + \
                                 # chops string into ["on","tw",..."el"]
                                 # ."ewEСBu­[" is a packed string
     ?|}"een"d}"lv"dTZ               (T if "een" in d or "lv" in d else Z),
                                     # add 10 for numbers from 12 to 19
   ?}"ty"dT1                     T if "ty" in d else 1),  # times 10 if "-ty"
  cz\-                         z.split("-"))  # splits input into words

परीक्षण सूट

---

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

z=input()
if "hu" in z:print(100);exit()
print(sum(map(lambda d:([0,"on","tw","th","fo","fi","si","se","ei","ni","te","el"].index(d[:2])+(10 if "een" in d or "lv" in d else 0))*(10 if "ty" in d else 1),z.split("-"))))

मूल रूप से पायथ उत्तर के समान।

---

विषय से परे:

मैंने जीवन, ब्रह्मांड और सब कुछ के उत्तर का एक सार्थक संस्करण खोजा: यह चाय-प्यासा टहनियाँ हैं। वाह, टहनियाँ जो चाय के लिए तरस रही हैं! मुझे यकीन नहीं है कि कितने अन्य उत्तर ऐसा करते हैं, लेकिन मेरे जवाब के लिए यदि इनपुट "चाय-प्यासा-टहनियाँ" है तो आउटपुट 42 है।

Comments

मेरा मानना ​​है कि आप पैक्ड स्ट्रिंग का उपयोग करके सात बाइट्स बचा सकते हैं । आउटपुट को कॉपी करें और इसे "ontwthfofisiseeiniteel"इस कार्यक्रम के स्थान पर रखें ।

— ETHproductions

@ETHproductions वाह, धन्यवाद! पिछली बार जब मैंने जाँच की थी, तब भी स्ट्रिंग के सिर पर "ज़ी" था, और पैकिंग काम नहीं कर सकती थी। एक बार और जाँचने के बाद मैंने उसे बाहर नहीं निकाला। फिर से, धन्यवाद xD

— बसुक्सुआन

@ETHproductions हाँ मैंने वास्तव में किया था, यह छद्म कोड के तहत है।

— बसुकक्सुआन

Answer 5

पायथन 3, 365 361 310 303 अक्षर

golfed

def f(a):
 y=0
 for i in a.split("-"):
  x="one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir;four;fif;six;seven;eigh;nine;twenty,thirty,forty,fifty,sixty,seventy,eighty,ninety,one hundred".replace(";","teen,").split(",").index(i)
  y+=x+1 if x<20 else range(30,110,10)[x-20]
 return y

Ungolfed

 def nameToNumber (numberName):
    names = ["one","two","three","four","five","six","seven","eight","nine","ten","eleven","twelve","thirteen",
             "fourteen","fifteen","sixteen","seventeen","eighteen","nineteen","twenty","thirty","forty","fifty",
             "sixty","seventy","eighty","ninety","one hundred"]
    numbers = range(30, 110, 10)
    number = 0
    for n in numberName.split("-"):
        x = names.index(n)
        number += x + 1 if x < 20 else numbers[x - 20]
    return number

Comments

45 अक्षर छोटे: n="one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thirteen,fourteen,fifteen,sixteen,seventeen,eighteen,nineteen,twenty,thirty,forty,fifty,sixty,seventy,eighty,ninety,one hundred".split(",")लेकिन जैसा कि मैं देख रहा हूं, इसे बिना वेरिएबल एन को असाइन किए बिना काम करना चाहिए, बस .index()सीधे कॉल करें ।

— 16

7 अक्षर छोटे "one,two,three,four,five,six,seven,eight,nine,ten,eleven,twelve,thir;four;fif;six;seven;eigh;nine;twenty,thirty,forty,fifty,sixty,seventy,eighty,ninety,one hundred".replace(";","teen,").split(","):।

— १६

StackExchange साइट इंजन में एक चिड़चिड़ापन आदत है: यह टिप्पणियों में पोस्ट किए गए कोड में अदृश्य अक्षर (U200C शून्य चौड़ाई गैर-योजक और U200B शून्य चौड़ाई स्थान) सम्मिलित करता है। आपने उन्हें भी कॉपी-पेस्ट किया। मैंने उन्हें हटाने के लिए आपकी पोस्ट संपादित की।

— manatwork

Answer 6

हास्केल, 252 231 बाइट्स

let l=words;k=l"six seven eight nine";w=l"one two three four five"++k++l"ten eleven twelve"++((++"teen")<$>l"thir four fif"++k)++[n++"ty"++s|n<-l"twen thir for fif"++k,s<-"":['-':x|x<-take 9w]]in maybe 100id.flip lookup(zip w[1..])

यह "एक" से "निन्यानवे" तक सभी अंग्रेजी नंबर नामों की एक सूची बनाता है और फिर इनपुट के सूचकांक को देखता है। यदि यह मौजूद नहीं है, तो हम किनारे के मामले में "एक सौ" हैं, इसलिए यह वापस आ जाता है 100, अन्यथा यह सूचकांक वापस करने जा रहा है।

Ungolfed

-- k in the golfed variant
common = words "six seven eight nine" 

-- w in the golfed variant
numbers = words "one two three four five" ++ common
       ++ words "ten eleven twelve" ++ [p ++ "teen" | p <- words "thir four fif" ++ common]
       ++ [p ++ "ty" ++ s| p <- words "twen thir for fif" ++ common
                         , s <- "" : map ('-':) (take 9 numbers)]

-- part of the expression in the golfed variant
convert :: String -> Int
convert s = maybe 100 id $ lookup s $ zip numbers [1..]

Answer 7

पायथन 2, 275 वर्ण

def x(n):a='one two three four five six seven eight nine ten eleven twelve'.split();t='twen thir four fif six seven eigh nine'.split();b=[i+'teen'for i in t[1:]];c=[i+'ty'for i in t];return(a+b+[i+j for i in c for j in ['']+['-'+k for k in a[:9]]]+['one hundred']).index(n)+1

यह सरल हर संख्या की एक सूची बनाता है और सूचकांक पाता है।

Answer 8

जाप, 82 बाइट्स

+Ur`(.+)¿``¿-$1` r"y$""-d" q$/ |-|dr/$ £`un|Üaiwo|ØÏ¿ifoifix¿iÊ¿¿e¿iv`qi b_XfZ}Ãq

प्रत्येक ¿एक अनपेक्षित चार का प्रतिनिधित्व करता है। इसे ऑनलाइन टेस्ट करें!

मेरे जेएस जवाब के आधार पर। एक बाइट घटाना अगर उत्पादन एक पूर्णांक होने की जरूरत नहीं है, क्योंकि यह बिल्कुल एक स्ट्रिंग के रूप में दिखाई देगा।

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

+Ur`(.+)¿` `¿-$1`  r"y$""-d" q/ |-|dr/ £  `un|Üaiwo|ØÏ¿ifoifix¿iÊ¿¿e¿iv`          qi b_ XfZ}à q
+Ur"(.+)te""on-$1" r"y$""-d" q/ |-|dr/ mX{"un|dioniwo|wenithifoifixisihineiteiniv"qi bZ{XfZ}} q

Ur"(.+)te""on-$1" // Replace "thirteen", "fourteen", etc. with "on-thiren", "on-fouren", etc.
r"y$""-d"         // Replace "twenty", "thirty", etc. with "twent-d", "thirt-d", etc.
q/ |-|dr/         // Split at occurances of a space, hyphen, or "dr". By now,
                  // "one", "thirteen", "twenty", "sixty-six", "one hundred" will have become:
                  // "one", "on" "thiren", "twent" "d", "sixty" "six", "one" "hun" "ed"
mX         }      // Map each item X in the resulting array to:
"..."qi           //  Take this string, split at "i"s,
b_XfZ}            //  and find the first item Z where X.match(RegExp(Z)) is not null.
                  //  See my JS answer to learn exactly how this works.
                  // Our previous example is now
                  // "1", "1" "3", "2" "0", "6" "6", "1" "0" "0"
+              q  // Join and convert to integer.
                  // 1, 13, 20, 66, 100

Answer 9

जावास्क्रिप्ट, 214 199 बाइट्स

हमेशा की तरह: यह पता चला है कि यह प्रतिस्पर्धा करने के लिए बहुत लंबा है, लेकिन अब जब मैंने ऐसा किया है तो यह पोस्ट नहीं करना एक बेकार होगा।

शायद गोल्फ का एक स्पष्ट तरीका यह है कि आगे मैंने अनदेखी की है?

e=s=>s.slice(-1)=='d'?100:'  ontwthfofisiseeinite'.indexOf(s.slice(0,2))/2;f=s=>([t,u]=s.split('-'),~s.indexOf`le`?11:~s.indexOf`lv`?12:e(t)+(t.slice(-3)=='een')*10+''+(u?e(u):t.slice(-1)=='y'?0:''))

परीक्षण मामलों के लिए JSFiddle

Comments

कैसे बदल रहा fहै f=s=>([t,u]=s.split('-'),~s.indexOf('le')?11:~s.indexOf('lv')?12:e(t)+(t.slice(-3)=='een')*10+''+(u?e(u):t.slice(-1)=='y'?0:''))? इसके अलावा, एक एकल स्ट्रिंग तर्क को एक समारोह में पारित किया जा सकता है जैसे:s.indexOf`lv`

— ETHproductions

@ETHproductions यह बहुत अच्छा है, धन्यवाद! मुझे नहीं पता था कि JS के पास अल्पविराम ऑपरेटर था, और स्ट्रिंग पासिंग के लिए आशुलिपि वास्तव में उपयोगी है।

— vvye

Answer 10

पर्ल, 158 बाइट्स

@s=split/(\d+)/,'te1ten0l1le1on1tw2th3fo4fi5si6se7ei8ni9d00';foreach(split'-',$n=$ARGV[0]){for($i=0;$i<$#s;$i+=2){m/$s[$i]/&&print$s[$i+1]}}$n=~/ty$/&&print 0

कमांड लाइन से चलता है। इसे दो इनपुट के रूप में व्याख्या one hundredकिए जाने "one hundred"से रोकने के लिए दर्ज किया जाना चाहिए ।