30

यहाँ एक सरल ASCII कला रूबी है :

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_\/

ASCII रत्न निगम के लिए एक जौहरी के रूप में, आपकी नौकरी नए अधिग्रहीत माणिकों का निरीक्षण करती है और आपके द्वारा पाए जाने वाले किसी भी दोष के बारे में ध्यान दें।

सौभाग्य से, केवल 12 प्रकार के दोष संभव हैं, और आपका आपूर्तिकर्ता गारंटी देता है कि किसी भी रूबी में एक से अधिक दोष नहीं होंगे।

12 दोष 12 भीतरी में से एक के प्रतिस्थापन के अनुरूप _, /या \एक अंतरिक्ष चरित्र (साथ गहरे लाल रंग का के पात्रों )। माणिक की बाहरी परिधि में कभी भी दोष नहीं होते हैं।

दोषों को गिना जाता है जिसके अनुसार आंतरिक चरित्र का स्थान अपनी जगह है:

दोष संख्या

तो दोष 1 के साथ एक रूबी इस तरह दिखता है:

  ___
 /\_/\
/_/  _\
\ \_/ /
 \/_\/

दोष 11 के साथ एक रूबी इस तरह दिखता है:

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \ _\/

यह अन्य सभी दोषों के लिए एक ही विचार है।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एकल, संभावित रूप से दोषपूर्ण माणिक की स्ट्रिंग में लेता है। दोष संख्या मुद्रित या वापस आनी चाहिए। यदि दोष न हो तो दोष संख्या 0 है।

टेक्स्ट फ़ाइल, स्टडिन या स्ट्रिंग फ़ंक्शन तर्क से इनपुट लें। दोष संख्या लौटाएं या इसे stdout में प्रिंट करें।

आप मान सकते हैं कि रूबी में एक अनुगामी न्यूलाइन है। आप यह नहीं मान सकते हैं कि इसमें कोई अनुगामी स्थान या अग्रणी नई सुर्खियाँ हैं।

बाइट्स में सबसे छोटा कोड जीतता है। ( आसान बाइट काउंटर। )

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

माणिक के 13 सटीक प्रकार, उनके अपेक्षित आउटपुट के बाद सीधे:

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_\/
0
  ___
 /\_/\
/_/  _\
\ \_/ /
 \/_\/
1
  ___
 /\ /\
/_/ \_\
\ \_/ /
 \/_\/
2
  ___
 /\_/\
/_  \_\
\ \_/ /
 \/_\/
3
  ___
 /\_/\
/_/ \_\
\  _/ /
 \/_\/
4
  ___
 /\_/\
/_/ \_\
\ \ / /
 \/_\/
5
  ___
 /\_/\
/_/ \_\
\ \_  /
 \/_\/
6
  ___
 /\_/\
/_/ \ \
\ \_/ /
 \/_\/
7
  ___
 /\_ \
/_/ \_\
\ \_/ /
 \/_\/
8
  ___
 / _/\
/_/ \_\
\ \_/ /
 \/_\/
9
  ___
 /\_/\
/ / \_\
\ \_/ /
 \/_\/
10
  ___
 /\_/\
/_/ \_\
\ \_/ /
 \ _\/
11
  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_ /
12

code-golf ascii-art kolmogorov-complexity

— केल्विन के शौक
स्रोत

स्पष्ट करने के लिए, माणिक में कोई अनुगामी स्थान नहीं हो सकता है, है ना?

— ऑप्टिमाइज़र

@ ओप्टिमाइज़र सही

— केल्विन के

@ केल्विन के शौकीन हम यह भी मान सकते हैं कि इनपुट में अनुगामी न्यूलाइन नहीं है?

— orlp

@orlp हां। हो सकता है कि यह पूरी बात हो ।

— केल्विन के शौक

माणिक सममित हैं। इसलिए त्रुटि # 7 त्रुटि # 10 के समान नहीं होनी चाहिए, उदाहरण के लिए?

— डेविडक्रैच

13

सीजेएम, 27 23 बाइट्स

F7EC5ZV4DI8G6]qBb67%J%#

आधार 11 में कनवर्ट करें, 67 एमओ लें, परिणाम का मॉड 19 लें, फिर सरणी में आपके पास क्या है, इसका इंडेक्स ढूंढें

