यूकेएमटी आईएमसी पेपर चिह्नित करें

22

मैंने इस साल आईएमसी किया। क्या यहां किसी और ने ऐसा किया?

यूकेएमटी इंटरमीडिएट मैथ्स चैलेंज पेपर में, पच्चीस प्रश्न हैं। पहले पंद्रह सवाल आपको पांच अंक देते हैं यदि आप उन्हें सही पाते हैं। अन्य दस प्रश्नों के लिए, आपको उन्हें सही करने के लिए छह अंक मिलते हैं। पिछले दस प्रश्नों में, यदि आप उन्हें गलत पाते हैं तो आप अंक खो देते हैं! सोलह से बीस सवाल के लिए, आप एक अंक खो देते हैं और अंतिम पांच प्रश्नों के लिए, आप दो अंक खो देते हैं। यदि आप एक प्रश्न को खाली छोड़ते हैं, तो कोई अंक नहीं दिए जाते हैं या काट दिए जाते हैं। पहले पंद्रह प्रश्नों में से कोई भी गलत पाने के लिए कोई अंक नहीं काटे जाते हैं। पेपर बहुविकल्पीय है; आप प्रत्येक प्रश्न के लिए A, B, C, D और E में से कोई भी उत्तर चुन सकते हैं। प्रत्येक प्रश्न के लिए हमेशा एक सही उत्तर होता है।

एक प्रोग्राम / फ़ंक्शन बनाएं जो दो तार लेता है और एक स्कोर को आउटपुट करता है। पहला स्ट्रिंग पेपर के लिए आपके उत्तर होंगे। यदि आप एक प्रश्न छोड़ते हैं, तो एक स्पेस, एक नल बाइट या एक अंडरस्कोर का उपयोग करें। अन्यथा, उत्तर के लिए A, B, C, D या E अक्षर का उपयोग करें। आप या तो इनपुट अपरकेस या लोअरकेस हो सकते हैं। पेपर में प्रत्येक प्रश्न के लिए दूसरा स्ट्रिंग सही उत्तर होगा। आपका प्रोग्राम / फ़ंक्शन तब स्कोर स्कोर करेगा। अपने कोड को छोटा करें।

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

DDDDDDDDDDDDDDDDDDDDDDDDD
ABCDEABCDEABCDEABCDEABCDE
15

BDBEACCECEDDBDABBCBDAEBCD
BDBEACCECEDDBDABBCBDAEBCD
135

DBACBDCDBAEDABCDBEECACDC_
DBADBDCDBAEDABCDBEEDACDCA
117

_________________________
DABDABDABDABDABDABDABDABD
0

DBADBDCDBAEDABCD_E__A__C_
DBADBDCDBAEDABCDBEEDACDCA
99

_______________BBBBBBBBBB
AAAAAAAAAAAAAAAAAAAAAAAAA
-15
code-golf 
— 0WJYxW9FMN
स्रोत
क्या "सवालों के लिए पंद्रह से बीस" होना चाहिए "सवालों के लिए सोलह से बीस"?
— ग्रेग मार्टिन
1
क्या हम छोड़े गए प्रश्नों का प्रतिनिधित्व करने के लिए एक अशक्त बाइट का उपयोग कर सकते हैं?
— betseg
2
और पहला स्कोर 27-12 = 15 नहीं होना चाहिए?
— ग्रेग मार्टिन
1
किसी ने यूकेएमटी के पेपर देखे / किए हैं? वे वास्तव में मजेदार हैं। Ukmt.org.uk पर पहेलियाँ देखें। मुझे अपने अधिकांश विचार मैथ्स के सवालों से चुनौती के लिए मिलते हैं।
— 0WJYxW9FMN
1
आपके परीक्षण मामलों में संभवतः नकारात्मक अंक के साथ सबमिशन शामिल होना चाहिए।
— डेनिस

जवाबों:

7

सी, 88 87 86 81 बाइट्स

c,d;i(char*a,char*b){for(c=d=0;*b;c++,a++)d+=*a^*b++?*a?-c/15-c/20:0:5+c/15;d=d;}

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

