तुम 8 दिन की लकीर पर हो!

Question

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

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

संभवतः डुओलिंगो देव टीम ने इस बग को छोड़ दिया क्योंकि वे ऐप में अधिक स्रोत कोड के लिए अंतरिक्ष से बाहर भाग गए थे, इसलिए आपको इस कोड को जितना संभव हो उतना कम बनाने की आवश्यकता है ताकि वे इसे निचोड़ सकें।

आपका कोड 0 से 2,147,483,647 और आउटपुट aया एक पूर्णांक लेना चाहिए an। एक अनुगामी न्यूलाइन वैकल्पिक है। इस चुनौती के प्रयोजनों के लिए, 1863 को एक हजार आठ सौ इकतीस के रूप में पढ़ा जाता है , न कि अठारह सौ तिहत्तर पर ।

परीक्षण के मामलों:

0 → a
8 → an
11 → an
18 → an
84 → an
110 → a
843 → an
1111 → a
1863 → a
8192 → an
11000 → an
18000 → an
110000 → a
180000 → a
1141592 → a
1897932 → a
11234567 → an
18675309 → an

Comments

क्या यह डुओलिंगो द्वारा समर्थित है? यदि नहीं, तो आपको उन्हें भाषा सीखने की साइट पर भाषा में सुधार के लिए हमें भुगतान करना चाहिए।

— आर्क

है 1100 (एक) ग्यारह सौ या (एक) एक हजार एक सौ ?

— user3819867

बिल्बो आपके कुछ परीक्षण मामलों से असहमत होगी। :)

— मार्टिन एंडर

@ ज़ैबिस: "यहाँ" का उच्चारण "वुन" की तरह किया जाता है, जिसमें एक ध्वनि होती है। इसलिए, " एक से एक हजार एक सौ दिन लकीर"।

— एल'एंडिया स्ट्रैटन

उन्होंने शायद इस बग को छोड़ दिया क्योंकि उन्हें लगा कि कोई भी 8 दिन की लकीर तक नहीं पहुंचेगा।

— पीएनडीए

Answer 1

पायथ, 23 बाइट्स

<>n\8hz}hjsz^T3,hT18"an

यह जाँचता है कि "an"पहला अक्षर नहीं है या नहीं, यह जांचने से अंत में बंद करने के लिए कितने अक्षर आते हैं 8और आधार 1000 में विचार किए जाने पर संख्या का पहला अंक 11 या 18 नहीं है। परिणामी बूलियन वर्णों की संख्या है जिसे टुकड़ा करना है समाप्त।

Comments

बहुत रचनात्मक। इसके अलावा, भयानक।

— हेलरएवर

Answer 2

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

lambda n:'a'+'n'[:`n`[0]=='8'or`n`[:2]in len(`n`)%3/2*'118']

एक अनाम फ़ंक्शन। nअगर या तो जोड़ता है :

• पहला अंक 8 है
• पहले दो अंक 11 या 18 हैं, और लंबाई 2 मोडुलो 3 है।

Comments

मुझे पता है कि यह एक सुपर पुराना सवाल है, लेकिन मुझे लगता है कि `` n> = '8' `` तीन बाइट्स बचाता है।

— लिन

@ लियोन कि गड़बड़ नहीं करेगा, हालांकि?

— xnor

ओह बेशक! मुझे टेस्ट सूट द्वारा बेवकूफ बनाया गया था :)

— लिन

Answer 3

GNU Sed, 32

स्कोर में -Esed के विकल्प के लिए +1 शामिल है ।

s/^8.*|^1[18](...)*$/an/
t
ca
:

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

• प्रत्येक संख्या के अंत से 3 अंकों के समूह निकालें जब तक कि केवल 1 से 3 अंक शेष न हों
• 8 या ठीक 11 या 18 से शुरू होने वाली किसी भी संख्या से मिलान करें और बदल दें an
• अन्य सभी नंबरों को बदल दें a

@ रेटिना दृष्टिकोण के लिए @ मार्टिनबटनर का धन्यवाद जिसने 10 बाइट्स बचाए।

Answer 4

