कार्य:

आपकी चुनौती है, पिछली सबमिशन और खुद को इनपुट के रूप में, उस भाषा को आउटपुट करना, जिसे उन्होंने निम्नलिखित प्रारूप में लिखा है:

बता दें कि पहला कार्यक्रम रूबी में है। इसे आउटपुट करना होगा 1, क्योंकि रूबी 1इस चुनौती में इस्तेमाल की जाने वाली सेंट लैंग्वेज है। एक उदाहरण कार्यक्रम है:

a=gets
puts 1

जब खुद को इनपुट के रूप में दिया जाता है, तो यह वापस आ जाता है 1।

अगला कार्यक्रम पाइथन में हो सकता है। इसे आउटपुट करना होगा 2, क्योंकि पायथन 2चुनौती में इस्तेमाल की जाने वाली एनडी भाषा है। एक उदाहरण कार्यक्रम है:

print(1 if input()[0]=="a"else 2)

पहले सबमिशन को देखते हुए, यह आउटपुट करता है 1, और खुद को यह आउटपुट देता है2 ।

आपको भाषाएँ दोहराने की अनुमति है, हालाँकि आपको पिछली उत्तर की भाषा में उत्तर प्रस्तुत करने की अनुमति नहीं है।

उदाहरण के लिए, यदि तीसरा प्रोग्राम रूबी में है, तो उसे 1पहले प्रोग्राम और खुद को दिया जाना चाहिए (क्योंकि रूबी 1इस्तेमाल की गई भाषा है), और दूसरे प्रोग्राम को इसे आउटपुट देना होगा 2।

नियम:

यदि nवर्तमान में चुनौती में उत्तर हैं , तो कम से कम होना चाहिएfloor(n / 3) विभिन्न भाषाएं । कोई भी सबमिशन जो इस नियम को तोड़ता है वह अयोग्य है।
कोई भी दो "पड़ोसी उत्तर" (जैसे उत्तर nऔर उत्तर n+1) एक ही भाषा का उपयोग नहीं कर सकते हैं।
किसी भाषा के विभिन्न संस्करण अलग-अलग भाषाओं (इसलिए Python 2 == Python 3) के रूप में नहीं गिने जाते हैं ।
उत्तर को इनपुट के रूप में पिछले सबमिशन को पूरा करना होगा।
पहला सबमिशन इनपुट लेना होगा।
आपको एक पंक्ति में कई जवाब प्रस्तुत करने की अनुमति नहीं है।
"उत्तर दोहराएं" (उत्तर प्रस्तुत करने के समान सटीक कोड वाले उत्तर) की अनुमति नहीं है।
उत्तर को उस उत्तर की आवंटित बाइट-काउंट पर जाने की अनुमति नहीं है - अधिक विवरण के लिए "आवंटित बाइट-काउंट" देखें।

आवंटित बाइट-गणना:

प्रत्येक उत्तर संख्या के लिए n, उस उत्तर के लिए आवंटित बाइट-गिनती है 45 + 5n।

उत्तर स्वरूपण:

अपने उत्तर को इस तरह प्रारूपित करें:

# {answer no.}, {language}
{program}
This prints:
- `1` in answer(s) {all answers using 1st language, with links}
- `2` in answer(s) {all answers using 2nd language, with links}
...
{optional explanation}

उत्तर सूचियों के लिए, यह करें:

- `1` in answers [1]({link to answer}), [3]({link to answer})...

स्कोरिंग:

7 दिनों के बाद जीवित रहने का पहला उत्तर बिना किसी वैध प्रस्तुत के उसके बाद विजेता घोषित किया जाता है।

classification answer-chaining

— clismique
स्रोत

1

क्या एक उपयोगकर्ता एक पंक्ति में लगातार दो प्रस्तुतियाँ कर सकता है?

— कृतिका लिथोस

इसलिए, जैसा कि यह खड़ा है, मैं किसी भी बदलाव के बिना, अपने उत्तर n ° 6 को उत्तर n ° 8 के रूप में दोहरा सकता हूं, जिसके बाद मार्टिन अपना नंबर n ° 7 (जब तक मैं गलत नहीं हूं) आदि को उत्तर n ° तक दोहरा सकता हूं। 15 लगाए गए सीमा (यानी floor(n / 3)भाषाओं) तक पहुंचने से पहले । मैं अनुमान लगा रहा हूं कि यह अभिप्रेत व्यवहार नहीं है।

— प्लेनापस

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

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

3

आवंटित बाइट गिनती ज्यामितीय प्रगति में बढ़ती है, और शायद ये चुनौती तब तक समाप्त नहीं होगी जब तक हम भाषाओं से बाहर नहीं निकलते, इसलिए नहीं कि कोड बहुत लंबा हो जाएगा।

— वुल्फराम

2

IMO एक उचित निश्चित सीमा (उदाहरण के लिए 384 या 256 बाइट्स), ने बेहतर काम किया होगा, और अंत में एक तंग प्रतियोगिता को ट्रिगर करेगा।

— जेपेलिन

4

(भाषा 12), 164 बाइट्स

मेरा पहला कार्यक्रम> <> में है! यह 156 वर्ण का है, लेकिन UTF-8 में 164 बाइट्स है।

^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
{:}&1+&=?v
      .&0/
v+!?='>'i41i
v+?='y'i47
v+?=' 'i12
v+?=' 'i24
v4
v6
v7
v8
v9
va
  v?(0:i
v1
n;\b1laa*)?+
/"^mwfPes{'tc"i2&01.;