— Ahemone
स्रोत
1
चूंकि ABCDEसभी बिंदु 95 से नीचे हैं, मुझे लगता है कि आप उपयोग कर सकते हैं *a<95।
— यति
2
चूंकि सवाल अंडरस्कोर के बजाय अशक्त बाइट लेने की अनुमति देता है, -(c/15+c/20)*(*a<95)बन सकता है *a?-c/15-c/20:0।
— डेनिस
— छत
6

जेली , २६ २३ २२ बाइट्स

=s5ị"“HHHQP‘D¤_2Fæ.n⁶¥

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

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

=s5ị"“HHHQP‘D¤_2Fæ.n⁶¥  Main link. Argument: t (answer to test), s (answer sheet)

=                       Test the characters of t and s for equality.
 s5                     Split into chunks of length 5.
             ¤          Combine the two preceding links into a niladic chain.
     “HHHQP‘              Yield the code points, i.e., [72, 72, 72, 81, 80].
            D             Decimal; yield [[7, 2], [7, 2], [7, 2], [8, 1], [8, 0]].
   ị"                   Index zipwith; use the Booleans in each chunk to index into
                        the corresponding pair. Indexing is 1-based and modular, so
                        1 gives the first element and 0 the last.
              _2        Subtract 2 from each result.
                F       Flatten the resulting 5x5 matrix.
                     ¥  Combine the two preceding links into a dyadic chain.
                   n⁶     Test the characters of t for inequality with space.
                 æ.     Take the dot product of the integers to the left and the
                        Booleans to the right.
— डेनिस
स्रोत
5

जावास्क्रिप्ट (ईएस 6), 70 68 66 बाइट्स

नील
बचे हुए 2 बाइट्स की वजह से 2 बाइट्स बचाए गए

आवेदक के उत्तर aऔर cकरी सिंटैक्स में सही उत्तर लेता है (a)(c)। एक स्थान के साथ चिह्नित प्रश्नों को छोड़ देने की अपेक्षा करता है।

a=>c=>a.replace(/\S/g,(a,i)=>s+=a==c[j=i>14,i]?5+j:-j^i>19,s=0)&&s

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

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
यदि आप स्किप किए गए प्रश्न को गैर-शब्द वर्ण (जैसे स्थान) में बदलते हैं तो /\w/gआप दो बाइट्स को सहेजने के लिए उपयोग कर सकते हैं ।
— नील
मुझे लगता -j-(i>19) है कि जैसा है -j^i>19, हालांकि मैं निश्चित नहीं हूं।
— ETHproductions
@ETHproductions वास्तव में। यह पार्स किया गया (-j)^(i>19)है, हां, यह काम करता है।
— अरनौलद
4

पायथन 2 , 86 85 83 77 बाइट्स

f=lambda t,s,i=24:~i and(i/10*-(14<i<t[i]<'_'),5+i/15)[t[i]==s[i]]+f(t,s,i-1)

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

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

यह एक पुनरावर्ती फ़ंक्शन f को परिभाषित करता है जो दो गैर-इष्टतम तर्क लेता है: t (परीक्षण के उत्तर) और s (उत्तर पत्रक)। जब इन दो तर्क के साथ ही कहा जाता है, च initializes मैं करने के लिए 24 , दोनों के अंतिम सूचकांक टी और एस ।

हर बार च को कहा जाता है, यह पहली बार जांचता है कि ~ i (बिटवाइस नॉट ऑफ i ) सत्य / गैर-शून्य है। चूंकि ~ (-1) = 0 , यह तब होता है जब मैं मूल्य -1 तक पहुंचता हूं । अगर मैं = -1 , ~ मैं 0 = लौटा दिया जाता है, लेकिन जैसा कि मैं से मान लेता है 24 करने के लिए 0 (के सभी सूचकांकों टी और एस ), कोड निम्नलिखित andनिष्पादित किया जाता है और च रिटर्न परिणाम।

जब मैं गैर-नकारात्मक होता हूं , तो निम्नलिखित होता है। प्रथम,