शेल + बीएसडी-गेम, 30

number -l|sed '/^e/{can
q};ca'

इनपुट STDIN से पढ़ा जाता है।

numberदशमलव स्ट्रिंग को शब्दों में परिवर्तित करता है। फिर यह तय करना एक साधारण मामला है कि क्या परिणाम के साथ शुरू होता है या नहीं e।

Comments

+1 bsd- गेम का उपयोग करने के लिए, मैंने वास्तव में नहीं सोचा था कि वे कभी भी उपयोगी होंगे :)

— ASCIIThenANSI

@ASCIIThenANSI हां, bsd- गेम्स यहां और वहां उपयोगी हैं :)

— डिजिटल ट्रॉमा

Answer 5

रेटिना , 27 बाइट्स

यह DigitalTrauma के रेटिना उत्तर से बहुत अलग नहीं है, लेकिन उन्होंने जोर देकर कहा कि मैं इसे स्वयं पोस्ट करता हूं।

^8.*|^1[18](...)*$
an
\d+
a

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

पहला रेगेक्स सभी संबंधित नंबरों को बदल देता है an, और दूसरा सभी शेष नंबरों को बदल देता है a। यह एक ही बाइट्स के लिए काम करता है:

^8.*|^1[18](...)*$
n
^\d*
a

Comments

+1 यह प्राइमलिटी परीक्षण के रूप में रेगेक्स के दुरुपयोग का लगभग समान स्तर है :)

— बिल्ली

और अच्छी बात यह है, डुओलिंगो वास्तव में रेटिना में लिखा गया है इसलिए इसे एकीकृत करने के लिए एक हवा होनी चाहिए। या रुको, यह कौन सी भाषा थी?

— को चालू

@ceasedtoturncounterclockwis मुझे बताया जा रहा है कि यह वास्तव में हेक्सागोनी में लिखा गया है, लेकिन उन्होंने रेटिना-टू-हेक्सागोनी ट्रांसपिलर लिखा है, इसलिए यह एक मुद्दा नहीं होना चाहिए।

— मार्टिन एंडर

Answer 6

सी ++, 101

यह मेरी चुनौती है, इसलिए इसका कोई प्रतिस्पर्धी जवाब नहीं है। बस यह देखना चाहता था कि मैं इसे C ++ में कितना छोटा कर सकता हूं। स्ट्रिंग ऑपरेशन केवल बहुत अधिक क्रियात्मक हैं इसलिए यह गणित के साथ किया जाता है। मुझे लगता है कि उस स्थिति को छोटा करने का एक तरीका होना चाहिए, लेकिन मैं इसे समझ नहीं पा रहा हूं।

const char*f(int i){int n=0,d=0;for(;i;(!(d++%3)&(i==18|i==11))|i==8?n=1:0,i/=10);return n?"an":"a";}

Answer 7

मैथेमेटिका, 53 बाइट्स

If[#~IntegerName~"Words"~StringStartsQ~"e","an","a"]&

स्ट्रिंग प्रसंस्करण का उपयोग करने वाला एक समाधान वास्तव में लंबा होगा।

Answer 8

पोस्टस्क्रिप्ट, 119 113 वर्ण

10 string cvs dup 0 get 56 eq exch dup length 3 mod 2 eq{0 2 getinterval dup(11)eq exch(18)eq or or}{pop}ifelse

परीक्षण कोड के साथ:

/An
{
    10 string cvs dup 0 get 56 eq exch dup length 3 mod 2 eq{0 2 getinterval dup(11)eq exch(18)eq or or}{pop}ifelse
} def

/ShouldBeFalse [ 0 110 1111 1863 110000 180000 1141592 1897932 ] def
/ShouldBeTrue [ 8 11 18 84 843 8192 11000 18000 11234567 18675309 ] def

() = (ShouldBeFalse) = ShouldBeFalse {An =} forall
() = (ShouldBeTrue)  = ShouldBeTrue  {An =} forall

Answer 9

जावास्क्रिप्ट (ईएस 6) 70 61 46 38 बाइट्स

n=>/^8|^1[18](...)*$/.test(n)?'an':'a'

सामुदायिक विकी क्योंकि वर्तमान समाधान मेरे मूल से बहुत अलग है। सभी को धन्यवाद!

डेमो: http://www.es6fiddle.net/iio40yep/

Comments

यह समझ आता है। समझाने के लिए धन्यवाद।

— डेनियल एफ

@Pavlo बहुत अच्छा, मैं evalट्रिक की खोज के बाद सिंगल एक्सप्रेशंस के बारे में भूल गया ! मुझे पता था कि वहाँ एक बेहतर नियमित अभिव्यक्ति होनी चाहिए, लेकिन मैं कुछ भी समझ नहीं पाया जो छोटा था। धन्यवाद!

— स्कॉट

@ पावलो स्वीट, फिर से अपडेट किया गया! बहुत कुछ सीखना, बहुत बहुत धन्यवाद :)