[15, 7, 14, 12, 5, 3, 0, 4, 13, 18, 8, 16, 6]

जादू!

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

— Sp3000
स्रोत

34

रूबी 2.0, 69 बाइट्स

#!ruby -Kn0rdigest
p'×ñF<ìX‚É²Ÿ_'.index Digest::MD5.digest(gets)[0]

हेक्सडम्प (विश्वासपूर्वक स्ट्रिंग में बाइनरी डेटा दिखाने के लिए):

00000000  23 21 72 75 62 79 20 2d  4b 6e 30 72 64 69 67 65  |#!ruby -Kn0rdige|
00000010  73 74 0a 70 27 d7 f1 46  3c 1f ec 58 82 c9 b2 9f  |st.p'..F<..X....|
00000020  5f 02 27 2e 69 6e 64 65  78 20 44 69 67 65 73 74  |_.'.index Digest|
00000030  3a 3a 4d 44 35 2e 64 69  67 65 73 74 28 67 65 74  |::MD5.digest(get|
00000040  73 29 5b 30 5d                                    |s)[0]|

स्पष्टीकरण:

-Knविकल्प के रूप में स्रोत फ़ाइल पढ़ता है ASCII-8BIT(बाइनरी)।
-0विकल्प की अनुमति देता getsपूरे इनपुट (और न सिर्फ एक पंक्ति) में पढ़ने के लिए।
-rdigestविकल्प लोड करता है digestमॉड्यूल, प्रदान करता है जो Digest::MD5।
कोड फिर इनपुट का MD5 करता है, डाइजेस्ट का पहला बाइट लेता है, और दिए गए बाइनरी स्ट्रिंग में इसका इंडेक्स प्राप्त करता है।

— क्रिस जस्टर-यंग
स्रोत

भाग्यशाली है कि MD5 पहले चार पर ही अद्वितीय है

— ऑप्टिमाइज़र

15

किसी भाग्य की आवश्यकता नहीं है। प्रत्येक बाइट में 256 संभावनाएँ होती हैं, इसलिए पहला बाइट 13 हैश के लिए अलग होना असामान्य नहीं है। लेकिन अगर वे किसी भी कारण से टकरा गए, तो मैं हैश के दूसरे बाइट का उपयोग करूंगा।

— क्रिस जस्टर-यंग

14

रूबी में एक रूबी इंस्पेक्टर लिखें। सहज रूप में!

— मस्तूल

अगली चुनौती: इस पोस्ट का स्वयं निरीक्षण करें

— रेडवॉल्फ कार्यक्रम

7

जूलिया, 90 59 बाइट्स

निश्चित रूप से सबसे छोटा नहीं है, लेकिन निष्पक्ष युवती जूलिया शाही माणिकों के निरीक्षण में बहुत ध्यान रखती है।

s->search(s[vec([18 10 16 24 25 26 19 11 9 15 32 34])],' ')

यह एक लैम्बडा फ़ंक्शन बनाता है जो एक स्ट्रिंग को स्वीकार करता है s और संबंधित रूबी दोष संख्या देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=s->...।

असंगठित + स्पष्टीकरण:

function f(s)
    # Strings can be indexed like arrays, so we can define d to
    # be a vector of indices corresponding to potential defect
    # locations

    d = vec([18 10 16 24 25 26 19 11 9 15 32 34])

    # Check the specified locations for defects, returning the
    # defect number as the index where a space was found and
    # was not expected. If no spaces are found, 0 is returned.

    search(s[d], ' ')
end

उदाहरण:

julia> f("  ___
 /\\ /\\
/_/ \\_\\
\\ \\_/ \/
 \\/_\\/")
2

julia> f("  ___
 /\\_/\\
/_/ \\_\\
\\ \\_/ \/
 \\/_\\/")
0

ध्यान दें कि इनपुट में बैकस्लैश से बचना होगा। मैंने @ केल्विन के शौक से पुष्टि की कि यह ठीक है।

यदि आपके कोई प्रश्न या सुझाव हैं तो मुझे बताएं!

संपादित करें: एंड्रयू पिलिसर की मदद से 31 बाइट्स बचाए!

— एलेक्स ए।
स्रोत

आप के साथ पाश के लिए छुटकारा searchऔर सरणी अनुक्रमण कर सकते हैं। s->(d=reshape([18 10 16 24 25 26 19 11 9 15 32 34],12);search(s[d],' '))। मुझे फेरबदल पसंद नहीं है, लेकिन मैं 1d सरणी प्राप्त करने के लिए एक छोटे तरीके के बारे में नहीं सोच सकता था।

— एंड्रयू का कहना है कि

@AndrewPiliser: धन्यवाद, मैं वास्तव में आपके इनपुट की सराहना करता हूं! मैंने आपके सुझाव का उपयोग करने के लिए संपादन किया। इसके अलावा, reshape()उपयोग करने के लिए एक छोटा तरीका है vec()। :)

— एलेक्स ए।

7

> <> (मछली) , 177 बाइट्स

यह एक लंबा लेकिन अनूठा समाधान है। कार्यक्रम में कोड में निश्चित स्थानों में इनपुट वर्ण सम्मिलित करने के अलावा कोई अंकगणित या शाखा नहीं है ।

ध्यान दें कि सभी निरीक्षण रूबी-निर्माण अक्षर (/ \ _ )> <> कोड में "दर्पण" हो सकते हैं जो निर्देश सूचक (आईपी) की दिशा बदलते हैं।

हम इन इनपुट वर्णों का उपयोग कोड-संशोधित निर्देश के साथ pऔर हर निकास पर (जो इनपुट में एक गुम दर्पण द्वारा बनाया गया है) के साथ उनसे संबंधित संख्या प्रिंट कर सकते हैं।

iiiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

    ;
   ;n
  ;nb
 ;n6S    0n;
 n3SB   cn;
 8SB!  4n;
 SB!  1n;
>B! U9n;
 ! U5
  U7n
 Uan;
 2n;
 n;
 ;

S B Uपत्र के लिए बदल जाते हैं / \ _क्रमशः। यदि इनपुट एक पूर्ण रूबी है तो अंतिम कोड बन जाता है:

\iiiiiiii19pi1cpi18piiii2bpi27pii28pi3apiiiii37pi49pi36piiiii00pi45pii46p

    ;
   ;n
  ;nb
 ;n6/    0n;
 n3/\   cn;
 8/\!  4n;
 /\!  1n;
>\! _9n;
 ! _5
  _7n
 _an;
 2n;
 n;
 ;

आप इस महान ऑनलाइन दृश्य दुभाषिया के साथ कार्यक्रम की कोशिश कर सकते हैं । जैसा कि आप वहाँ पर नए सिरे से इनपुट नहीं कर सकते हैं, इसके बजाय आपको कुछ डमी पात्रों का उपयोग करना होगा ताकि आप एक पूर्ण रूबी को इनपुट कर सकें जैसे कि SS___LS/\_/\L/_/S\_\L\S\_/S/LS\/_\/। (रिक्त स्थान के कारण रिक्त स्थान भी S में बदल गया।)

— randomra
स्रोत

5

CJam, 41 31 29 28 बाइट्स

"-RI)11a!"q103b1e3%A/c#

हमेशा की तरह, नॉन प्रिंट करने योग्य पात्रों के लिए, इस लिंक का अनुसरण करें ।

इसे यहाँ ऑनलाइन आज़माएँ

स्पष्टीकरण जल्द ही

पिछला दृष्टिकोण:

बहुत यकीन है कि अंकों / रूपांतरण तर्क को बदलकर इसे कम किया जा सकता है। लेकिन यहाँ पहला प्रयास जाता है:

"<KJ[]\"O=":iqN-"/\\_ "4,er4b1e3%A/#

हमेशा की तरह, उपयोग करें इस लिंक का अनपेक्षित वर्णों के लिए करें।

तर्क बहुत सरल है

"Hash for each defect":i - यह मुझे सूचकांक के रूप में हैश प्रति दोष प्राप्त करता है
qN-"/\\_ "4,er - यह वर्णों को संख्याओं में परिवर्तित करता है
4b1e3%A/ - आधार कन्वर्टेड नंबर में यह यूनिक नंबर है
# तब मुझे बस हैश में यूनिक नंबर का इंडेक्स मिल जाता है

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

इतना करीब, मैं आपसे १ चरित्र छोटा हूँ!

— orlp

ओह, मेरे पास पहले से ही 28 हैं। अद्यतन करने के लिए बहुत व्यस्त था

— ऑप्टिमाइज़र

मुझे लगता है कि मेरा जवाब पायथ के लिए इष्टतम है। पायथ को वास्तव में एक हैश फ़ंक्शन की आवश्यकता है ( .hअभी बेकार है क्योंकि यह अंतर्निहित अविश्वसनीय और खराब का उपयोग करता है hash()), तब तक मैं बेहतर नहीं कर सकता।

— orlp

4

पर्ची , 123 108 + 3 = 111 बाइट्स

^6 (`\\`_.?<?.?[ _]?|`_(`\.?(<.?|>)|`/.?.?>.?.?).?)| `_(`\.?<.?>?.?.?|`/(.?>.?.?.?|<`_))| `/\`_.?(.<.?>?.?)?

nऔर oझंडे के साथ चलाएं , अर्थात

py -3 slip.py regex.txt input.txt no

वैकल्पिक रूप से, इसे ऑनलाइन आज़माएं ।

स्लिप एक रेगेक्स जैसी भाषा है जिसे 2 डी पैटर्न मिलान चुनौती के हिस्से के रूप में बनाया गया था । स्लिप pनिम्न कार्यक्रम के माध्यम से स्थिति ध्वज के साथ एक दोष के स्थान का पता लगा सकता है :

^6? `_[/\]|( `/|^6 `\)\`_

जो निम्नलिखित पैटर्न में से एक के लिए लग रहा है (यहाँ Sमैच शुरू होता है):

S_/    S_\    /_S    \_S    S/      _
                              _      \S

इसे ऑनलाइन आज़माएं - निर्देशांक एक (x, y) जोड़ी के रूप में आउटपुट होते हैं। सब कुछ सामान्य रेगेक्स की तरह पढ़ता है, सिवाय इसके कि:

` भागने के लिए प्रयोग किया जाता है,
<> क्रमशः मैच पॉइंटर को बाएँ / दाएँ घुमाएँ,
^6 बाईं ओर का सामना करने के लिए मैच पॉइंटर सेट करता है, और
\ मैच पॉइंटर को ऑर्थोगोनली रूप से दाईं ओर खिसका देता है (जैसे अगर पॉइंटर का दाहिना ओर है तो यह एक पंक्ति से नीचे चला जाता है)

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

तो ऐसा करने के लिए हम उपरोक्त रेगेक्स का विस्तार प्रत्येक दोष के लिए सही समय से करने के लिए करते हैं, जिसकी मदद से o ओवरलैपिंग मैच मोड । टूट गए, घटक हैं:

1 11:    `_`\.?<.?>?.?.?
2 10:    `/\`_.?(.<.?>?.?)?
4 9:     `_`/(.?>.?.?.?|<`_)
3 12:   ^6 `_`/.?.?>.?.?.?
5 7:    ^6 `\\`_.?<?.?[ _]?
6 8:    ^6 `_`\.?(<.?|>).?

हां, यह ?संख्याओं को सही पाने के लिए एक असफल उपयोग है : पी

— Sp3000
स्रोत

हाहा, अद्भुत। मुझे अपनी भाषा में अधिक प्रकार के आउटपुट जोड़ने की आवश्यकता है।

— BMac

4

जावास्क्रिप्ट (ईएस 6), 67 72

बस दिए गए 12 स्थानों में रिक्त स्थान की तलाश करता है

सहेजे गए 5 बाइट संपादित करें , thx @apsillers

F=b=>[..."0h9fnopia8evx"].map((v,i)=>b[parseInt(v,34)]>' '?0:d=i)|d

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

x='  ___\n /\\_/\\\n/_/ \\_\\\n\\ \\_/ /\n \\/_\\/' // no defects
;[...x].forEach((c,p,a)=>{
  a[p]=' ' // put a blank
  y=a.join('') // rebuild a string
  d=F(y) // check
  if (d) console.log('\n'+y+'\n'+d) // if defect, output
  a[p]=c // remove the blamk
})

उत्पादन

  ___
 / _/\
/_/ \_\
\ \_/ /
 \/_\/
9

  ___
 /\ /\
/_/ \_\
\ \_/ /
 \/_\/
2

  ___
 /\_ \
/_/ \_\
\ \_/ /
 \/_\/
8

  ___
 /\_/\
/ / \_\
\ \_/ /
 \/_\/
10

  ___
 /\_/\
/_  \_\
\ \_/ /
 \/_\/
3

  ___
 /\_/\
/_/  _\
\ \_/ /
 \/_\/
1

  ___
 /\_/\
/_/ \ \
\ \_/ /
 \/_\/
7

  ___
 /\_/\
/_/ \_\
\  _/ /
 \/_\/
4

  ___
 /\_/\
/_/ \_\
\ \ / /
 \/_\/
5

  ___
 /\_/\
/_/ \_\
\ \_  /
 \/_\/
6

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \ _\/
11

  ___
 /\_/\
/_/ \_\
\ \_/ /
 \/_ /
12

— edc65
स्रोत

@ अंतराल यह अच्छा है और बेहतर भी है, धन्यवाद। चूंकि इनपुट स्ट्रिंग हमेशा '' से शुरू होती है, अग्रणी 0 पहले लूप में d से i के इनिशियलाइज़ेशन को बल देता है, इसलिए 'd = 0' को हटाया जा सकता है।

— edc65

2

सी, 98 84 बाइट्स

g(char*b){char*c="/'-5670(&,=?",*a=c;for(;*c&&!(*b=b[*c++-30]-32?0:c-a););return*b;}

अद्यतन: स्ट्रिंग के बारे में थोड़ा और अधिक चतुर, और गैर-खराब माणिक के साथ एक मुद्दा तय किया।

सुलझाया:

g(char*b){
    char*c="/'-5670(&,=?",*a=c;
    for(;*c&&!(*b=b[*c++-30]-32?0:c-a);)
        ;
    return*b;
}

एकदम सीधा, और बस 100 बाइट्स के नीचे।

परीक्षण के लिए:

#include "stdio.h"
int main() {
    char b[100];
    scanf("%35c", b);
    printf("%d\n", g(b));
    return 0;
}

STDIN पर इनपुट

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

माणिक में प्रत्येक दोष एक अलग चरित्र में स्थित है। यह सूची बताती है कि इनपुट स्ट्रिंग में प्रत्येक दोष कहाँ होता है:

Defect 1: 17
Defect 2: 9
Defect 3: 15
Defect 4: 23
Defect 5: 24
Defect 6: 25
Defect 7: 18
Defect 8: 10
Defect 9: 8
Defect 10: 14
Defect 11: 31
Defect 12: 33

{17,9,15,23,24,25,18,10,8,14,31,33}बहुत सारी बाइट्स की एक सरणी बनाने के बाद से , हम इस सूची को बनाने के लिए एक छोटा रास्ता ढूंढते हैं। गौर करें कि पूर्णांक की सूची में प्रत्येक संख्या के परिणाम में 30 जोड़कर जिन्हें मुद्रण योग्य ASCII वर्णों के रूप में दर्शाया जा सकता है। इस सूची इस प्रकार है: "/'-5670(&,=?"। इस प्रकार, हम cइस स्ट्रिंग में एक कैरेक्टर ऐरे (कोड में ) सेट कर सकते हैं , और हम इस सूची से प्राप्त हर मूल्य से 30 घटा सकते हैं, ताकि हम अपने मूल पूर्णांक को प्राप्त कर सकें। हम इस बात पर नज़र रखने के लिए aसमान रूप से परिभाषित करते हैं कि हमने cकितनी सूची प्राप्त की है। कोड में केवल एक चीज बची है for। यह सुनिश्चित करने के लिए जाँच करता है कि हमने cअभी तक अंत नहीं मारा है, और फिर जाँचता है कि क्या bकरंट का चरित्रc एक स्थान (ASCII) है। यदि यह है, तो हम पहले, अप्रयुक्त तत्व को सेट करते हैंb दोष संख्या और इसे वापस करने के लिए।

— BrainSteel
स्रोत

2

पायथन 2, 146 88 86 71 बाइट्स

फ़ंक्शन fप्रत्येक सेगमेंट स्थान का परीक्षण करता है और दोष खंड के सूचकांक को लौटाता है। इनपुट स्ट्रिंग में पहले बाइट पर एक परीक्षण यह सुनिश्चित करता है कि 0यदि कोई दोष नहीं मिला है तो हम वापस लौटते हैं।

अब हम सेगमेंट ऑफ़सेट को एक कॉम्पैक्ट स्ट्रिंग में पैक करते हैं और ord()उन्हें पुनर्प्राप्त करने के लिए उपयोग करते हैं:

f=lambda s:sum(n*(s[ord('ARJPXYZSKIO`b'[n])-65]<'!')for n in range(13))

एक पूर्ण रूबी के साथ परीक्षण:

f('  ___\n /\\_/\\\n/_/ \\_\\\n\\ \\_/ /\n \\/_\\/')
0

एक खंड द्वारा प्रतिस्थापित खंड 2 के साथ परीक्षण:

f('  ___\n /\\ /\\\n/_/ \\_\\\n\\ \\_/ /\n \\/_\\/')
2

संपादित करें: अच्छी sum(n*bool for n in...)तकनीक के लिए @xnor को धन्यवाद ।

EDIT2: अतिरिक्त गोल्फ टिप्स के लिए @ Sp3000 को धन्यवाद।

— तर्क नाइट
स्रोत

2

मुझे लगता है कि आप एक संकेतक-राशि का उपयोग करके चार्ट को बचा सकते हैं sum(n*(s[...]==' ')for ...)।

— xnor

1

यह देखते हुए कि प्रतिस्थापित चर अंतरिक्ष के बाद हैं, आप शायद बाइट के <'!'बजाय कुछ ऐसा कर सकते हैं ==' '। आप के साथ सूची भी उत्पन्न कर सकते हैं map(ord, ...), लेकिन मुझे यकीन नहीं है कि आप

— unprintables के

1

पायथ, 35 31 28 बाइट्स

hx"*6#,54@"C%imCds.zT67

एक पैथ पाइथ की आवश्यकता होती है , के वर्तमान नवीनतम संस्करण में स्ट्रिपिंग कैरेक्टर्स से .zस्ट्रिप्स में एक बग है ।

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

उत्तर में अनपेक्षित वर्ण शामिल हैं, अपनी मशीन पर प्रोग्राम को सटीक रूप से उत्पन्न करने के लिए इस पायथन 3 कोड का उपयोग करें:

garbage = [42, 22, 54, 35, 44, 28, 31, 53, 52, 64, 16, 11]
prg = 'hx"' + "".join(chr(c) for c in garbage) +'"C%imCds.zT67'
open("golf_gen.pyth", "w").write(prg)
print(len(prg))

— orlp
स्रोत

1

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

f l=last[x|x<-[0..12],l!!([0,17,9,15,23,24,25,18,10,8,14,31,33]!!x)==' ']

कई अन्य समाधानों के समान रणनीति: दिए गए स्थानों पर रिक्त स्थान की तलाश में। लुकअप सूचकांकों की एक सूची देता है जिसमें से मैं अंतिम तत्व लेता हूं, क्योंकि सूचकांक 0 के लिए हमेशा हिट होता है।

— nimi
स्रोत

0

05AB1E , 16 बाइट्स

•W)Ì3ô;4(•₆вèðk>

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

स्पष्टीकरण:

•W)Ì3ô;4(•        # Push compressed integer 2272064612422082397
          ₆в      # Converted to Base-36 as list: [17,9,15,23,24,25,18,10,8,14,31,33]
            è     # Index each into the (implicit) input-string
             ðk   # Get the 0-based index of the first space in the indexed characters
                  # (-1 if not found, which means the ruby had no defects)
               >  # And increase it by 1 (which is output implicitly as result)

(वर्गों मेरा यह 05AB1E टिप देखें कितना बड़ा पूर्णांक संपीड़ित करने के लिए? और कैसे संपीड़ित पूर्णांक सूचियों के लिए? ) को समझने के लिए क्यों •W)Ì3ô;4(•है 2272064612422082397और •W)Ì3ô;4(•₆вहै [17,9,15,23,24,25,18,10,8,14,31,33]।

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

आधिकारिक रूबी इंस्पेक्टर

चुनौती

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

सीजेएम, 27 23 बाइट्स

रूबी 2.0, 69 बाइट्स

जूलिया, 90 59 बाइट्स

> <> (मछली) , 177 बाइट्स

CJam, 41 31 29 28 बाइट्स

पर्ची , 123 108 + 3 = 111 बाइट्स

जावास्क्रिप्ट (ईएस 6), 67 72

सी, 98 84 बाइट्स

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

पायथन 2, 146 88 86 71 बाइट्स

पायथ, 35 31 28 बाइट्स

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

05AB1E , 16 बाइट्स