(i/10*-(14<i<t[i]<'_'),5+i/15)

लंबाई 2 का एक समूह बनाता है :

  • भागफल i/10है 0 अगर 0 ≤ मैं <10 , 1 अगर 10 ≤ मैं <20 , और 2 यदि 20 ≤ मैं <25 । जंजीर तुलना14<i<t[i]<'_' सही है और यदि केवल सभी व्यक्तिगत तुलना सही है , अर्थात, अगर और केवल अगर मैं ( 15 (जुर्माना के साथ सवालों की सीमा) लौटाता हूं , तो मैं t [i] से छोटा हूं (चूंकि सभी संख्याओं की तुलना में छोटा है) पायथन 2 में सभी पुनरावृत्तियाँ), और t [i] एक अंडरस्कोर नहीं है।

    यदि तुलना गलत हो जाती है , तो यूरी -रिटर्न 0 और संपूर्ण एक्सप्रेशन 0 का मूल्यांकन करता है । हालाँकि, यदि तुलना सही है , तो यूनरी -1- लौटता है , इसलिए संपूर्ण अभिव्यक्ति 0 का मूल्यांकन करती है, यदि 0 <i <10 , -1 यदि 10 <i <20 , और -2 यदि 20 <i <25 ; ये सभी सूचकांकों के लिए गलत या गुम उत्तरों के लिए शुद्ध परिणाम हैं i ।

  • 5+i/15रिटर्न 5 + 0 = 5 यदि 0 ≤ मैं <15 और 5 + 1 = 6 यदि 15 ≤ मैं <25 । ये सभी सूचकांकों के लिए सही उत्तर के लिए शुद्ध परिणाम हैं i ।

अंत में, [t[i]==s[i]]निर्मित tuple के पहले तत्व का चयन करता है यदि t [i] और s [i] भिन्न (गलत या अनुपस्थित उत्तर) और दूसरा यदि वे समान (सही उत्तर) हैं, तो f की वापसी मान को घटाया हुआ कहा जाता है मैं उस परिणाम के लिए एक बार जब मैं -1 पर पहुंचता हूं , तो अंतिम स्कोर की गणना की जाती है और एफ द्वारा वापस कर दिया जाता है ।

— डेनिस
स्रोत
3

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