— स्कॉट

Urgh! 2 बाइट शेव करना भूल गए! यहाँ अंतिम एक है: n=>/^8|^(?=1[18])..(\d{3})*$/.test(n)?'an':'a'( es6fiddle.net/iiehl1ex )। यह 46 बाइट लंबा है।

— इस्माइल मिगुएल

@ScottKaye कोड बहुत सरल है: यदि यह इसके साथ शुरू होता है 8, अगर यह इसके साथ शुरू होता है 1[18]और संख्याओं की लंबाई है , तो यह जाँच करता है 2 * (3n)। मूल रूप से, यह आपका पूरा कोड है, लेकिन एक नियमित अभिव्यक्ति के भीतर।

— इस्माइल मिगुएल

Answer 10

गंभीरता से, 43 40 बाइट्स

9⌐9τk,;;$l3@\3*╤@\(íub)$#p'8=)XkΣ'n*'a+

यहाँ रणनीति केवल 1, 2, या 3 सबसे महत्वपूर्ण अंकों को देखना है, जो इनपुट से 10^(3n)कम के सबसे बड़े मूल्य से इनपुट को विभाजित करके ।

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

स्पष्टीकरण:

9⌐9τk,;;$l3@\3*╤@\(íub)$#p'8=)XkΣ'n*'a+
9⌐9τk                                    push [11, 18]
     ,;;                                 push 3 copies of input (n)
        $l                               get length of n as string (effectively floor(log(n,10)))
          3@\3*╤                         get largest 10^(3n) less than the length
                @\                       get most significant digits of n (x)
                  (í                     bring list from back, push the index of x in the list or -1 if not in list
                    ub)                  increment by 1, convert to boolean, shove to bottom
                       $#p               push first digit from n (as string)
                          '8=            push 1 if "8" else 0
                             )X          shove to bottom of stack, discard remaining digits
                               kΣ'n*     push sum of stack, push a string containing that many "n"s
                                    'a+  push "a", concatenate

Answer 11

रेटिना , ३४

मेरे sed उत्तर का सीधा अनुवाद :