यह प्रिंट:

1उत्तर 1 , 5 , 7 , 9 और 14 (रेटिना) के साथ।
2उत्तर 2 (ब्रेन-फ्लैक) के साथ।
3उत्तर 3 (APL) के साथ।
4उत्तर 4 , 12 और 15 (जावास्क्रिप्ट) के साथ।
56 और 8 (आर) के जवाब के साथ ।
610 , 17 , 20 , 22 और 25 (बाश) उत्तरों के साथ ।
711 और 19 के उत्तर के साथ (गणितज्ञ)।
8उत्तर 13 (पायथन) के साथ।
9उत्तर 16 (पर्ल) के साथ।
10उत्तर 18 , 21 और 23 (C / C ++) के साथ।
11उत्तर 24 (Zsh) के साथ।
12 इस उत्तर के साथ (> <>)।

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

स्पष्टीकरण:

पहली पंक्ति केवल उत्तर # 5 है। यह कुछ नहीं करता है, लेकिन निर्देश सूचक को नीचे की रेखा पर भेजें। /मछली को सही मोड़ देता है, और पात्रों ^mwfPes{'tcको ढेर पर रख दिया जाता है। इनपुट का एक एकल वर्ण पढ़ा जाता है ( i)। (चलो इस चरित्र Cको प्रदर्शनी के लिए कहते हैं ।) 2 रजिस्टर में डाल दिया गया है ( 2&)। फिर हम दूसरी पंक्ति (पंक्ति 1) की शुरुआत में कूदते हैं (01. ) ।

यह पंक्ति Cस्टैक पर प्रत्येक वर्ण की तुलना करती है। Cस्टैक के तल पर एक प्रति रखी जाती है। {स्टैक को घुमाता है इसलिए Cशीर्ष पर है; :इसे दोहराता है; }कॉपी को वापस नीचे की ओर घुमाता है। हम रजिस्टर ( &1+&) को एक मैच नहीं मिलने तक बढ़ाते हैं। (इसलिए यदि C"ग" है, तो रजिस्टर 3 मिलता है जब मैच पाया जाता है; यदि C"टी" है, तो रजिस्टर 4 रखता है, और इसी तरह।) फिर हम रजिस्टर में लाइन नंबर के पहले अक्षर पर जाते हैं (0&. ) ।

लाइन्स 3 को 13 के माध्यम से Cक्रमशः सी, टी, ', {, आदि के साथ क्या करना है। जब हम कूदते हैं तो निर्देश सूचक पीछे की ओर बढ़ रहा होता है; यह दी गई रेखा के पहले वर्ण पर उतरता है, लेकिन एक छलांग के बाद यह निष्पादित करने से पहले एक टिक को आगे बढ़ाता है, इसलिए यह पीछे की ओर जाने वाली रेखा के अंत से निष्पादित करना शुरू कर देता है। प्रत्येक पंक्ति स्टैक पर उपयुक्त भाषा संख्या को धक्का देती है, फिर मछली को nनिर्देश पर नीचे भेजती है , जो इसे प्रिंट करती है।

^इस जवाब की पहली पंक्ति के साथ मेरे अपने नृशंसता के कारण सबसे जटिल मामला है। लाइन 13 ईओएफ तक इनपुट पढ़ता है। फिर यह 15 की रेखा के नीचे जाता है, जो स्टैक की लंबाई ( l) से 100 ( aa*) तक की तुलना करता है । अगर यह लंबा है ( )?), हम जोड़ते हैं + bऔर 112 पाने के लिए, यह भाषा; अन्यथा, स्टैक के शीर्ष पर 1 रहता है।

— निक मत्ते
स्रोत

23

1. रेटिना , 0 बाइट्स

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

1खाली इनपुट (यानी खुद) दिए जाने पर खाली प्रोग्राम प्रिंट करता है, क्योंकि यह गिनता है कि खाली रेगेक्स इनपुट से कितनी बार मेल खाता है (जो हमेशा होता है 1+length(input))।

— मार्टिन एंडर
स्रोत

12

2. ब्रेन-फ्लैक , 22 बाइट्स

{<>(())(<>)}{}(<>{}())

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

यह स्टैक के शीर्ष की जांच करता है और गैर-शून्य होने पर विपरीत स्टैक पर एक डालता है। यह फिर वृद्धि करता है और विपरीत स्टैक को वापस करता है। यह खाली प्रोग्राम के लिए 1 और किसी और चीज के लिए 2 रिटर्न देता है।

चूंकि ब्रेन-फ्लैक डिफॉल्ट में शून्य पर ढेर हो जाता है, एक खाली प्रोग्राम में स्टैक के शीर्ष पर एक शून्य होगा, जबकि किसी भी अन्य प्रोग्राम (प्रोग्राम्स को छोड़कर जो अशक्त वर्णों में समाप्त होते हैं) का सत्य मूल्य होगा। इसका मतलब है कि अगर हम इनपुट स्टैक पर प्रोग्राम करते हैं तो हम बहुत सरल तरीके से चल सकते हैं।

{      (<>)}{}              #If not zero
 <>(())                     #Push one to the other stack
              (<>{}())      #Switch to other stack and increment by one

— गेहूं का जादूगर
स्रोत

क्या आप इस उत्तर को संपादित कर सकते हैं? मैंने गलती से इसे वोट दिया :)

— कॉनर ओ'ब्रायन

9

3. एपीएल, 7 बाइट्स

' {'⍳⊃⍞