Tr@(m=MapThread)[#/.True->#2/.False->-#3&,{Tr/@Partition[m[Equal,#/."_"->u]/.u==_->0,5],{5,5,5,6,6},{0,0,0,1,2}}]&

शुद्ध फ़ंक्शन वर्णों की सूचियों की एक क्रमबद्ध जोड़ी लेकर और एक पूर्णांक लौटाता है। m[Equal,#/."_"->u]बूलियन्स की एक सूची लौटाता है, u=="B"जहां उन स्थानों पर फॉर्म की अनवैलिडेटेड प्रविष्टियों को छोड़कर, जहां उत्तर की बराबरी की जाती है "_"; फिर तुरंत, u==_->0उन अनवीक्षित प्रविष्टियों को बदल देता है 0। Tr/@Partition[...,5]एक समय में इन प्रविष्टियों को 5 तक जोड़ता है, जिसके परिणामस्वरूप {4False+True, 4False+True, 4False+True, 4False+True, 4False+True}पहले परीक्षण मामले या {5True, 5True, 5True, 2True, 2True}अंतिम परीक्षण मामले के लिए एक सूची होती है । फिर प्रत्येक समन्वय में, Trueऔर Falseउचित स्कोर के लिए मैप किया जाता है, और परिणाम एक साथ जोड़ दिए जाते हैं।

— ग्रेग मार्टिन
स्रोत
3

जेली , 22 21 बाइट्स

Zm0ṁ135µ;t€⁶E€’;E€ṫ⁹S

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

मैंने सोचा @ डेनिस का जवाब शायद हतोत्साहित करने वाला था। और विभिन्न संभावनाओं की एक बड़ी संख्या की कोशिश करने और एक अद्भुत संयोग से लाभ उठाने के बाद, मैंने आखिरकार इसे प्रबंधित किया है!

यह कार्यक्रम इनपुट के रूप में [छात्र के उत्तरों, सही उत्तरों] की एक जोड़ी लेता है और लापता उत्तर को इंगित करने के लिए रिक्त स्थान का उपयोग करता है।

व्याख्या

यह कार्यक्रम कुछ विचित्र आंतरिक इनपुट स्वरूपों का उपयोग करता है जो कि चल रहा है, इस पर नज़र रखने के लिए, इसलिए हम इसे एक बार में एक कदम उठाएंगे।

  1. Z

    यह इनपुट को स्थानांतरित करता है, इसलिए हम प्रत्येक प्रश्न के लिए 25 तत्वों की एक सूची के साथ समाप्त करेंगे; प्रत्येक तत्व फॉर्म का है [छात्र का उत्तर, सही उत्तर]। हम इस फ़ॉर्म के एक तत्व को एक बड़े अक्षर के साथ इंगित करेंगे; Aप्रश्न 1 के लिए, Bप्रश्न 2 के लिए, और इसी तरह। तो वर्तमान में जवाब के रूप में संग्रहीत किया जा रहा है

    ABCDEFGHIJKLMNOPQRSTUVWXY

  2. m0

    यह एक "अधिक से अधिक पैलिंड्रोम" ऑपरेशन है; हम वर्तमान मूल्य के विपरीत मूल्य को ही जोड़ते हैं, इससे उपज होती है:

    ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA

  3. ṁ135

    ṁ(मोल्ड) ऑपरेटर चीजों की एक संख्या है, लेकिन इस संदर्भ में, यह प्रभावी रूप से बार-बार खुद को वर्तमान मूल्य जोड़कर उत्पादन अनंत सूची के पहले 135 तत्वों लेता है। यह हमें निम्नलिखित देता है (जो मैंने सुविधा के लिए 50 तत्वों के समूहों में तोड़ दिया है; यह आंतरिक रूप से 135 जोड़े की सूची है):

    ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP

  4. µ;

    µलापता ऑपरेंड के लिए नए डिफ़ॉल्ट के रूप में वर्तमान मान सेट करता है। हम फिर तुरंत एक बिल्डिन देखते हैं जो एक ऑपरेंड को याद कर रहा है; ;एपेंड करता है, लेकिन हमने निर्दिष्ट नहीं किया है कि किसके साथ क्या करना है। नतीजतन, वर्तमान मूल्य को अंतिम µ(जो कि वर्तमान मूल्य भी है) के रूप में मूल्य में जोड़ा जाता है , जिससे हमें निम्नलिखित 270-तत्व वर्तमान मूल्य मिलता है:

    ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBA
ABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQPABCDEFGHIJKLMNO
PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
PQRSTUVWXYYXWVUTSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNO
PQRSTUVWXYYXWVUTSRQP

  5. t€⁶

    याद रखें कि ऊपर दिए गए सभी बड़े अक्षर [छात्र के उत्तर, सही उत्तर] के जोड़े को दर्शाते हैं। t€⁶आपरेशन प्रत्येक (पर चल रही €हटाए गए () जोड़ी, और t) रिक्त स्थान ( ⁶) जोड़ी के दोनों ओर से (यानी किसी भी स्थान है कि जोड़ी में दिखाई देता है)। इसलिए हमारे पास अभी भी 270 प्रश्नों की एक ही सूची कई रिपीट के साथ है, लेकिन वे फॉर्म [सही उत्तर] (छात्र ने उत्तर नहीं दिया) या [छात्र का उत्तर, सही उत्तर] (छात्र ने उत्तर दिया)।

  6. E€’

    E€’आपरेशन भी एक (पर चल रही है €के उपयोग के कारण) तत्व, और, E, 1 के साथ तत्व बदल दे सभी तत्वों के बराबर हैं (यानी छात्र का उत्तर देने या सवाल का अधिकार मिल गया नहीं था), या 0 सभी नहीं तो तत्व बराबर हैं (अर्थात छात्र ने उत्तर दिया लेकिन प्रश्न गलत मिला)। यहां के उपयोग से ’नंबरिंग बदल जाती है, जिसका अर्थ है कि अब हम क्रमशः -1 या 0 का उपयोग करते हैं। मैं इस नए प्रकार के तत्व के लिए लोअरकेस अक्षरों का उपयोग करूंगा, जो उत्तर के लिए -1 का उपयोग करता है जिसे दंडित किया जाएगा यदि यह दंड-योग्य प्रश्न पर था, या 0 लापता या सही उत्तर के लिए:

    abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
pqrstuvwxyyxwvutsrqp

  7. ;E€

    हमने दोनों को E€और ;पहले देखा है ; हम वर्तमान मूल्य के लिए कुछ जोड़ रहे हैं, और हम 1 के प्रारूप का उपयोग कर रहे हैं यदि सभी तत्व समान हैं, या 0 यदि कुछ अलग हैं ( ’इस बार नहीं!)। यहां एक लापता ऑपरेंड है, इसलिए हम अंतिम µ(यानी चरण 3 के आउटपुट) के रूप में मूल्य का उपयोग करते हैं । चरण 3 में वापस, हमने तत्वों से रिक्त स्थान नहीं हटाया था, इसलिए हमारे पास एक सही उत्तर के लिए 1 होगा, या 0 गलत या लापता उत्तर के लिए (क्योंकि एक स्थान सही उत्तर से मेल नहीं खाएगा)। अब से, मैं इस 1 = सही, 0 = गलत / लापता प्रारूप के लिए बड़े अक्षरों का उपयोग करूंगा, और 0 = सही / गायब, -1 = गलत के लिए लोअरकेस अक्षरों का उपयोग करना जारी रखूंगा। परिणामी मूल्य में 405 तत्व हैं, और इस तरह दिखता है:

    abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwxyyxwvutsrqponmlkjihgfedcba
abcdefghijklmnopqrstuvwxyyxwvutsrqpabcdefghijklmno
pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
pqrstuvwxyyxwvutsrqponmlkjihgfedcbaabcdefghijklmno
pqrstuvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
TSRQPONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVU
TSRQP

  8. ṫ⁹

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

    प्रत्येक पूंजी पत्र एक सही उत्तर के लिए +1 का प्रतिनिधित्व करता है; पहले 15 प्रश्न (के Aमाध्यम से O) प्रत्येक स्ट्रिंग में 5 बार दिखाई देते हैं, और अंतिम 10 प्रश्न ( प्रत्येक के Pमाध्यम से Y) 6 बार दिखाई देते हैं। वह बिट वास्तव में जादुई नहीं है; मैंने इसे इस तरह से डिज़ाइन किया था जब मैंने प्रोग्राम में 135 नंबर पहले चुना था (जो 5 × 15 + 6 × 10 है), और यहाँ भाग्य का एकमात्र स्ट्रोक यह है कि 5 एक विषम संख्या है (इसलिए यह अंतिम 10 है प्रश्न जो पहले 10 के बजाय अतिरिक्त समय को समाप्त करते हैं)। 15 पत्र तुरंत इस पूर्ववर्ती शामिल pके माध्यम से t(-1 जुर्माना प्रश्न) एक बार, और uके माध्यम से y(-2 दंड प्रश्न) दो बार। यह भी बहुत संयोग नहीं है; क्योंकि हमने इस्तेमाल कियाm0पहले, प्रश्नों की अतिरिक्त प्रतियां क्रम में हैंPQRSTUVWXYYXWVUTSRQP, और बाद के प्रश्न स्वाभाविक रूप से उस स्ट्रिंग के मध्य के पास होंगे (इसलिए "अतिरिक्त" प्रश्नों के अंतिम 15 को किनारों के पास वाले लोगों को कम दोहराएंगे; और निश्चित रूप से, यह "अतिरिक्त" नहीं है; प्रश्न अंतिम आते हैं)।

    क्योंकि प्रत्येक लोअरकेस अक्षर गलत, गैर-लापता उत्तर के लिए स्कोर से 1 घटाता है, और प्रत्येक अपरकेस पत्र एक सही उत्तर के लिए स्कोर में 1 जोड़ता है, इसलिए हमें प्राप्त करने के लिए अंतिम 135 + 15 = 150 तत्वों को लेने की आवश्यकता है प्रत्येक प्रकार का तत्व कई बार सही संख्या में होता है। एक सूची के अंत में एक विकल्प प्राप्त करने के लिए जेली की कमान है ṫ; हालाँकि, यह आपके इच्छित तत्वों की संख्या को निर्दिष्ट नहीं करता है, बल्कि आपके द्वारा वांछित पहले तत्व का सूचकांक है। हमारे पास इस बिंदु पर 405 तत्व हैं, और 150 चाहते हैं, इसलिए हमें सूचकांक (405 - 150 + 1), या 256 पर शुरू करने की आवश्यकता है। एक अद्भुत संयोग में, 256 में अलग-अलग ऑक्टेट की संख्या होती है जो मौजूद हैं, और इस तरह से है जेली में एक छोटा प्रतिनिधित्व (⁹)। ऐसा करने के लिए मैं बहुत कम कर सकता था; चरण 4 ने राउंड नंबर को हिट करने के लिए सूची की शुरुआत में एक और 135 तत्वों को जोड़ा, लेकिन तथ्य यह है कि यह 135 तत्व थे जिन्हें मुझे जोड़ना था (एक मान जो कार्यक्रम में उस समय आसानी से उपलब्ध था) वास्तव में सुविधाजनक था, मूल रूप से इस स्थिति में कोई अन्य संख्या पूरी तरह से अप्रभावी होने के कारण।

    यहां बताया गया है कि आंतरिक मूल्य अब कैसा दिखता है:

    uvwxyyxwvutsrqpABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP
ONMLKJIHGFEDCBAABCDEFGHIJKLMNOPQRSTUVWXYYXWVUTSRQP

  9. S

    अंत में, अब हमें प्रश्नों से प्राप्तांक में संशोधन की सूची मिल गई है, हमें बस इतना करना है कि हम उनका उपयोग Sकर रहे हैं, और हम कर रहे हैं।

2

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

f=lambda a,b,n=0:a>""and((a[0]==b[0])*(5+n/15)or-(n/15*n/10)*(a[0]<"^"))+f(a[1:],b[1:],n+1)

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

-2 बाइट्स @KritiiLithos को धन्यवाद

इनपुट:

  • a: छात्र के उत्तर को एक _प्रश्न के रूप में, कटा हुआ प्रश्न के लिए
  • b : सही उत्तर
  • n: वर्तमान प्रश्न की संख्या- 0आधारित, चूक करना0
— OVS
स्रोत
आप बाइट्स को बचाने के a[0]<'^'बजाय कर सकते हैंa[0]!="_"
— Kritii Lithos
मुझे लगता है कि a>""इसके बजाय काम कर सकते हैंa!=""
— Kritii Lithos
यदि आपका प्रारंभिक चेक aखाली होने पर पुनरावृत्ति को समाप्त कर रहा है, तो क्या आप बस नहीं कर सकते a and? एक खाली स्ट्रिंग झूठी है, अन्यथा यह सच है।
— फ्लिपकार्ट
@ फेकटैक यह TypeErrorआखिरी पुनरावर्ती कॉल के रूप में फेंक देगा एक स्ट्रिंग
— लौटेगा
1

के, 52 बाइट्स

फ़ंक्शन 2 स्ट्रिंग्स लेता है, परीक्षण मामलों के अनुसार प्रारूप

{+/(~x="_")*(+,/'(15 5 5#'0 -1 -2;15 10#'5 6))@'x=y}

उदाहरण:

k){+/(~x="_")*(+,/'(15 5 5#'0 -1 -2;15 10#'5 6))@'x=y}["DBADBDCDBAEDABCD_E__A__C_";"DBADBDCDBAEDABCDBEEDACDCA"]
99
— skeevey
स्रोत
1

हास्केल, 84 बाइट्स

i x a b|a>'Z'=0|a==b=6-0^x|1<2= -x
w x=x<$[1..5*3^0^x]
(sum.).zipWith3 i(w=<<[0..2])

प्रयोग उदाहरण: ((sum.).zipWith3 i(w=<<[0..2])) "DBADBDCDBAEDABCD_E__A__C_" "DBADBDCDBAEDABCDBEEDACDCA"-> 99। इसे ऑनलाइन आज़माएं!।

यह कैसे काम करता है: सही परिणाम के साथ i x a bएकल उत्तर के लिए स्कोर की गणना करता है और गलत उत्तर के लिए जुर्माना (गैर-नकारात्मक मूल्य)। यदि आप छोड़ते हैं ( ), तो स्कोर है , यदि उत्तर सही है ( ), स्कोर है , तो स्कोर हैabxa>'Z'0a==b6-0^x-x ।

w=<<[0..2](और> 15 बार , 5 बार और 5 बार ) प्रत्येक संख्या की प्रतियां बनाकर, यानी , करने के wलिए आवेदन करके और सभी 25 सवालों के लिए दंड की एक सूची बनाता है ।0125*3^0^x012

zipWith3iदंड की सूची, उत्तरों की सूची और सही परिणामों की सूची पर लागू होता है। अंत में सभी स्कोर जोड़े जाते हैं ( sum)।

— nimi
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 105 103 101 94 89 89 88 85 84 78 77 बाइट्स

ईएस 6 में मेरा पहला समाधान, शायद जावास्क्रिप्ट ओओ में भी पहला

f=(s,a,i=24)=>i+1&&(s[i]>'Z'?0:s[i]==a[i]?5+(i>14):~(i>19)*(i>14))+f(s,a,i-1)

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

यहाँ 78 बाइट्स पर एक गैर-पुनरावर्ती समाधान है:

s=>a=>eval([...s].map((c,i)=>c>'Z'?0:c==a[i]?5+(i>14):~(i>19)*(i>14)).join`+`)

करी सिंटैक्स के माध्यम से इनपुट लेता है।

9 बाइट बचाने के लिए @ETHproductions को धन्यवाद ! s[i]करने के लिए cऔर (-1-(i>19|0))करने के लिए~(i>19) ।

एक बाइट को बचाने के लिए @Kritii Lithos को धन्यवाद ! c=='_'को c>'Z'।

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

— Yytsi
स्रोत
जेएस में आपका पहला समाधान होने की बात करते हुए, कोड गोल्फ के लिए आपकी मुख्य भाषा क्या है? मैंने केवल कोड गोल्फ के लिए कभी पायथन और ब्रेनफक का उपयोग किया है।
— 0WJYxW9FMN
@ J843136028 मेरी मुख्य भाषा पायथन है, लेकिन मैंने सी # के साथ भी थोड़ा सा गोल्फ दिया है। हैक्स थोड़ी देर के लिए बंद कर दिया गया है, लेकिन मैं इसे वापस कर सकते हैं।
— यति
ठंडा! मैंने केवल एक बार ब्रेनफक का उपयोग किया है, इसलिए मेरी मुख्य भाषा पायथन भी है।
— 0WJYxW9FMN
@ J843136028 हाँ, मैंने वास्तव में आपके उत्तर यहाँ और वहाँ देखे हैं। अपनी जैव पैदावार के रूप में, मैं उस समय को समाधानों का पता लगाने में खर्च नहीं करता, इसलिए वे ज्यादातर समय ब्याज के नहीं होते हैं। मैंने केवल ब्रेनफ़ * सीके के साथ बहुत कम किया है, क्योंकि लघु समाधान खोजने में बहुत समय लगता है, यहां तक ​​कि मध्यवर्ती समस्याओं के लिए भी।
— यति
मुझे पता है कि आपका BF के बारे में क्या मतलब है। मुझे आश्चर्य है कि लोग मेरे उत्तरों को देखते हैं।
— 0WJYxW9FMN
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.