+`(.)...$
$1
^8.*|^1[18]$
an
\d+
a

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

एक बाइट ने @Timwi को धन्यवाद दिया।

Answer 12

पर्ल 6 ,  31   30 बाइट्स

{'a'~'n'x?/^8|^1<[18]>[...]*$/} # 31 bytes

{<a an>[?/^8|^1<[18]>[...]*$/]} # 31 bytes

{<a an>[?/^8|^[11|18][...]*$/]} # 31 bytes

{'a'~'n'x?/^8|^1[1|8][...]*$/} # 30 bytes

{<a an>[?/^8|^1[1|8][...]*$/]} # 30 bytes

(पर्ल 6 [ ]गैर-कैप्चरिंग के लिए रेगीक्स में उपयोग करता है ( ), और <[ ]>चरित्र सेट के लिए उपयोग करता है)

उपयोग:

# store it in a lexical code variable for ease of use
my &code = {...}

my @a  = <0 110 1111 1863 110000 180000 1141592 1897932>;
my @an = <8 11 18 843 8192 11000 18000 11234567 18675309>;

say @a.map: &code;
say @an.map: &code;

(a a a a a a a a)
(an an an an an an an an an)

Answer 13

पोस्टस्क्रिप्ट, 109 बाइट्स

(a)exch 10 string cvs dup[exch length 3 mod 2 eq{(11)(18)}if(8)]{anchorsearch{pop pop(an)exch}if}forall pop =

यदि कोड कुछ उपसर्गों से शुरू होता है तो कोड सत्यापित करता है। उपसर्ग 8को हमेशा चेक किया जाता है ( आठ , अस्सी-कुछ , आठ-सैकड़ों-और ), लेकिन 11और 18( ग्यारह और अठारह ) केवल तभी जांचे जाते हैं जब अंकों की संख्या 3 से अधिक 2 की संख्या होती है।

हम एक अस्थायी परिणाम के साथ शुरू करते हैं aऔर जब एक उपसर्ग पाया जाता है तो परिणाम को बदल दिया जाता है an। anchorsearchस्ट्रिंग से एक उपसर्ग निकालने से बचने के लिए उपयोग किया जाता है। अगर कोई मैच पाया जाता है तो भी हम बाकी सब उपसर्गों को सत्यापित करना जारी रखते हैं - क्यों 5 बाइट बर्बाद करते हैं  exit? -, लेकिन क्योंकि मूल स्ट्रिंग को aहमारे साथ बदल दिया जाता है, हमें यकीन है कि कोई भी गलत सकारात्मकता नहीं मिलेगी।

a-ओर लौटने के लिए- anइसे प्रिंट करने के बजाय ऑपरैंड स्टैक पर परिणाम करें, अनुगामी  =(परिणामी लंबाई: 107 बाइट्स) को हटा दें ।

टेस्ट कोड:

/DO {
    ... the code above ...
} def

(Should be "a"s:)  = {0 110 1111 1863 110000 180000 1141592 1897932}     { DO } forall
(Should be "an"s:) = {8 11 18 84 843 8192 11000 18000 11234567 18675309} { DO } forall
flush

Answer 14

पोस्टस्क्रिप्ट (बाइनरी टोकन के साथ), 63 बाइट्स

(a)’>10’¥’1’8[’>’b3’j2’={(11)(18)}if(8)]{’${’u’u(an)’>}if}’I’u=

’मूल्य 146 (दशमलव) के साथ बाइट्स हैं, ¥एक 165 है और $एक 3. अन्य सभी प्रिंट करने योग्य 7-बिट ASCII चरित्र है।

यह मेरे पोस्टस्क्रिप्ट [शुद्ध ASCII] संस्करण के समान है, लेकिन बाइनरी टोकन का उपयोग करता है जहां यह कुल लंबाई को कम करने में मदद करता है। मैं इसे 3 कारणों से अलग-अलग पोस्ट करता हूं:

• सामान्य स्थिति में, एक कार्यान्वयन जो ASCII कोड को कम करता है, जरूरी नहीं कि वह बाइनरी संस्करण को कम करने वाला हो। ASCII पोस्टस्क्रिप्ट कोड के कुछ लंबे टुकड़े दूसरे से बेहतर संपीड़ित कर सकते हैं और इसके संबंधित बाइनरी संस्करण को छोटा किया जा सकता है।
• बाइनरी कोड हर जगह उपयुक्त नहीं है, इसलिए एक शुद्ध ASCII उत्तर को अधिक समय तक पसंद किया जा सकता है।
• बाइनरी एनकोडिंग का उपयोग करके शुद्ध ASCII पोस्टस्क्रिप्ट उत्तर की लंबाई की तुलना करना उचित नहीं होगा।

Answer 15

पायथन 3, 110 93 91 76 74 70 65 64 बाइट्स

यहाँ एक लंबा है, लेकिन एक सरल है।

संपादित करें: isaacg के लिए धन्यवाद के साथ ठीक किया गया । तुलना के बाद कुछ व्हाट्सएप को बचाया। कई बाइट्स के लिए धन्यवाद बचाया Timwi , Mego , benpop और अलिसा ।

n=input();print("a"+"n"*(len(n)%3>1and n[:2]in"118"or"8"==n[0]))

या बाइट्स की समान संख्या के लिए।

n=input();print("a"+"n"[:len(n)%3>1and n[:2]in"118"or"8"==n[0]])

Ungolfed:

def a():
    n=input()
    if "8"==n[:1]:
        a = "n"
    elif len(n)%3 == 2 and (n[:2] in ["11", "18"]):
        a = "n"
    else:
        a = ""
    return "a"+a

Comments

यह इनपुट पर गलत है 843, "आठ सौ चौंसठ", जो होना चाहिए an।

— इसहाक

@isaacg न केवल आप सही हैं, लेकिन यह मेरे कोड को बहुत सरल करता है। धन्यवाद! यह पता चला है कि मैं केवल आठ, आठ हजार, आठ मिलियन को देख रहा था, जबकि अस्सी और आठ सौ जैसे मामलों की अनदेखी कर रहा था।

— शर्लक

(-~len(n)%3)<1इसके बजाय क्यों len(n)%3==2?

— टिमवी

(n[:2]=="11"or n[:2]=="18")को छोटा किया जा सकता है "118".contains(n[:2])?

— टिमवी

या भी n[:2]in"118"?

— तिमवी

Answer 16

जावा 10, 102 बाइट्स

n->{var N=n+"";return(n>9&&"118".contains(N.substring(0,2))&N.length()%3>1)|N.charAt(0)==56?"an":"a";}

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

स्पष्टीकरण:

n->{                  // Method with integer parameter and String return-type
  var N=n+"";         //  Input integer as String
  return(n>9&&        //  If the input has at least two digits,
    "118".contains(N.substring(0,2))
                      //  and the first two digits are "11" or "18",
    &N.length()%3>1)  //  and the length modulo-3 is 2
   |N.charAt(0)==56?  //  Or if the first digit is an '8':
     "an"             //   Return "an"
   :                  //  Else:
     "a";}            //   Return "a"

Answer 17

जाप , 28 27 बाइट्स

'a+'npUì v ¥8ª[B18]d¥UìA³ v

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

अनपैक्ड और यह कैसे काम करता है

'a+'npUì v ==8||[B18]d==UìAp3  v

'a+'np  "a" + "n".repeat(...)
Uì v ==8    First digit in decimal == 8
||          or...
[B18]d      [11,18].some(...)
==UìAp3  v  == First digit in base 10**3

Comments

आप बदल सकते हैं 1e3के साथA³

— ओलिवर

Answer 18

जीएनयू sed -r+ बीएसडी number, 34 बाइट्स

s/(e?).*/number &/e
s//a\1/
y/e/n/

सबसे पहले हम अंग्रेजी नंबर में कनवर्ट करते हैं। फिर एक प्रारंभिक प्रारंभिक को छोड़कर सब कुछ हटा दें e, और साथ उपसर्ग करें a। फिर e(यदि मौजूद है) में परिवर्तित करें n। एकमात्र गोल्फ ट्रिक eपहले प्रतिस्थापन में वैकल्पिक से मेल खाती है , इसलिए हम निम्न पंक्ति में पैटर्न का पुन: उपयोग कर सकते हैं।

डेमो

for i in 0 8 11 18 84 110 843 1111 1863 8192 \
    11000 18000 110000 180000 1141592 1897932 11234567 18675309
do printf "%'10d → %s\n" $i $(./66841.sed <<<$i)
done

         0 → a
         8 → an
        11 → an
        18 → an
        84 → an
       110 → a
       843 → an
     1,111 → a
     1,863 → a
     8,192 → an
    11,000 → an
    18,000 → an
   110,000 → a
   180,000 → a
 1,141,592 → a
 1,897,932 → a
11,234,567 → an
18,675,309 → an

Answer 19

टीस्क्रिप्ट , 35 बाइट्स

[18,11,8,80]I(+xh(x.n%3¶3©?'an':'a'

इसे यहाँ आज़माएँ।

व्याख्या

               xh(x.n%3¶3           get the relevant digits from the input
                                    xh compiles to x.head which returns the
                                    first n chars of x (implicit input)
                                    ¶ ('\xb6') compiles to ||
              +                     cast the result to an integer since
                                    .includes does a strict comparison
                         ©          ('\xa9') compiles to ))
[18,11,8,80]                        array of the special cases
            I(                      I( is an alias for .includes( which
                                    returns true if the array contains the
                                    argument
                          ?'an':'a' finally, return 'an' if the array
                                    contains the number, 'a' otherwise

Answer 20

पायथन 2.7, 66

s=`input()`
print['a','an'][s[:1]=='8'or s[:2]in len(s)%3/2*'118']

जाहिर है कि यह उतना छोटा नहीं है lambda।

Answer 21

05AB1E , 26 बाइट्स

g3%ô¬D11Qs18Q+I1£8Q+>„ans∍

शायद थोड़ा और गोल्फ हो सकता है, लेकिन इसका काम करना।

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

स्पष्टीकरण:

g3%                  # Length of the input, modulo-3
                     #  11234567 → 8 → 2
                     #  110000 → 6 → 0
   ô                 # Split the input into chunks of that size
                     #  11234567 and 2 → ['11', '23', '45', '67']
                     #  110000 and 0 → ['110000']
    ¬                # Take the Head (first element)
                     #  ['11', '23', '45', '67'] → '11'
                     #  ['110000'] → '110000'
     D11Q            # Does it equal 11?
                     #  '11' and 11 → 1
                     #  '110000' and 11 → 0
     s18Q            # Or does it equal 18?
                     #  '11' and 18 → 0
                     #  '110000' and 18 → 0
         +           # Add them together (if it was either 11 or 18, this becomes 1)
                     #  1 and 0 → 1
                     #  0 and 0 → 0
I1£                  # Get the first character of the input
                     #  11234567 → '1'
                     #  110000 → '1'
   8Q                # Does it equal 8?
                     #  '1' and 8 → 0
          +          # Add them together
                     #  1 and 0 → 1
                     #  0 and 0 → 0
           >         # Increase it by 1
                     #  1 → 2
                     #  0 → 1
            „ans∍    # Push "an", and shorten it to a size equal to the result above
                     #  "an" and 2 → "an"
                     #  "an" and 1 → "a"

Answer 22

क्वाड्स , 32 बाइट्स

'a',⍵
^8.*|^1[18](...)*$
⊃⍵L/'n'

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

Answer 23

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

â-x▬♪°∞▄'δL|÷æ╪║>₧4¢ÿ·7åR

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

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह ऐसा दिखता है।

Vk|Eh       get the first "digit" after converting to base 1000
AJ|Eh       get the first "digit" after converting to base 100
c20>9*^/    if the result is greater than 20, divide it by 10 again
"AMj"!#     is the result one of [8, 11, 18]?
^           increment by 1
.an(        keep that many characters of the string "an"

इसको चलाओ

Answer 24

व्हॉट्सएप , 243 बाइट्स

[S S S T    T   S S S S T   N
_Push_97_a][T   N
S S _Print_as_character][S S S T    N
_Push_1][S N
S _Duplicate_1][S N
S _Duplicate_1][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][N
S S S T N
_Create_Label_LOOP][S N
T   _Swap_top_two][S S S T  N
_Push_1][T  S S S _Add][S N
T   _Swap_top_two][S N
S _Duplicate][S S S T   T   S S T   S S N
_Push_100][T    S S T   _Subtract][N
T   T   T   N
_If_negative_jump_to_Label_TWO_DIGITS][S S S T  S ST    S N
_Push_10][T S T S _Integer_division][N
S N
S T N
_Jump_to_Label_LOOP][N
S S T   N
_Create_Label_TWO_DIGITS][S N
S _Duplicate][S S S T   S S S N
_Push_8][T  S S T   _Subtract][N
T   S S S N
_If_zero_jump_to_Label_PRINT_n][S N
S _Duplicate][S S S T   S T T   N
_Push_11][T S S T   _Subtract][N
T   S S N
_If_0_jump_to_Label_2_MOD_3][S N
S _Duplicate][S S S T   S S T   S N
_Push_18][T S S T   _Subtract][N
T   S S N
_If_0_jump_to_Label_2_MOD_3][S S S T    S ST    S N
_Push_10][T S T S _Integer_division][S N
S _Duplicate][N
T   S N
_If_0_jump_to_Label_EXIT][N
S N
T   N
_Jump_to_Label_TWO_DIGITS][N
S S S N
_Create_Label_2_MOD_3][S N
T   _Swap_top_two][S S S T  T   N
_Push_3][T  S T T   _Modulo][S S S T    S M
_Push_2][T  S S T   _Subtract][N
T   T   N
_If_negative_jump_to_Label_EXIT][N
S S S S N
_Create_Label_PRINT_n][S S S T  T   S T T   T   S N
_Push_110_n][T  N
S S _Print_as_character][N
S S N
_Create_Label_EXIT]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

इसे ऑनलाइन आज़माएं (केवल कच्चे स्थानों, टैब और नई-लाइनों के साथ)।
प्रोग्राम एक त्रुटि के साथ बंद हो जाता है: कोई निकास नहीं मिला।

छद्म कोड में स्पष्टीकरण:

Print "a"
Integer input = STDIN as integer
Integer counter = 1
Start LOOP:
  counter = counter + 1
  If(input < 100)
    Jump to function TWO_DIGITS
  input = input integer-divided by 10
  Go to next iteration of LOOP

function TWO_DIGITS:
  If(input == 8)
    Jump to function PRINT_n
  If(input == 11 or input == 18)
    Jump to function 2_MOD_3
  input = input integer-divided by 10
  If(input == 0)
    Exit program
  Recursive call to TWO_DIGITS

function 2_MOD_3:
  If(counter modulo-3 != 2)
    Exit program
  Jump to function PRINT_n

function PRINT_n:
  Print "n"
  Exit program

Answer 25

सी ++, 80 79 बाइट्स

[](int i){for(;i>999;i/=1e3);return i-11&&i-18&&i/100-8&&i/10-8&&i-8?"a":"an";}

यह 4 बाइट्स को 8xx और 8x के खिलाफ स्पष्ट रूप से परीक्षण करने के लिए छोटा है /=10, जैसे कि एक और लूप,

[](int i){for(;i>999;i/=1e3);for(i==11|i==18?i=8:0;i>9;i/=10);return i-8?"a":"an";}

डेमो

#include <locale>
#include <cstdio>
int main(int argc, char**argv)
{
    auto const f =
        [](int i){for(;i>999;i/=1e3);return i-11&&i-18&&i/100-8&&i/10-8&&i-8?"a":"an";}
    ;

    std::locale::global(std::locale{""});
    for (int i = 1;  i < argc;  ++i) {
        auto const n = std::stoi(argv[i]);
        printf("%'10d → %s\n", n, f(n));
    }
}

         0 → a
         8 → an
        11 → an
        18 → an
        84 → an
       110 → a
       843 → an
     1,111 → a
     1,863 → a
     8,192 → an
    11,000 → an
    18,000 → an
   110,000 → a
   180,000 → a
 1,141,592 → a
 1,897,932 → a
11,234,567 → an
18,675,309 → an

Comments

मैं सी भी अच्छी तरह से पता नहीं ++ सकते हैं, लेकिन i/=1000हो सकता है i/=1e3, और सभी कर सकते हैं &&बन &?

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

यह वास्तव में काम करने लगता है: इसे ऑनलाइन आज़माएं।

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

@ केविन - मैंने एक बिंदु पर 1e3 किया था; मैंने डिबगिंग के दौरान इसे बदल दिया और इसे वापस बदलना भूल गया। &&सब नहीं किया जा सकता &, क्योंकि घटाव पूर्णांकों और बूलियन नहीं पैदावार - जैसे 19-118 है, और 19-181 है, यह देखना 8 && 1सत्य है, लेकिन 8 & 1असत्य है। हम उपयोग कर सकते हैं, &लेकिन हमें कोष्ठक में भी बदलाव -करना होगा !=।

— टोबी स्पाइट

आह .. निश्चित रूप से &यहाँ काम नहीं करता, मेरा बुरा। Btw, आप अपने जवाब में एक TIO- लिंक क्यों नहीं जोड़ते?

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

Answer 26

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

$_=a.n x/^8|^1[18](...)*$/

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

Answer 27

पर्ल, 71 55 49 बाइट्स

$_=<>;$_=/^8/||/^1[18]/&&length%3==1?'an':'a';say

मुझे पता था कि टर्नरी ऑपरेटर एक दिन मदद करेगा ...

मुझे इसे तोड़ने दो।

• $_=<> इनपुट के रूप में एक संख्या को स्वीकार करता है।
• बड़े $_=...ब्लॉक $_का उपयोग होने के बाद उसका मूल्य निर्धारित होगा ।
  • ...?...:...टेनेरी ऑपरेटर है। यदि शर्त (प्रथम तर्क) सत्य है, तो यह दूसरा तर्क देता है। अन्यथा, यह तीसरा लौटाता है।
  • /^8/||(/^1[18]/&&length%3==2)यह देखने के लिए कि क्या संख्या 8 से शुरू होती है या 11 या 18 से शुरू होती है ( 1[18]या तो स्वीकार करता है) और 2 की लंबाई mod 3 है।
  • अगर यह सच है, $_पर सेट है an। अन्यथा, यह करने के लिए सेट है a।
• यह तो की सामग्री को बाहर प्रिंट $_(या तो aया anके साथ) say।

परिवर्तन

• सहेजे गए 16 बाइट्स msh210 के लिए धन्यवाद।
• Parens को हटाकर और डिफ़ॉल्ट का उपयोग करके 6 बाइट्स सहेजे गए

Comments

$_=<>;$_=(/^8/)||/^1[18]/&&length($_)%3==1?'an':'a';sayकुछ बाइट्स बचाता है। (हालांकि इसकी तुलना करने की संख्या इस बात पर निर्भर करती है कि आपका न्यूलाइन वर्ण क्या है, लेकिन यह बाइट गिनती नहीं बदलता है।)

— msh210

@ msh210 ऐसा लगता है कि यह केवल 55 बाइट्स है जिसका अर्थ है कि यह 16 बाइट बचाता है। मैं उस में जोड़ दूंगा! धन्यवाद

— ASCIIThenANSI

आपका स्वागत है। ओह, और आप पहले पार्न्स को गिरा सकते हैं (मुझे लगता है कि मैंने परीक्षण नहीं किया है)। मैं तुम्हें भी बदल सकता है लगता है कि length($_)करने के लिए length(या कम से कम कोष्ठक ड्रॉप) लेकिन यह है कि किसी कारण से मेरे लिए काम नहीं कर रहा।

— msh210

@ msh210 हां, आप पार्न्स को गिरा सकते हैं और ($_)प्राप्त करने के लिए $_=<>;$_=/^8/||/^1[18]/&&length%3==1?'an':'a';say, जो केवल 49 बाइट्स है।

— ASCIIThenANSI

आप का उपयोग करके कुछ बाइट्स बचा सकता है -pके बजाय $_=<>और say, y///cबजाय length, और चारों ओर उद्धरण छोड़ने aऔर an: perl -pe'$_=/^8/||/^1[18]/&&y///c%3==2?an:a'(34 बाइट्स + 1 के लिए -p)। ध्यान दें कि इनपुट एक नई सीमा के साथ समाप्त नहीं हो सकता है echo -n 11 | perl -pe'...':। यह एक बग को भी ठीक करता है: के length%3==2रूप में पार्स किया जाता है length(%3)==2, जैसे नहीं length($_)%3==2, इसलिए यह हमेशा गलत होता है।

— ThisSuitIsBlackNot

Answer 28

अजगर, 29 31

?:_ec_z3"(^18$|^11$|^8)"0"an"\a

स्ट्रिंग को उलट देता है, इसे तीन के खंडों में विभाजित करता है, इसे फिर से उलटता है, फिर उपयुक्त अंत चुनता है।

Comments

यह इनपुट पर गलत है 111- यह देता हैan

— isaacg

आप सही हे। फिक्स्ड।

— Moose