स्पष्टीकरण:

      ⍞  read from the keyboard
     ⊃   first item of list, or space if empty
' {'⍳    index into the string ' {', giving N+1 (=3) if not found

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

8

10. बैश (+ कोरुटिल्स) [भाषा 6], 44, 74 बाइट्स

निश्चित संस्करण (भाषा आईडी लौटाता है)

expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G

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

— टसेपेल्लिन
स्रोत

7

9. रेटिना (भाषा 1), 20 बाइट्स

$|}\{|[:'][^]']|,\b1

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

प्लेनैपस की तरह, मैंने चीजों को थोड़ा बदलने के लिए फिर से लिखने का फैसला किया, जिसने कोड को काफी छोटा कर दिया (प्लाननापस के नवीनतम के लिए मेरे आखिरी जवाब के संशोधन में लगभग 32 बाइट्स समाप्त हो गए होंगे, मुझे लगता है)।

व्याख्या

मेरे अन्य उत्तरों की तरह, यह सिर्फ विभिन्न रेगेक्स मैचों की संख्या को गिनाता है, लेकिन इसके बारे में और अधिक कुशलता से बताता है:

$स्ट्रिंग के अंत से मेल खाता है। यह हमेशा काम करता है, भले ही स्ट्रिंग के अंत तक सभी तरह से मैच हो रहा हो, इसलिए यह हमें 1सभी इनपुट के लिए एक आधार रेखा प्रदान करता है।
}\{दूसरे कार्यक्रम (ब्रेन-फ्लैक) में एक ही मैच पाता है, जिससे वहां गिनती बढ़ जाती है 2। भागने के लिए बैकस्लैश आवश्यक नहीं है, लेकिन यह रेगेक्स के इस हिस्से को मिलान करने से रोकता है।
[:'][^]']वास्तव में सुंदर है। एकमात्र उद्देश्य 'एपीएल कार्यक्रम (भाषा 3) में दो और :जावास्क्रिप्ट कार्यक्रम (भाषा 4) में तीन की गणना करना है, लेकिन हमें इस हिस्से को मिलान करने से रोकने की आवश्यकता है। इसलिए हम यह भी सुनिश्चित करते हैं कि अगला चरित्र न तो है ', और न ही ](क्योंकि जो हम मैच नहीं करना चाहते हैं, उसके बाद दिखाई नहीं देते हैं , लेकिन वे यहां इस कार्यक्रम में दिखाई देते हैं)।
'पिछले भाग से पहले से ही, अनुसंधान कार्यक्रमों में एक मैच का कारण बनता है तो हम तीन और की जरूरत है। सबस्ट्रिंग ,1उन दोनों में तीन बार दिखाई देता है, और अन्य कार्यक्रमों में नहीं। हम इसे ,\b1फिर से मिलान करने से रोकने के लिए बीच में एक शब्द को जोड़कर जोड़ते हैं ।

— मार्टिन एंडर
स्रोत

हम्म, बस एहसास हुआ कि यह आर जवाबों को बिल्कुल भी पन्नी नहीं करता है, क्योंकि 1बस उनका डिफ़ॉल्ट आउटपुट है। मुझे अगले उत्तर के साथ उसके बारे में कुछ करना होगा।

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

7

18. सी (भाषा 10), 121 बाइट्स

यह C89 या C90 मानक है। यह या तो ऑनलाइन क्लैग या जीसीसी के साथ काम करता है।

main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}

यह प्रिंट:

1उत्तर 1 , 5 , 7 , 9 और 14 (रेटिना) के साथ।
2उत्तर 2 (ब्रेन-फ्लैक) के साथ।
3उत्तर 3 (APL) के साथ।
4उत्तर 4 , 12 और 15 (जावास्क्रिप्ट) के साथ।
56 और 8 (आर) के जवाब के साथ ।
610 और 17 के जवाब के साथ (बैश)।
7उत्तर 11 (गणितज्ञ) के साथ।
8उत्तर 13 (पायथन) के साथ।
9उत्तर 16 (पर्ल) के साथ।
10 इस उत्तर के साथ (सी)।

यहाँ एक बैश ड्राइवर है जो इसे ऑनलाइन प्रयास करने पर सभी 18 उत्तरों के साथ चलाता है !

Ungolfed समकक्ष (646 बाइट्स):

#include <string.h>
#include <stdio.h>
int main(){
    char *v=" ^{ s ePfwm", b[999];
    gets(b); /* buffer overrun if more than 998 characters in the input.
                could be a problem if we get to 191 answers */
    char *c = strchr(v, b[0]); /* Find first character of input in v, or null */
    int n = strlen(b);
    if (!n) {
        printf("1");
    } else if (c) {
        printf("%d", c-v); /* Index of first character of input in v */
    } else if (n > 99) {
        printf("4");
    } else if (n > 60) {
        printf("5");
    } else if (n > 15) {
        printf("1");
    } else {
        printf("3");
    }
    return 0;
}

— निक मत्ते
स्रोत

6

5. रेटिना (भाषा 1), 23 बाइट्स

^$|(?![⊂⍴])[⊂-⍴]|\B=|{}

इसे ऑनलाइन आज़माएं! (सभी संभावित आदानों का परीक्षण)

इनपुट में विभिन्न चीजों के मिलान गिनाते हैं:

^$ इनपुट स्ट्रिंग से मेल खाता है, यानी पहला उत्तर एक बार।
{} खुद से मेल खाता है, जो दूसरे कार्यक्रम में दो हैं, और इस एक में एक है।
(?![⊂⍴])[⊂-⍴]कोड अंक 8834 से 9076 तक अनन्य के साथ मेल खाता है , जो तीसरे कार्यक्रम में तीन मैच पाता है। हम इस कार्यक्रम में मिलान की जा रही सीमा के सिरों से बचने के लिए ऋणात्मक रूप का उपयोग करते हैं।
\B=एक ऐसे शब्द से मेल खाता है =जो एक शब्द चरित्र से पहले नहीं है । यह =चौथे कार्यक्रम में चार से मेल खाता है , और =इस कार्यक्रम में मेल नहीं खाता है ।

— मार्टिन एंडर
स्रोत

5

7. रेटिना (भाषा 1), 27 बाइट्स

^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5

इसे ऑनलाइन आज़माएं!(सभी संभावित आदानों का परीक्षण)

पांचवें उत्तर का एक मामूली संशोधन । \B=पहले से ही छठे उत्तर में 4 मैच ढूंढता है, और \b5किसी अन्य उत्तर के मिलान के बिना दूसरा पाता है।

— मार्टिन एंडर
स्रोत

4

4, जावास्क्रिप्ट (ईएस 6), 32 बाइट्स

s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1

एक खाली इनपुट के लिए आउटपुट 1, 2 अगर इनपुट के साथ शुरू होता है {, 4 अगर यह एक sऔर 3 के साथ शुरू होता है अन्यथा ।।

— ल्यूक
स्रोत

आप की जगह ले सकता s[0]=='{'द्वाराs[0]>'z'

1

@Masterzagh I was also thinking about how this can be golfed, but alas, this isn't a code-golf :/

— Kritixi Lithos

@KritiiLithos अच्छी तरह से हाँ, लेकिन वह पहले से ही इसे पसंद किया है इसलिए मुझे लगा कि वह आगे जाना चाहेगी।

@Masterzagh लोगों को इस तरह की चुनौतियों में मान्य उत्तरों को संपादित करने से बचना चाहिए क्योंकि वे a) बाद के उत्तरों को अमान्य कर सकते हैं, b) ऐसे उत्तर जो वर्तमान में काम कर रहे हैं।

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

@MartinEnder, आप सही कह रहे हैं। जैसे कि मैं इसे संपादित नहीं करूंगा। मुझे पता है कि यह गुदगुदी (टर्नरी ऑपरेटरों की वजह से) दिखता है, लेकिन मैंने इसे इस तरह नहीं लिखा था ... फिर भी सभी प्रतिक्रिया के लिए धन्यवाद!

— ल्यूक

4

11. गणितज्ञ [भाषा 7], 53 बाइट्स

Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&

Unnamed function taking a list of characters as its argument and outputting a positive integer. Simply branches on the first letter of the input, using its position in the string "^{'sceP" to decide on the output. This gives the right answer for all previous submissions except the initial empty Retina program and the most recent Retina answer; both of these spit errors, but the output is repaired by the rule /._@__->1 which transforms any unevaluated function to 1.

— Greg Martin
स्रोत

I think it's really time to mess up that first-character strategy :)

— Martin Ender

1

मैं जा रहा था, लेकिन फिर मुझे याद आया कि मुझे अपनी भाषा के लिए भी सही ढंग से आउटपुट देना है: डी

— ग्रेग मार्टिन

4

16. पर्ल (भाषा 9), 94 बाइट्स

while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}

इसे ऑनलाइन आज़माएं! (checks all answers). Outputs "1234151516748149"

यह प्रिंट:

1 उत्तर, 5, 7, 9 और 14 (रेटिना) के साथ।
2 उत्तर 2 (ब्रेन-फ्लैक) के साथ।
3 उत्तर 3 (एपीएल) के साथ।
4 उत्तर, 12 और 15 (जावास्क्रिप्ट) के साथ 4।
5 उत्तर 6 और 8 (आर) के साथ।
उत्तर 10 (बाश) के साथ 6।
7 उत्तर 11 (गणितज्ञ) के साथ।
8 उत्तर 13 (पायथन) के साथ।
9 इस उत्तर के साथ (पर्ल)।

कार्यक्रम इनपुट लंबाई की जाँच करता है और इसे वर्तमान भाषा वितरण के लिए मैप करता है।

— Lyth
स्रोत

3

6. आर (भाषा 5), 61 बाइट्स

cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))

जाँचता है कि इनपुट का पहला वर्ण क्या है और तदनुसार आउटपुट चुनें।

इस प्रकार प्रिंट करता है:

1उत्तर 1 और 5 (रेटिना) के साथ।
2उत्तर 2 (ब्रेन-फ्लैक) के साथ।
3उत्तर 3 (APL) के साथ।
4उत्तर 4 (जावास्क्रिप्ट) के साथ।
और 5इस जवाब के साथ।

उपयोग:

> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))

1
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
{<>(())(<>)}{}(<>{}())
2
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
' {'⍳⊃⍞
3
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
4
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
1
> cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
5

— plannapus
स्रोत

REPL के बाहर इसे चलाने के लिए, उत्तर 8 के तहत टिप्पणी देखें।

— plannapus

3

8. आर (भाषा 5), 76 बाइट्स

c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)

इनपुट के पहले अक्षर की जांच करता है, और एक वेक्टर युक्त के साथ तुलना (इसी क्रम में) रिक्त स्ट्रिंग, {, ', sऔर c। यह मैच के इंडेक्स (आर इंडेक्सिंग 1-आधारित) या 1 होता है अगर मैच नहीं होता है।

उत्तर n ° 6 के रूप में समान अवधारणा लेकिन उत्तर n ° 7 को मिलान करने से रोकता है।

यह प्रिंट:

1उत्तर 1 , 5 और 7 (रेटिना) के साथ।
2उत्तर 2 (ब्रेन-फ्लैक) के साथ।
3उत्तर 3 (APL) के साथ।
4उत्तर 4 (जावास्क्रिप्ट) के साथ।
और 5उत्तर 6 और इस उत्तर (R) के साथ।

If I'm not mistaken, the byte-count allowance for this answer was 94 bytes.

— plannapus
स्रोत

FYI R online interpreters (rfiddle, ideone and tryitonline) seems to have problem handling stdin (at least with readline() ) and thus won't behave properly. If you want to try this (and the previous answer) you'll have to try locally on an installed version of R, i'm afraid.

— plannapus

^ ठीक है, एक REPL के बाहर से readlineप्रतिस्थापित किया जाना चाहिए readLines(file("stdin"))। जिसका अर्थ है 16 अधिक वर्ण: उत्तर 6 इसलिए 77 बाइट्स (79 अनुमत में से) होना चाहिए और यह 92 बाइट्स (94 में से) का उत्तर है। इस परिवर्तन के साथ यह ऑनलाइन दुभाषियों पर भी काम करता है।

— प्लेनैपस

3

12. जावास्क्रिप्ट (भाषा 4), 117 बाइट्स

नोट: मैंने इस एक गलती को सुधारने के लिए एक चरित्र को बदल दिया।

c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;

इनपुट का पहला अक्षर चेक करता है, अगर यह c है, तो इनपुट की लंबाई की जाँच करता है।

आउटपुट:

1 उत्तर, 1, 5, 7, 9 के लिए
2 उत्तर के लिए 2
उत्तर 3 के लिए 3
उत्तर 4 के लिए 4 और यह उत्तर
5 जवाब 6, 8 के लिए
उत्तर 10 के लिए 6
उत्तर 11 के लिए 7

— Devsman
स्रोत

3

13. पायथन (भाषा 8), 110 बाइट्स

नोट: यह उत्तर ओपी की सिफारिश पर पोस्ट करने के 6 घंटे बाद बदल दिया गया था।

from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N

यह उत्तर 10 (बैश) के रूप में एक ही विचार है, लेकिन पायथन 3 में (यह दृष्टिकोण हेक्स अंकों से बाहर निकलने से पहले सबसे अधिक 3 और प्रविष्टियों के लिए काम कर सकता है।)

यह प्रिंट:

1उत्तर 1 , 5 , 7 और 9 (रेटिना) के साथ।
2उत्तर 2 (ब्रेन-फ्लैक) के साथ।
3उत्तर 3 (APL) के साथ।
4उत्तर 4 और 12 (जावास्क्रिप्ट) के साथ।
56 और 8 (आर) के जवाब के साथ ।
6उत्तर 10 (बाश) के साथ।
7उत्तर 11 (गणितज्ञ) के साथ।
8 इस जवाब के लिए (पायथन)।

Try it online! for: Answer 1, Answer 2, Answer 3, Answer 4, Answer 5, Answer 6, Answer 7, Answer 8, Answer 9, Answer 10, Answer 11, Answer 12, or this answer.

— Nick Matteo
स्रोत

What is the current byte limit?

— Vi.

@Vi: खैर, यह उत्तर 13 के लिए 149 और उत्तर 14 के लिए 163 था; लेकिन ओपी ने बाइट काउंट नियमों को बदलकर 45 + 5n कर दिया, ताकि उत्तर 13 के लिए 110 बाइट्स और उत्तर 14. के लिए 115 बाइट्स हो जाएं

— निक

आपको शायद 110 बाइट समाधान ऊपर रखना चाहिए।

— क्लिस्मिक

@ Qwerp-Derp: बिलकुल ठीक। उम्मीद है कि किसी के चल रहे काम को तोड़ेगी नहीं।

— निक मैटेओ

ठीक है, बाइट की सीमा जावा-अनुकूल भूमि तक पहुंचने तक लगभग 60 उत्तरों की प्रतीक्षा कर रही है।

— वि।

3

24. ज़ीश (भाषा 11), 142 बाइट्स

My previous answer #18 in C still works unmodified for all the subsequent entries (demo). So let's mix it up a little.

typeset -A p
p=("[\$^]*|'\[*" 1 '{*' 2 "' *" 3 '?=>*' 4 'c?[wt]*' 5 'e*' 6 'P*' 7 'f*' 8 'w*' 9 'm*' 10 'ty*' 11)
echo ${p[(k)$1]:-1} #@<`w&X{

The purpose of the comment at the end is to match the length of answers 21 and 23, and ensure that no single character of the sha256 or sha384 hashes is unique for every answer so far, using the characters checked by Lyth's C++ answers. ;-)

This prints:

1 with answers 1, 5, 7, 9, and 14 (Retina).
2 with answer 2 (Brain-Flak).
3 with answer 3 (APL).
4 with answers 4, 12, and 15 (Javascript).
5 with answers 6 and 8 (R).
6 with answers 10, 17, 20, and 22 (Bash).
7 with answers 11 and 19 (Mathematica).
8 with answer 13 (Python).
9 with answer 16 (Perl).
10 with answers 18, 21, and 23 (C/C++).
11 with this answer (Zsh).

Try it online!

— Nick Matteo
स्रोत

I think this is the first answer to be multi-lined... +1 from me.

— clismique

2

14. Retina (language 1), 39 bytes

'[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$

Try it online! (Tests all valid inputs.)

— Martin Ender
स्रोत

1

Come on Martin, post in a different language... also, could you do the answer-formatting thing?

— clismique

3

@ Qwerp-Derp यह वास्तव में मानक रेगेक्स गोल्फ पर एक दिलचस्प बदलाव में बदल रहा है। इनपुट का एक सेट होने और उनमें से कुछ का मिलान करने और कुछ अन्य को विफल करने के बजाय, यहां आपको प्रत्येक इनपुट पर एक विशिष्ट संख्या में मिलान प्राप्त करना होगा। मुझे आश्चर्य है कि क्या यह रेगेक्स किसी बिंदु पर तेजी से उड़ जाएगा।

— Martin Ender

क्या यह वास्तव में 39 बाइट्स है? TIO 37 बाइट्स की रिपोर्ट करता है।

— अरनौलद

1

@ अर्नुलड टीआईओ रेटिना के लिए वर्णों को गिनने के लिए हार्डकोडेड है क्योंकि आप अक्सर सिंगल-बाइट एन्कोडिंग का उपयोग करते हैं। इस उत्तर के लिए UTF-8 की आवश्यकता होती है।

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

2

15. जावास्क्रिप्ट (भाषा 4), 108 बाइट्स

golfed

t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1

— टसेपेल्लिन
स्रोत

2

17. बैश (+ कोरुटिल्स + ओपनसेल) (भाषा 6), 103 बाइट्स

golfed

expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x

मेरे उत्तर # 10 के समान तकनीक का उपयोग करता है , लेकिन हेक्स के बजाय बेस 64 एनकोडेड डिक्शनरी के साथ ।

मैंने परीक्षण के लिए निम्न डेटा फ़ाइल को एक साथ रखा है:

6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

परीक्षा

for i in `seq 17`
do
  echo -n `cat lchain|sed -n $i'{p;q}'|cut -c1`=\>
  cat lchain|sed -n $i'{p;q}'|cut -c6-|\
  expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
done

6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
1=>1

— टसेपेल्लिन
स्रोत

2

19. गणितज्ञ (भाषा 7), 96 बाइट्स

Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&

इनपुट के रूप में वर्णों की सूची लेने और पूर्णांक वापस करने का कार्य करें:

1उत्तर 1 , 5 , 7 , 9 और 14 (रेटिना) के साथ।
2उत्तर 2 (ब्रेन-फ्लैक) के साथ।
3उत्तर 3 (APL) के साथ।
4उत्तर 4 , 12 और 15 (जावास्क्रिप्ट) के साथ।
56 और 8 (आर) के जवाब के साथ ।
610 और 17 के जवाब के साथ (बैश)।
7उत्तर 11 और इस उत्तर के साथ (गणितज्ञ)।
8उत्तर 13 (पायथन) के साथ।
9उत्तर 16 (पर्ल) के साथ।
10उत्तर 18 (C) के साथ।

अब तक सभी उत्तर की लंबाई अलग-अलग है, और वे भी 59 modulo अलग-अलग हैं- इसलिए पता लगाया जा सकता है कि 33, 34, ..., 91 में किस पूर्णांक से वे (mod 59) के अनुरूप हैं। ये सभी मुद्रण योग्य ASCII वर्ण हैं, जो स्ट्रिंग द्वारा एन्कोड किए गए हैं ";NRU$ Q B [1: =L J, 5% 3 # >"; ToCharacterCode@StringSplit@इस स्ट्रिंग का उपयोग उस सीमा में पूर्णांकों की दस सूचियों की सूची में बदल जाता है, और यह Position[...,Mod[Length@#,59,33]][[1,1]]पाता है कि इनपुट की संशोधित लंबाई में से कौन से दस उपविभाजक मेल खाते हैं।

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

1

20. बैश (+ कोरुटिल + ओपनसेल) (भाषा 6), 121 बाइट

golfed

expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u

मेरे उत्तर # 17 के रूप में एक ही विधि (जो बदले में मेरे मूल उत्तर # 10 पर आधारित है )।

जैसा कि अब हमारे पास 10 अलग-अलग भाषाएँ हैं, मैंने हेक्साडेसिमल स्थिति एन्कोडिंग पर स्विच कर दिया है।

डेटा

6 20 expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u
7 19 Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&
A 18 main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}
6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

परीक्षण (आउटपुट)

./test
6=>6
7=>7
A=>10
6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2

— टसेपेल्लिन
स्रोत

1

23. सी (जीसीसी) (भाषा 10), 142 बाइट्स

main(c){int d[256]={0};while((c=getchar())!=EOF)d[c]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}

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

1उत्तर 1 , 5 , 7 , 9 और 14 (रेटिना) के साथ।
2उत्तर 2 (ब्रेन-फ्लैक) के साथ।
3उत्तर 3 (APL) के साथ।
4उत्तर 4 , 12 और 15 (जावास्क्रिप्ट) के साथ।
56 और 8 (आर) के जवाब के साथ ।
610 , 17 , 20 और 22 (बाश) के उत्तर के साथ ।
7उत्तर 11 और 19 (गणितज्ञ) के साथ।
8उत्तर 13 (पायथन) के साथ।
9उत्तर 16 (पर्ल) के साथ।
10उत्तर 18 , 21 और इस उत्तर (C) के साथ।

यह कार्यक्रम विभिन्न वर्णों की संख्या (ASCII में, इसलिए मल्टी-बाइट UTF-8 वर्ण कई प्रविष्टियों में विभाजित हो जाता है) की गणना करता है और फिर इस या उस चरित्र की घटनाओं की संख्या के आधार पर सावधानीपूर्वक डिज़ाइन किए गए निर्णय ट्री का अनुसरण करता है।

निर्णय वृक्ष # 21 (या!) से अपरिवर्तित है। मुझे ठीक उसी कोड को पोस्ट करने की अनुमति नहीं है, इसलिए हम मामूली संशोधनों के साथ शुद्ध C पर वापस आ गए हैं।

— Lyth
स्रोत

0

21. सी ++ (जीसीसी) (भाषा 10 सी के एक संस्करण के रूप में), 142 बाइट्स

main(){int K,d[256]{0};while((K=getchar())!=EOF)d[K]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}

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

1उत्तर 1 , 5 , 7 , 9 और 14 (रेटिना) के साथ।
2उत्तर 2 (ब्रेन-फ्लैक) के साथ।
3उत्तर 3 (APL) के साथ।
4उत्तर 4 , 12 और 15 (जावास्क्रिप्ट) के साथ।
56 और 8 (आर) के जवाब के साथ ।
610 , 17 और 20 (बाश) के उत्तर के साथ ।
7उत्तर 11 और 19 (गणितज्ञ) के साथ।
8उत्तर 13 (पायथन) के साथ।
9उत्तर 16 (पर्ल) के साथ।
10उत्तर 18 और इस उत्तर (C) के साथ।

यह कार्यक्रम विभिन्न वर्णों की संख्या (ASCII में, इसलिए मल्टी-बाइट UTF-8 वर्ण कई प्रविष्टियों में विभाजित हो जाता है) की गणना करता है और फिर इस या उस चरित्र की घटनाओं की संख्या के आधार पर सावधानीपूर्वक डिज़ाइन किए गए निर्णय ट्री का अनुसरण करता है।

सामान्य ज्ञान : पत्र K का उपयोग इस प्रविष्टि तक नहीं किया गया था। अक्षर I, E, Y, j, k, q, z अप्रयुक्त रहते हैं।

— Lyth
स्रोत

C ++ भाषा 11 पर विचार करने के लिए एक विकल्प है, कुछ बाइट्स को फिट करने के लिए छोड़ दिया जाता है।

— Lyth

0

22. बैश (+ कोरुटिल्स) [भाषा 6], 123, 131 बाइट्स

EDIT: पहले एक गलत संस्करण प्रकाशित किया गया था, अब इसे ठीक किया जाना चाहिए।

golfed

expr substr 6A67A69418476151514321 $(expr index i3xFepQsAalyIvtqPY7ZN+ \\`openssl sha256 -binary|base64|cut -c10`) 1| dc -e16i?p #L

मेरे उत्तर # 20, # 17 और # 10 जैसी ही तकनीक ।

डेटा

6 22 expr substr 6A67A69418476151514321 $(expr index i3xFepQsAalyIvtqPY7ZN+ \\`openssl sha256 -binary|base64|cut -c10`) 1| dc -e16i?p #L
A 21 main(){int K,d[256]{0};while((K=getchar())!=EOF)d[K]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}
6 20 expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u
7 19 Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&
A 18 main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}
6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

परीक्षण चालन

./test
6=>6
A=>10
6=>6
7=>7
A=>10
6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
1=>1

— टसेपेल्लिन
स्रोत

क्या है 44?

— क्लिस्मिक

२२ * २? *

— ।

@ Qwerp-Derp, बस एक टाइपो

— टसेपेल्लिन

चलिए, आपके उत्तर अब उबाऊ हो रहे हैं - यदि आपका अगला उत्तर इस तरह है, तो मैं नीच विचार कर रहा हूं (यह दिलचस्प नहीं है, y'know?)

— clismique

1

यहाँ कुछ गलत है। आपके हैशेड पत्रों (3PgT आदि) में केवल 20 प्रविष्टियाँ हैं। खाली इनपुट के लिए मुझे एक त्रुटि मिलती है, और उत्तर # 2 के लिए मुझे "4" मिलता है (दोनों ने उत्तर के साथ सही ढंग से काम किया।)

— निक मैटेओ

0

25. बैश (भाषा 6), 169 बाइट्स

मेरे उत्तर # 22, # 20, # 17 और # 10 जैसी ही तकनीक ।

क्षमा करें @ Qwerp-Derp! ;) मैं वादा करता हूं कि यह आखिरी है :)

golfed

{ echo -n 'addsomesalt?';cat; }|expr substr 6BA6A67A69418476151514321 $(expr index 1W0TC4YrKwRGAJupDqn7Xlcog \\`openssl sha256 -binary|base64|cut -c40`) 1| dc -e16i?p #8

डेटा

ध्यान दें कि उत्तर # 24 के लिए newlines एन्कोडेड हैं

6 25 { echo -n 'addsomesalt?';cat; }|expr substr 6BA6A67A69418476151514321 $(expr index 1W0TC4YrKwRGAJupDqn7Xlcog \\`openssl sha256 -binary|base64|cut -c40`) 1| dc -e16i?p #8
B 24 typeset -A p\np=("[\$^]*|'\[*" 1 '{*' 2 "' *" 3 '?=>*' 4 'c?[wt]*' 5 'e*' 6 'P*' 7 'f*' 8 'w*' 9 'm*' 10 'ty*' 11)\necho ${p[(k)$1]:-1} #@<`w&X{
A 23 main(c){int d[256]={0};while((c=getchar())!=EOF)d[c]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}
6 22 expr substr 6A67A69418476151514321 $(expr index i3xFepQsAalyIvtqPY7ZN+ \\`openssl sha256 -binary|base64|cut -c10`) 1| dc -e16i?p #L
A 21 main(){int K,d[256]{0};while((K=getchar())!=EOF)d[K]++;printf("%d",d[88]?9:d[119]?5*d[123]:d[35]?d[38]?7:8-d[96]:d[48]?4:d[60]?2:1+d[158]*2);}
6 20 expr substr 67A69418476151514321 $(expr index 7042PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1| dc -e16i?p #u
7 19 Position[ToCharacterCode@StringSplit@";NRU$ Q B [1: =L J, 5% 3 # >",Mod[Length@#,59,33]][[1,1]]&
A 18 main(n){char*v=" ^{ s ePfwm",b[999],*c;gets(b);c=strchr(v,*b);n=strlen(b);printf("%d",n?c?c-v:n>99?4:n>60?5:n>15?1:3:1);}
6 17 expr substr 69418476151514321 $(expr index 2PtgBOlrvfDVC8ZHL `openssl md5 -binary|base64|cut -c2`) 1 #x
9 16 while(<>){print substr("1234151516748149",index("0F=POmS6D4e_XWVH",chr(47+length($_)%70)),1);}
4 15 t=>({24:2,86:3,5:4,73:5,68:5,74:7,4:6,79:4,1:8,67:4})[[...t].reduce((r,c,i)=>r*i^c.charCodeAt(0),0)&0x5F]||1
1 14 '[ ⍳]|}\{|[o@:][^]'c@:]|^c|,\b1|1\d|$
8 13 from hashlib import*;print("1234151516748"["a5e1f936cd78b".index(sha256(input().encode()).hexdigest()[34])])#N
4 12 c=>c?c[0]=='e'?6:c[0]=='$'||c[0]=='^'?1:c[0]=='c'&&c.length>80?4:c[0]=='P'?7:c[0]=='c'?5:c[0]=='{'?2:c[0]=='s'?4:3:1;
7 11 Position[Characters@"^{'sceP",#&@@#][[1,1]]/._@__->1&
6 10 expr substr "1234151516" $(expr index "365f8dc0eb" `md5sum|cut -c12`) 1 #G
1 09 $|}\{|[:'][^]']|,\b1
5 08 c=which(c("","{","'","s","c")==substr(readline(),1,1));ifelse(length(c),c,1)
1 07 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}|\b5
5 06 cat(switch(substr(readline(),1,1),"{"=2,"'"=3,"s"=4,"c"=5,1))
1 05 ^$|(?![⊂⍴])[⊂-⍴]|\B=|{}
4 04 s=>s?s[0]==`{`?2:s[0]==`s`?4:3:1
3 03 ' {'⍳⊃⍞
2 02 {<>(())(<>)}{}(<>{}())
1 01

टेस्ट आउटपुट

6=>6
B=>11
A=>10
6=>6
A=>10
6=>6
7=>7
A=>10
6=>6
9=>9
4=>4
1=>1
8=>8
4=>4
7=>7
6=>6
1=>1
5=>5
1=>1
5=>5
1=>1
4=>4
3=>3
2=>2
1=>1

— टसेपेल्लिन
स्रोत

क्या आप उस भाषा को जानते हैं?

कार्य:

नियम:

आवंटित बाइट-गणना:

उत्तर स्वरूपण:

स्कोरिंग:

26. > <> (भाषा 12), 164 बाइट्स

1. रेटिना , 0 बाइट्स

2. ब्रेन-फ्लैक , 22 बाइट्स

3. एपीएल, 7 बाइट्स

10. बैश (+ कोरुटिल्स) [भाषा 6], 44, 74 बाइट्स

9. रेटिना (भाषा 1), 20 बाइट्स

व्याख्या

18. सी (भाषा 10), 121 बाइट्स

5. रेटिना (भाषा 1), 23 बाइट्स

7. रेटिना (भाषा 1), 27 बाइट्स

4, जावास्क्रिप्ट (ईएस 6), 32 बाइट्स

11. गणितज्ञ [भाषा 7], 53 बाइट्स

16. पर्ल (भाषा 9), 94 बाइट्स

6. आर (भाषा 5), 61 बाइट्स

8. आर (भाषा 5), 76 बाइट्स

12. जावास्क्रिप्ट (भाषा 4), 117 बाइट्स

13. पायथन (भाषा 8), 110 बाइट्स

24. ज़ीश (भाषा 11), 142 बाइट्स

14. Retina (language 1), 39 bytes

15. जावास्क्रिप्ट (भाषा 4), 108 बाइट्स

17. बैश (+ कोरुटिल्स + ओपनसेल) (भाषा 6), 103 बाइट्स

19. गणितज्ञ (भाषा 7), 96 बाइट्स

20. बैश (+ कोरुटिल + ओपनसेल) (भाषा 6), 121 बाइट

23. सी (जीसीसी) (भाषा 10), 142 बाइट्स

21. सी ++ (जीसीसी) (भाषा 10 सी के एक संस्करण के रूप में), 142 बाइट्स

22. बैश (+ कोरुटिल्स) [भाषा 6], 123, 131 बाइट्स

25. बैश (भाषा 6), 169 बाइट्स