2016 टाइम कैप्सूल स्ट्रिंग: आपकी भाषा कितनी बहुमुखी है?

71

31 दिसंबर 2015 को लगभग एक साल पहले, मुझे यह विचार आया था कि:

हमें एक टाइम कैप्सूल स्ट्रिंग बनाना चाहिए। प्रत्येक व्यक्ति को एक चरित्र जोड़ना पड़ता है और अगले नए वर्षों में हम देखेंगे कि उस समय के सभी पात्रों में से सर्वश्रेष्ठ कार्यक्रम कौन बना सकता है।

दरवाज़े कृपा एकत्र पात्रों से PPCG समुदाय और उन्हें एक साल के लिए सुरक्षित रखा।

एक 74 लोगों ने भाग लिया इसलिए हमारे पास खेलने के लिए 74 मुद्रण योग्य- ASCII वर्ण हैं!

2016 के टाइम कैप्सूल स्ट्रिंग के 74 अक्षर इस प्रकार हैं कि उन्हें प्रस्तुत किया गया था:

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

यहां ASCII ऑर्डर में 2016 टाइम कैप्सूल स्ट्रिंग के 74 अक्षर दिए गए हैं (ध्यान दें कि स्पेस प्रमुख है):

 !!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

यह पूरी तरह से काम करने के लिए नहीं है, लेकिन यहां एक चुनौती हमें पसंद है।

चुनौती

यह निर्धारित करने के लिए कि कौन सी भाषा "सर्वश्रेष्ठ" है समय कैप्सूल स्ट्रिंग के साथ हमारे पास 6 (201 6 के लिए ) चुनौतियां होंगी जो कठिनाई में वृद्धि करती हैं जहां प्रत्येक में आपको 74 समय कैप्सूल वर्णों के सबसेट का उपयोग करना होगा।

6 अलग-अलग चुनौतियाँ होने से यह सुनिश्चित करने में मदद मिलती है कि अधिक भाषाएँ प्रतिस्पर्धा कर सकती हैं, लेकिन केवल सर्वश्रेष्ठ भाषाएँ ही उन सभी का उत्तर दे पाएंगी और उच्च स्कोर कर पाएंगी।

स्कोरिंग:

  • प्रत्येक चुनौती का उपयोग 0 से 74 तक किया जाएगा जो इस बात पर निर्भर करता है कि कितने वर्ण उपयोग किए गए हैं।
  • उच्च अंक बेहतर हैं।
  • यदि आपकी भाषा एक चुनौती को पूरा नहीं कर सकती है, तो उस चुनौती के लिए आपका स्कोर 0 है।
  • चुनौतियों का कोई भी खाली हिस्सा पूरा हो सकता है।
  • आपका अंतिम स्कोर सभी 6 चुनौतियों से स्कोर का योग है।
  • सर्वश्रेष्ठ अंतिम स्कोर संभव 6 × 74 या 444 है ।

चुनौतियाँ

1. भागो

अगर किसी भाषा का कोड पहली बार नहीं चल सकता है तो वह कुछ भी करने में सक्षम नहीं होगा।

सबसे लंबा पूर्ण कार्यक्रम संभव लिखें (केवल 74 समय कैप्सूल वर्णों का उपयोग करके, याद रखें) जो संकलन-समय या रनटाइम त्रुटियों के बिना चलाता / निष्पादित करता है।

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

टिप्पणियों की अनुमति है, इसलिए यह उतना ही सरल हो सकता है

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

74 के स्कोर के लिए पायथन में।

(जवाब देने से डरो मत अगर यह एकमात्र ऐसी चुनौती है जिसे आपकी भाषा पूरी कर सकती है, लेकिन बहुत सारे वोटों की उम्मीद न करें।)

स्कोर = कार्यक्रम की लंबाई (अब कार्यक्रम बेहतर है)

2. मैं / ओ

ऐसी भाषा जिसमें इनपुट या आउटपुट का कोई रूप नहीं है, लगभग उतना ही बेकार है जितना कि कोई भी नहीं चल सकता है।

समावेशी (0x33) से (0x7D) के लिए एक मुद्रण योग्य ASCII चरित्र को देखते हुए , इससे पहले और बाद में मुद्रण योग्य ASCII चरित्र को आउटपुट करता है।!}

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

उदाहरण के लिए यदि इनपुट है }उत्पादन हो सकता है |~या ["|", "~"]या | ~या |\n~।

इसी तरह, "के लिए आउटपुट है !और ACके लिए आउटपुट है B।

स्कोर = 74 - कार्यक्रम की लंबाई (छोटा कार्यक्रम बेहतर है)

3. शाखामिलन

ट्यूरिंग पूर्णता के लिए सशर्त अक्सर एक आवश्यकता होती है, जो अक्सर एक भाषा के उपयोगी होने के लिए एक आवश्यकता होती है।

एक सकारात्मक पूर्णांक को देखते हुए, यदि यह दशमलव अंकों में समाप्त होता है, 16तो 6ए में बदल जाता है 7और परिणाम को आउटपुट करता है; अन्यथा, इनपुट अपरिवर्तित आउटपुट। यदि आप पसंद करते हैं तो आप इनपुट / आउटपुट के लिए तार का उपयोग कर सकते हैं।

उदाहरण:

2016 -> 2017
16 -> 17
116 -> 117
1616 -> 1617
6 -> 6
15 -> 15
17 -> 17
106 -> 106
2106 -> 2106

स्कोर = 74 - कार्यक्रम की लंबाई (छोटा कार्यक्रम बेहतर है)

4. पाश्यता

एक भाषा जो लूप नहीं कर सकती है वह दोहराए जाने वाले कोड को थकाऊ करेगी ताकि आपको थोड़ी देर के लिए प्रोग्रामिंग ब्रेक लेने की आवश्यकता हो।

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

उदाहरण के लिए:

1    <- input
X    <- output

2
XX
XX

3
XXX
X-X
XXX

4
XXXX
X--X
X--X
XXXX

5
YYYYY
Y...Y
Y.Y.Y
Y...Y
YYYYY

6
XXXXXX
X----X
X-XX-X
X-XX-X
X----X
XXXXXX

7
ZZZZZZZ
Z-----Z
Z-ZZZ-Z
Z-Z-Z-Z
Z-ZZZ-Z
Z-----Z
ZZZZZZZ

स्कोर = 74 - कार्यक्रम की लंबाई (छोटा कार्यक्रम बेहतर है)

5. मैथ

एक भाषा जो संख्या और गणित के साथ अच्छी नहीं है, वह मानविकी की बड़ी कंपनियों के लिए भी हो सकती है।

कोई इनपुट न लें, लेकिन किसी भी क्रम में, 2016 के 72 पूर्णांक विभाजकों को सकारात्मक और नकारात्मक आउटपुट दें । आउटपुट को एक उचित तरीके से एक स्ट्रिंग या सूची के रूप में स्वरूपित किया जा सकता है।

उदाहरण: 

-1, -2, -3, -4, -6, -7, -8, -9, -12, -14, -16, -18, -21, -24, -28, -32, -36, -42, -48, -56, -63, -72, -84, -96, -112, -126, -144, -168, -224, -252, -288, -336, -504, -672, -1008, -2016, 1, 2, 3, 4, 6, 7, 8, 9, 12, 14, 16, 18, 21, 24, 28, 32, 36, 42, 48, 56, 63, 72, 84, 96, 112, 126, 144, 168, 224, 252, 288, 336, 504, 672, 1008, 2016

स्कोर = 74 - कार्यक्रम की लंबाई (छोटा कार्यक्रम बेहतर है)

6. गूढ़ार्थवाद

(नहीं, कि ।) हम पर PPCG हमारे जैसे गूढ़ सामान , और quines कि का एक अच्छा उदाहरण है।

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

स्कोर = कार्यक्रम की लंबाई (अब कार्यक्रम बेहतर है)

विशिष्ट नियम

  • आपके 6 चुनौतियों में से प्रत्येक में आपके कार्यक्रम को 74 बार कैप्सूल वर्णों का एक सबसेट होना चाहिए जो किसी भी तरह से आपको पसंद आया। यह एक खाली उपसमुच्चय या अनुचित उपसमुच्चय हो सकता है , इसलिए आपके प्रत्येक कार्यक्रम में 0 और उतने ही 74 वर्ण हो सकते हैं।
  • इनपुट / आउटपुट / कोड के अंत में एक एकल अनुगामी न्यूलाइन कहीं भी ठीक है क्योंकि कुछ भाषाओं को इसकी आवश्यकता होती है या इसे आसानी से टाला नहीं जा सकता है।
  • जब तक अन्यथा निर्दिष्ट नहीं किया जाता है, प्रत्येक चुनौती को हमारी चूक के अनुसार एक फ़ंक्शन या पूर्ण कार्यक्रम के रूप में पूरा किया जा सकता है ।
  • सभी चुनौतियों को एक ही भाषा में पूरा करना होगा।
  • पृथ्वी पर कहीं भी 2017 होने से पहले आपको एक भाषा (या किसी भाषा का संस्करण) का उपयोग करना चाहिए ।
  • किसी का भी जवाब देने के लिए स्वागत है, चाहे आपने समय कैप्सूल में एक चरित्र जोड़ा या नहीं।

अपनी चुनौतियों में 2016 के समय के कैप्सूल पात्रों का उपयोग करने के लिए स्वतंत्र महसूस करें।

string  code-challenge  number  restricted-source  quine 
— केल्विन के शौक
स्रोत
4
Yay: D एक चुनौती है जहाँ JavaScript संभावित रूप से उत्कृष्ट हो सकती है!
— डाउनगेट
1
कुछ समाधानों पर सहयोग करने के लिए चर्चा कक्ष ।
— user48538
6
निश्चित 6×74 or 444रूप से यह संभव नहीं है, क्योंकि इसका मतलब होगा कि खाली कार्यक्रम, जो किसी तरह अलग व्यवहार करते हैं। इसलिए, 442 वास्तविक न्यूनतम है, इसका मतलब है कि 3 इनपुट कार्यक्रमों में से दो में एक चार है
— विनाशकारी नींबू
7
मेरी भाषा जावा है। मैं डिफ़ॉल्ट रूप से हार गया: पी
— वीकर ई।
2
चलो फिर से ऐसा करते हैं!
— ev3commander

जवाबों:

37

ग्लाइफो , 74 + (74 - 36) = 112

1. भागो (74 बाइट्स)

!!#%QTQT@=A@$!!$)()*!&))+...1449:@HILOQZ\\^`````````eefmpx|||{~~~~~~y~|~ ~

2. IO (36 बाइट्स)

!!!#!$!$4419TAHT\ee\OQQQ))*+)..)|~~~

व्याख्या

ग्लिफ़ो इस चुनौती के लिए एक अच्छा विकल्प की तरह लग रहा था, क्योंकि यह वास्तविक पात्रों के उपयोग के बारे में परवाह नहीं करता है। इसके बजाय, यह चार वर्णों के समूहों को देखता है और उन चार वर्णों में पुनरावृत्ति के पैटर्न के आधार पर कमांड चुनता है। चूंकि समय कैप्सूल स्ट्रिंग के बीच बहुत सारे डुप्लिकेट हैं, इसलिए हम उन प्रोग्रामों में काफी लचीले हैं, जिन्हें हम लिख सकते हैं, सिवाय इसके कि हम 18 कमांड (जो कि ग्लिफ़ो में पूरी तरह से नहीं है) के कार्यक्रमों तक सीमित हैं। जबकि इसने मुझे पहली दो समस्याओं को आसानी से हल करने की अनुमति दी, मुझे संदेह है कि ग्लिफ़ो दूसरों को इतने कम वर्णों के साथ चला सकता है।

मैंने 2006-06-23 से प्राप्त जावा इंटरप्रेटर का उपयोग करके इनका परीक्षण किया है , जो कि वेकबैक मशीन पर है , जो कमांडों की थोड़ी अलग मैपिंग का उपयोग करता है:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

भागो कार्यक्रम के लिए अनुवाद:

1d-+[...]

जहां ...कुछ कबाड़ है जिसे मैंने अनुवाद करने के लिए परेशान नहीं किया है।

1      Push 1.
d      Duplicate.
-      Turn into -1.
+      Add. Gives 0.
[...]  Skip the rest because the top of the stack is zero.

आईओ कार्यक्रम के लिए अनुवाद:

id1-+o1+o

यहाँ है कि यह क्या करता है:

i   Read a character.
d   Duplicate.
1   Push 1.
-   Turn into -1.
+   Add to character, i.e. decrement it.
o   Output it.
1   Push another 1.
+   Add to character, i.e. increment it.
o   Output it.
— मार्टिन एंडर
स्रोत
24

CJam, 74 + (74 - 14) + (74 - 26) = 182 स्कोर

1. भागो (74 बाइट्स)

e# !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````efmpxy{||||~~~~~~~~~

e#आगे की टिप्पणियों के लिए चलती पूरी लाइन।

2. मैं / ओ (14 बाइट्स)

9`)ZH*+~):Q(Q)

डेनिस ने 8 बाइट्स बचाए।

स्पष्टीकरण:

9`                   Push "9".
  )                  Extract character '9'.
   ZH*               Push 3 * 17 = 51.
      +              Add to get character 'l'.
       ~             Eval as CJam code. Command l reads a line.
        )            Extract the only character from the input line
         :Q(         Assign to Q and decrement
            Q)       Push Q and increment

3. ब्रांचबिलिटी (26 बाइट्स)

4`)4Z|`I!`|~^~~T$AT$*%H(=+

स्पष्टीकरण:

4`)                            Push character '4'
   4Z|`                        Push 4 | 3 = 7, stringify
       I!`                     Push !18 = 0, stringify
          |~                   Setwise or and eval to get 70
            ^                  XOR to get 'r'
             ~                 Eval to read input
              ~                Eval the input as CJam code to turn
                               it into an integer
               T$              Duplicate it
                 A             Push 10
                  T$*          Duplicate that and multiply → 100
                     %         Mod the copy by 100
                      H(=      Compare to 17 - 1 = 16
                         +     Add the result (1 or 0) to the original

मैं बाद में दूसरों को देखूंगा। ( संपादित करें : मुझे संदेह है कि वे संभव हैं, बिना ब्लॉक या स्ट्रिंग शाब्दिक के ... शायद गणित एक?)

— लिन
स्रोत
# 2 के लिए, आप उपयोग कर सकते हैं 9`)ZH*+~):Q(Q)।
— डेनिस
11

जे, स्कोर 71 + (74 - 19) = 126

टास्क 1, लंबाई 71

AHILO=:( |T`T`Z`e`e`f`m`p`x`y|.~~%~@{|~^|Q@Q@Q+.*.449!~!~!~!!#$$&1\\~~)

यह एक क्रिया AHILOको अंदर से परिभाषित करता है । अप्रयुक्त:

)))

मुझे नहीं लगता कि इससे लंबा कोई रास्ता है।

टास्क 3, लंबाई 19

+($#~$~4)=1e4|&%:*~

इस कार्य को बिना किसी प्रतिबंध के करने का तरीका है +16=100|], जो इस प्रकार है:

        ]  Input
    100|   mod 100
 16=       equals 16? (Evaluates to 1 or 0)
+          Add to input.

हम +, =और कई प्रतियों या |हमारे निपटान में है, और यह चारों ओर पाने के लिए आसान है ], लेकिन संख्या अधिक समस्याग्रस्त हैं। यहाँ पहला भाग है जो इनपुट मोडुलो 100 की गणना करता है:

1e4|&%:*~
       *~  Input squared (multiplied with itself).
1e4        The number 10000.
   |       Perform modulo
    &      on
     %:    their square roots.

उसके बाद हमने ऐसा किया है, आइए 16 नंबर का उत्पादन करें। आसान तरीका है *~4(4 खुद के साथ गुणा), लेकिन हमने पहले से ही इसका उपयोग किया है *इसलिए यह निषिद्ध है। इसके बजाय, हम कुछ सरणी हेरफेर करेंगे।

($#~$~4)
    $~4   Reshape 4 to shape 4, resulting in the array 4 4 4 4.
  #~      Replicate wrt itself: replace each 4 by four 4s.
 $        Take length.

काम

2

यह सबसे निश्चित रूप से असंभव है। चरित्र मूल्यों में हेरफेर करने के एकमात्र तरीके हैं a.और u:, और हमारी न तो पहुंच है।

अब, यदि हम aइसके स्थान पर उपयोग कर सकते हैं , कहते हैं A, तो यह एक समाधान होगा:

Q{~(*^.4%9 1)+I.~&Q=:a.

इसे काम करने के लिए सबसे कठिन हिस्सा नंबर -1 का उत्पादन करना था।

Q{~(*^.4%9 1)+I.~&Q=:a.
                     a.  The array of all bytes.
                  Q=:    Bind it to Q
              I.~&       and find the input's index in it.
   (        )+           Add the following array:
    *                    Signum of
     ^.                  logarithm of
       4%                4 divided by
         9 1             the array 9 1.
                         This evaluates to -1 1.
Q{~                      Index back into Q.

4

(*.1:"|~@+.)

यह भूसी के आकार को उत्पन्न करता है, लेकिन मैं पात्रों को उत्पन्न करने का तरीका नहीं खोज सकता। अफसोस।

5

बेशक, यह जे में करने के लिए सबसे आसान काम लगता है। हालांकि, बिना i., यह काफी कठिन होगा।

6

यह संभव है कि नकली-आउट की तरह 449या बिना कुछ के बिना असंभव है, क्योंकि कैप्सूल स्ट्रिंग में स्ट्रिंग के उत्पादन के उद्धरण या कोई अन्य तरीका शामिल नहीं है।

— कॉनर ओ'ब्रायन
स्रोत
कार्य 2 के लिए, Q{~1+I.~&Q=:a.अगला वर्ण देता है: वर्णमाला a.को बांधें Q, इसमें इनपुट का इंडेक्स ढूंढें I., एक जोड़ें, और इंडेक्स को इसमें जोड़ें Q। कोशिश करो। केवल शेष समस्या का उत्पादन करना है -1...
— जर्गब
इसके अलावा, कार्य 3 स्ट्रिंग कार्यों के बिना किया जा सकता है +16=100&|:। आपको बस किसी तरह 16 और 100 का उत्पादन करने की आवश्यकता है।
— जर्गर्ब
@Zgarb (1) हाँ ... (2) ओह! यह अच्छा है! हम्म बहुत मुश्किल नहीं होना चाहिए
— कॉनर ओ'ब्रायन
हा, मुझे लगता है कि मुझे 3 मिला: +($@#~@$~4)=1e4|&%:*~यह बहुत कष्टप्रद था क्योंकि हमारे पास केवल एक (&=:+*और दो 4एस हैं।
— जर्गब
यहाँ आन्द के 2: Q{~(*^.4%9 1)+I.~&Q=:a.मुझे एहसास हुआ कि लघुगणक ^.0 और 1 के बीच कड़ाई से आदानों के लिए नकारात्मक संख्या देता है, और हमारे पास %अंशों का उत्पादन *करने के लिए और -1 और 1. के परिणाम लेने के लिए है
— ज़गारब
8

पॉवरशेल - कुल स्कोर: 74

1. रन - स्कोर: 74

#~= `TeQ.)`~H|$QL4yA)\*`!^O$1)!Z`!`~|\`&T@!x+e(f|Q`.|!4%.{~`:~~)m@~`@p~I9~

चूंकि यह PowerShell में बहुत मुश्किल है (इनपुट प्राप्त करने की हर संभव विधि दिए गए वर्णों के साथ असंभव है, जहां तक ​​मैं बता सकता हूं), मैंने कम से कम पहली चुनौती को यादृच्छिक बनाने का फैसला किया है, इसलिए हम सीधे उदाहरण की नकल नहीं कर रहे हैं पद से।

तो यहाँ एक यादृच्छिक चुनौती 1 उत्तर जनरेटर है (उन भाषाओं के लिए जहां #एक टिप्पणी है):

'#'+$(-join([char[]]' !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~'|Get-Random -Count 73))

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

— briantist
स्रोत
मुझे लगता है कि आप सही हैं। निकटतम हम प्राप्त कर सकते हैं $^जो "सत्र में पिछली पंक्ति का पहला टोकन" है, जो बेहद सीमित और मानक I / O नियमों के एक गंभीर झुकने की संभावना होगी।
— AdmBorkBork
@TimmyD हाँ, $^नए सत्र में वैसे भी रिक्त है।
— बेरिंटिस्ट
8

मेम , स्कोर ( 62 65 + 70) 135

1: भागो

मैंने सभी बैकटिक्स ( `) और गणितीय ऑपरेटरों को हटा दिया । उन्होंने संघर्ष किया क्योंकि प्रत्येक यूनियरी और बाइनरी ऑपरेटर को संतुष्ट करने के लिए पर्याप्त संख्या में नहीं थे। मैंने कुछ को छोड़ दिया, जिसके परिणामस्वरूप +3 बाइट्स हुए । परिणाम कार्यक्रम:

 !!!!!#$$%&())))...+1^4*49:=@@@AHILOQQQTTZ\\eefmpxy{||||~~~~~~~~~

मुझे नहीं पता कि यह क्यों और कैसे काम किया। कम से कम यह कोई C # रनटाइम अपवाद नहीं फेंकता है, और इसलिए क्रैश नहीं होता है।

6: काफी

आप जानते हैं, अगर उन 74 पात्रों में कहीं न कहीं एक -लोअरकेस qहोता, तो यह बहुत आसान होता। मुझे Iऑपरेटर के लिए खुशी है , कम से कम।

1/4I

यह कोड बिल्कुल स्पष्ट नहीं है। यहाँ एक स्पष्टीकरण है:

1    Set object to 1 (1)
/4   Divide by 4     (0.25)
I    Set object to a fraction string. (1/4)

फ़्रिक्शन स्ट्रिंग्स (जैसे 1/4) को I के साथ अंत में प्रदर्शित किया जाता है, ठीक उसी को इंगित करने के लिए। Iऑपरेटर आम तौर पर बेकार है, मैं इसे अन्य साधनों के लिए जोड़ा है, लेकिन हे, यह इस तरह काम करता है!

उपरोक्त कोड अमान्य है। मूर्ख मुझे यह नहीं दिखाई दिया कि 74 वर्णों में एक भी डिवीजन ऑपरेटर नहीं है, फॉरवर्डलैश ( /)। मैं हालांकि कुछ और के साथ आया:

True

स्पष्टीकरण:

T    Set object to "true" (bool value)
rue  None of these are valid tokens, so they don't get interpreted.

आउटपुट True(क्योंकि कैसे सी # Boolean.ToString()अपरकेस और लोअरकेस नहीं संभालता है )। यकीन नहीं होता कि यह एक उचित क्वीन है, इस बीच मैं अभी भी एक वैध, वास्तव में उचित और सहज ज्ञान युक्त के लिए अपना सिर फोड़ रहा हूं।

शायद I / O और गणित चुनौती को हल कर सकता है, लेकिन मैं विशिष्ट टोकन (अक्षर) को याद कर रहा हूं जो 74 वर्णों में शामिल नहीं हैं।

— devRicher
स्रोत
8

ब्रेनफक, 74 बाइट्स

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

मुझे बस करना था।

स्पष्टीकरण:

कोई भी चरित्र जो एक मान्य ब्रेनफक वर्ण नहीं है, उसे एक टिप्पणी के रूप में माना जाता है। एकमात्र कोड जो वास्तव में चलता है वह यह है:

.+..

यह कोई मुद्रण योग्य उत्पादन नहीं करता है, क्योंकि ASCII में न तो 0 और न ही मुद्रण योग्य वर्ण हैं। हालांकि, यह एक त्रुटि का कारण नहीं बनता है, इसलिए हम पहली चुनौती को सफलतापूर्वक पूरा करते हैं।

— जूलियन लचनीट
स्रोत
3
यह वास्तव में उत्पादन का उत्पादन करता है। यह उन पात्रों का निर्माण करता है। वे "प्रिंट करने योग्य" नहीं हो सकते हैं (पढ़ें: दृश्यमान), लेकिन फिर भी उन्हें फिर भी स्टडआउट भेजा जाता है।
— mbomb007
7

मैथमेटिका, 62 का स्कोर

मुझे आश्चर्य होगा कि अगर कोई भी गणितज्ञों में 2-6 कार्य कर सकता है। यहाँ सबसे अच्छा मैं चुनौती के साथ किया 1:

A:=1.`!#&@(4`+4.`*9.`^$$H~I~L~O~Q~Q~Q~T~T||Z||e@@efmpxy%)!!!!

Aएक स्थिर मूल्य के साथ एक बहुत बेवकूफ समारोह को परिभाषित करता है । 12 अप्रयुक्त वर्ण हैं:

)))\\`````{~
— ग्रेग मार्टिन
स्रोत
6

ऑक्टेव, स्कोर 74

1. भागो

x =@(AHILOQQQTTZeefmpy)+.1||!!!!!~~~~~~~~~4.^.4||9%#$$)))*@@\`````````{\&:

इनमें से 50 अक्षर समारोह का हिस्सा हैं, जबकि शेष 24 नहीं हैं।

यह क्या करता है:

x =@(AHILOQQQTTZeefmpy)एक फ़ंक्शन बनाता है xजो AHILOQQQTTZeefmpyइनपुट के रूप में एक चर ले सकता है ।

बाकी समझने के लिए:

a||bफ़ंक्शन all()को दोनों पर aऔर b। यदि उनमें से एक या दोनों सही हैं, तो ||ऑपरेटर सही लौटेगा।

!aऔर ~aयहाँ एक ही बात का मतलब है, वे दोनों हैं not(a)।

a.^b एक तत्व-वार शक्ति है (a(1)^b(1), a(2)^b(2) ...)

निरंतर स्पष्टीकरण

जैसे-जैसे मैं आगे बढ़ता हूँ, मैं प्रत्येक चरण को छोटा करूँगा:

4.^.4||9  % This is 4 raised to the power of .4||9
          % .4||9 is true, since both .4 and 9 are true
          % true is evaluated to 1 when used in an expression
...       % 4 raised to the power of 1 is simply 4.
4         % The above expression simplified

तथा:

!!!!!~~~~~~~~~4  % ! and ~ are the not() operator, so this is equivalent to:
not(not(not(not(not(not(not(not(not(not(not(not(not(not(4))))))))))))))

की सम संख्या है not, इसलिए यह समतुल्य है not(not(4))जो trueया है 1।

+.1||1      % This is equivalent to all(+.1) | all(1), which returns true

बाकी टिप्पणी की जाती है।

— स्टीवी ग्रिफिन
स्रोत
6

* * <> , कुल स्कोर = 74

1. भागो, स्कोर 74

f:4%*e+e14=p!Q H@~^)$.`~A|Q)~`\ZI~O.~@``#|9@)T\T`(!``|`~!y!`)Q~$x.|m~~&!L{

यहाँ यह कोशिश करो!

;चरित्र के बिना ऐसा करना बेहद कठिन था । मैंने वास्तव में सोचा था कि यह कुछ क्षणों के लिए असंभव होने जा रहा था, जब तक कि मैंने नहीं देखा %, मैंने मूल रूप से हार मान ली थी।

यह भी एक मान्य> <> कार्यक्रम है।

समझाया (अप्रासंगिक भागों छोड़ा गया)

f:4%*e+e14=p!Q 

f:               copy 15
  4%             pop 15, push 15%4 (3)
    *            pop 15 and 3, push 15*3 (45)
     e+          pop 45, push 45+14 (59, ascii ";")
       e         push 14
        14=      push 0
           p     replace coord (14, 0) with ";"
            !Q   skip Q (this is just filler)
              ;  end execution

चुनौतियों का सामना करना पड़ा

मैं अन्य चुनौतियों की कोशिश कर सकता हूं ... वे बेहद कठिन होंगे और इसमें अजीब तरीकों से नियमों को शामिल करना शामिल हो सकता है, लेकिन |दर्पणों और !ट्रम्पोलिंस का उदार उपयोग कम से कम एक और चुनौती को संभव बनाना चाहिए।

ये चुनौतियां विशेष रूप से कठिन हैं क्योंकि हमें *> <> ( oऔर n), या यहां तक ​​कि फ़ंक्शन कॉल ( C), फ़ंक्शन रिटर्न ( R), या प्रोग्राम टर्मिनेटर ( ;) के साथ किसी भी आउटपुट की अनुमति नहीं है । यद्यपि हम iइनपुट के लिए भी गायब हैं, फिर भी हम स्टैक पर इनपुट रख सकते हैं जो एक प्लस है। एक और प्लस यह है कि हमें एक एकल pनिर्देश मिलता है , जो हमें कोडबॉक्स में एक निर्देश को बदलने की अनुमति देता है। यह कई बार उपयोग करने में सक्षम हो सकता है (अभी तक एक व्यावहारिक तरीका नहीं खोजा गया है), जो अन्य कार्यक्रमों को अधिक संभव बनाने के लिए शुरू होगा (जैसा कि हम दो या अधिक निर्देश उत्पन्न करने में सक्षम होंगे)।

— redstarcoder
स्रोत
5

हास्केल, स्कोर 63

1. भागो:

(!!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~)fmpxyAHILOQQQTTZ e=14`e`49

उपयोग नहीं किए गए हैं )))```````{। हास्केल में टिप्पणियाँ --या हैं {- ... -}, इसलिए कोई आसान ऑल-कमेंट संस्करण नहीं है।

यह कोड एक infix ऑपरेटर को परिभाषित करता है !!!!!#$$%&*+...:@@@\^||||~~~~~~~~~जो दो तर्क देता है:

  1. fmpxyAHILOQQQTTZ जिसे अनदेखा किया जाता है और इसलिए वह एक मनमाना प्रकार हो सकता है
  2. e, जो दो नंबर लेने वाला फ़ंक्शन होना चाहिए

फ़ंक्शन में शरीर eको 14 और 49 में लागू किया जाता है, `-इनफिक्स संकेतन का उपयोग करते हुए।

उपयोग उदाहरण:

Prelude> () !!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~ (*)
686

ऑपरेटर के लिए लागू किया जाता है (), खाली ट्यूपल, और (*), गुणा ऑपरेटर, इसलिए 14*49 = 686गणना की जाती है।

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

अन्य चुनौतियां

मुझे संदेह है कि अन्य चुनौतियों में से कोई भी संभव है, सबसे विशेष रूप से संभव चर नामों की कमी के कारण जो दो बार दिखाई दे सकते हैं, जो कि केवल e(या ऐसा कुछ eQT) है, क्योंकि चर नाम किसी बड़े अक्षर से शुरू नहीं हो सकते हैं। बेशक, केवल एक होने से =भी मदद नहीं मिलती है।

— Laikoni
स्रोत
5

अजगर, अभी के लिए 131 (2 चुनौतियों को पूरा)

1. भागो, 74

# `````````!!!)!)!)*$AOeIefLmpxQ|Q|y|Q|~~~~~~~~~()${+%&\=@@@^\:.1.4.49TTZH

यह प्रोग्राम कोई इनपुट नहीं लेता है और कोई आउटपुट नहीं बनाता है।

यह प्रोग्राम उपयोग करता है $$, जो मनमाने ढंग से कोड निष्पादन की अनुमति देता है, और इसलिए ऑनलाइन प्रतिबंधित है, इसलिए यह कार्यक्रम ऑनलाइन ऑफ़लाइन चलता है। यहां इसका संकलन आउटपुट है, ताकि आप देख सकें कि वास्तव में क्या चलता है:

while True:
 try:
  (repr(repr(repr(repr(repr(repr(repr(repr(repr(Pnot(Pnot(Pnot()))))))))))))
  imp_print(Pnot())
  imp_print(Pnot())
  imp_print(times(AOeIefLmpxQ|Q|y|Q|~~~~~~~~~(),uniquify(plus(mod(("=" and lookup(lookup(lookup(Ppow(":",.1),.4),.49),T)),T),Z))))
  imp_print(H)
 except Exception:
  break

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

पहला कदम #सभी त्रुटियों को खाने के लिए उपयोग करना है। इसके बाद, हमें उन त्रुटियों के कारण और , जिनसे प्रत्येक का अपना विवरण है ~, से बचने की आवश्यकता है । यह उन्हें अंदर डालने से प्राप्त होता है , जो उन्हें आउटपुट संकलन के अंदर एम्बेड करता है, और इस तरह उन्हें पायथन के संकलन नियमों के अधीन करता है, न कि पायथ के। अंत में, उपयोगकर्ता इनपुट लेने से बचने के लिए, विभिन्न आर्क 0 टोकन (वैरिएबल्स और समान) को अंत में रखा जाता है, और एस को ब्लॉक के अंदर ले जाया जाता है।IL$$Q$$

2. आई.ओ.

यह अविश्वसनीय रूप से मुश्किल होगा, अगर यह भी संभव है। Pyth फ़ंक्शंस में से कोई भी ऐसा नहीं है जो मनमाने तरीके से तार या वर्ण बनाता है .f, सिवाय मौजूद हैं , और जो कि मनमाने ढंग से वर्ण बनाने का एक बहुत ही खराब काम करता है।

3. शाखायिकी: 74 - 17 = 57

|&x%Q*TTye|LZ9Q+1

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

एक समान पायथ कार्यक्रम होगा:

?n%Q100 16Q+1

यह कोड इनपुट मॉड 100 लेता है, इसकी तुलना 16 से करता है, और फिर इनपुट और इनपुट प्लस वन के बीच चयन करने के लिए एक टर्नरी का उपयोग करता है। चरित्र प्रतिबंधों के कारण, मैंने कुछ प्रतिस्थापन किए:

  • इसके बजाय ?, टर्नरी, मैंने उपयोग किया |&, orफिर and, जिसमें समान कार्यक्षमता है, सिवाय इसके कि यदि इनपुट शून्य है तो यह टूट जाता है, लेकिन जब से हम सकारात्मक पूर्णांक इनपुट की गारंटी देते हैं, यह ठीक है। (यह बिना किसी अतिरिक्त वर्ण के तय किया जा सकता था, लेकिन यह इस तरह सरल है।)

  • दो नंबरों की तुलना करने के बजाय, मैं उनका XOR साथ लेता हूं x, जो कि शून्य है और केवल अगर वे समान हैं, तो वे वांछित हैं।

  • 100सीधे लिखने के बजाय , मैं इसके साथ उत्पन्न करता हूं *TT, क्योंकि Tइसे आरंभीकृत किया गया है 10।

  • 16सीधे लिखने के बजाय , मैं इसे उत्पन्न करता हूं ye|LZ9। |LZआवश्यक रूप से रेंज फ़ंक्शन के रूप में कार्य करता है, इसलिए |LZ9देता है [0, 1, 2, 3, 4, 5, 6, 7, 8]। eएक सूची का अंतिम तत्व लेता है 8। yइसे दोगुना, 16वांछित के रूप में दे रही है । एक अतिरिक्त +या एक अतिरिक्त के साथ *मैं एक चरित्र को बचा सकता था, लेकिन वे दोनों कहीं और उपयोगी हैं।

और भी आने को है!

— isaacg
स्रोत
3

रूबी - स्कोर: 74

1. भागो

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

चुनौती से पकड़ा गया।

— dkudriavtsev
स्रोत
1
पायथन के लिए समान
— डैनियल
3

जावास्क्रिप्ट (ईएस 6), स्कोर = 74

1. भागो, 74 बाइट्स

Z=` !!!!!#$$%())))...1449:@@@\AHILOQQQTT^\`eefmpxy{||||~~~~~~~~~`*``+``&``

6. गूढ़ार्थवाद (अमान्य)

रिकॉर्ड के लिए, मेरा सुझाव दिया गया था:

1.4e+49

जो अमान्य है, जैसा कि नीचे टिप्पणी में चर्चा की गई है।

— Arnauld
स्रोत
वह क्वीन मान्य है।
— wizzwizz4
3
क्वीन मान्य नहीं है। प्रासंगिक नियम चुनौती में जुड़े हुए हैं। विशेष रूप से, किसी भी क्वीन जो कि एकल शाब्दिक पर आधारित है, स्रोत के एक अलग भाग में स्रोत के भाग को एनकोड करने में विफल रहता है । cc @ wizzwizz4
— मार्टिन
@MartinEnder मेरे ब्राउज़र में, वह प्रोग्राम अपने सोर्स कोड को शाब्दिक रूप से आउटपुट करता है। यह एक ऐसा कथन है जो स्वयं का मूल्यांकन करता है। मुझे यकीन नहीं है कि आप क्या कह रहे हैं; स्रोत का कोई अलग हिस्सा नहीं है ।
— wizzwizz4
1
@ wizzwizz4 इस समुदाय के पास "प्रोग्राम प्रिंट करने के लिए अपने स्वयं के स्रोत" की तुलना में क्वीन के लिए अधिक आवश्यकताएं हैं, क्योंकि यह विभिन्न प्रकार के धोखाधड़ी समाधानों की अनुमति देता है जो कि क्वीन की भावना में नहीं हैं। लिंक देखें।
— मार्टिन एंडर
1
@ wizzwizz4 ने शीर्ष वोट किए गए उत्तर से कहा, "कार्यक्रम के एक हिस्से की पहचान करना संभव है जो कार्यक्रम के एक अलग हिस्से को एन्कोड करता है। (" अलग-अलग "का अर्थ है कि दो हिस्से अलग-अलग स्थिति में दिखाई देते हैं।)" गोल्फ के लिए आप एक क्वीन हैं। बहुत अच्छे के लिए, चुनौती (और जुड़ा हुआ जवाब) लिंक किए गए मेटा पोस्ट की तुलना में कई साल पुरानी है।
— मार्टिन एंडर
3

रेटिना, स्कोर 74

1. भागो, स्कोर 74

)))` !!!!!#$$%&()*.+..1449:=@@@AHILOQQQTTZ\\^````````eefmpxy{||||~~~~~~~~~

मैं regex में उन्हें संतुलित करने के लिए कॉन्फ़िगर करने के लिए अतिरिक्त parens ले जाया गया। मैं `उन लोगों के बाद भी सही चला गया , और बदल +.गया .+।

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

दूसरों की संभावना असंभव है, क्योंकि कोई नई बात नहीं है। -लिप्यंतरण के लिए या dअंक वर्ण वर्ग के लिए भी कोई नहीं है ।

— mbomb007
स्रोत
3

पिप, स्कोर 74 + (74 - 19) = 129

इतने सारे backticks nary के साथ एक उद्धरण देखा जा सकता है, सिंगल या डबल!

टास्क 1, स्कोर 74

`` `\``!!!!!`#$$%&())))*+...1449:=@@@ILOQQQTTZ\^efmpx{|||~~~~~~~~~`|`yeAH`

मूल रूप से बैकटिक्स में केवल पैटर्न (रेगेक्स) शाब्दिक श्रृंखला, जिनमें से अंतिम मुद्रित है। चूँकि वहाँ एक अजीब संख्या है, इसलिए हमें उनमें से एक को पीछे हटाना है ( `\``)। इसे ऑनलाइन आज़माएं , -wध्वज के साथ यह साबित करने के लिए जोड़ा गया है कि कोई चेतावनी उत्पन्न नहीं होती है।

टास्क 3, स्कोर 55 (लंबाई 19)

e+!!e%(1.#x.!9)=4*4

पांचवीं कमांड लाइन तर्क - बल्कि एक अजीब इनपुट विधि का उपयोग करना - यह संभव है। इसे ऑनलाइन आज़माएं!

                     e is 5th cmdline arg; x is empty string
       1.#x.!9       Concatenate 1, 0 (length of x), and 0 (not 9)
    e%(       )      e mod 100...
               =4*4  ... equals 16?
  !!                 Logically negate twice
e+                   Add to e (+1 if number mod 100 is 16, +0 otherwise)
                     Expression is autoprinted

अन्य कार्य

कार्य 2 के लिए इनपुट प्राप्त करना संभव है, उसी विधि द्वारा कार्य 3 से ऊपर। मुसीबत ASCII कोड और एक चरित्र में वापस परिवर्तित हो रही है। पूर्व के साथ किया जा सकता है A, लेकिन बाद की आवश्यकता होती है C, या संभवतः PAचर में अनुक्रमित होती है । कोड का निर्माण और मूल्यांकन बिना नहीं किया जा सकता है V। मुझे नहीं लगता कि कार्य संभव है।

टास्क 4 एक प्रतिबंधित चरित्र सेट के बिना भी चुनौतीपूर्ण है। एक अनुमान के अनुसार, इसके लिए सूचियों की आवश्यकता होगी (बिना []सीमांकक RL(पुनरावर्तक सूची का उपयोग किए बिना ) और केवल एक ही मौका AL(उपयोग सूची) - संभावना नहीं है) या संभवत: CG(समन्वय ग्रिड) या MC(मानचित्र कोर्डर्स) के साथ दोनों को अस्वीकृत कर दिया गया ।

टास्क 5 संभावना के किनारे पर है। लूप मुश्किल होगा, चूंकि Fया Mएपी संभव नहीं हैं, और श्रेणियों का निर्माण नहीं किया जा सकता है ,। Tबीमार के साथ कुछ करना पड़ सकता है । वृद्धि x:x+1विभिन्न प्रकार की हो सकती है (जाहिर है x, हालांकि इसके अलावा एक चर के साथ )। डिवीजिबिलिटी चेक का उपयोग कर सकते हैं %। फिर भी, मुझे नहीं लगता कि पर्याप्त वर्ण हैं - विशेष रूप से दोहराए गए अक्षर - सब कुछ करने के लिए जो होना चाहिए।

टास्क 6 पूरी तरह से असंभव दिखता है। सभी ज्ञात पिप quines "उनमें है। वे (रिप्ले R), RP(repr), या V(eval) का भी उपयोग करते हैं , जिनमें से कोई भी उपलब्ध नहीं है।

— DLosc
स्रोत
2

दरअसल, स्कोर (74 + 0 + 0 + 0 + 0 + 0 ) = 74

हां, कैप्सूल स्ट्रिंग रन के लिए वास्तव में उसी तरह काम करेगा, जैसा कि वास्तव में किसी भी त्रुटि को खारिज करता है और हर त्रुटि एनओपी बन जाती है।

H@~*^)$.~+1A|Q)p~\Z!IQ~e:O.~@#|9@)Tf\eT`=(!|~!y!) Q~$x.4|m4~~&!L{%( इसे ऑनलाइन आज़माएं! )

यह चीजों की गड़बड़ी का उत्पादन करेगा, हालांकि (लेकिन एक बार इसका स्रोत भी: 3)।

मैं हालांकि अन्य चुनौतियों पर काम करूंगा।

— user48538
स्रोत
1
यदि आप कुछ ऑप्स को नोप्सेस में बना सकते हैं, तो क्वीन प्रोग्राम (उम्मीद है) काफी सरल होगा।
— wizzwizz4
1
क्वीन प्रोग्राम सरल नहीं है। आप बिल्कुल भी उपयोग नहीं कर सकते Q(क्योंकि यह क्विनिंग बिलिन है), और कोई दोहरे उद्धरण नहीं हैं, इसलिए आप कोई भी स्ट्रिंग प्रारूपण नहीं कर सकते। मैंने इस कल पर थोड़ी देर के लिए काम किया, और मुझे पूरा यकीन है कि अन्य कार्यक्रम केवल 74 वर्णों के साथ संभव नहीं हैं।
— मेघ
और इटैलिक एफ नहीं लगता ... :(
— user48538
2

05AB1E - कुल स्कोर: 74

1. भागो, 74 बाइट्स

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

सब कुछ है कि एक त्रुटि का कारण बनता है 05AB1E द्वारा छोड़ दिया जाता है। कोड की यह पूरी लाइन एक एनओपी है।

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

— अदनान
स्रोत
2

(दुर्व्यवहार) PHP, 74 + 74 = 148

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

PHP दुभाषिया केवल स्रोत कोड को डंप करता है जब तक कि यह नहीं पाता है <?क्योंकि हमारे पास <उन वर्णों के हर क्रम में कमी है एक चल रहा है। मुझे लगता है कि यह बिलियन क्वीन कमांड का उपयोग करने से भी बदतर नहीं है: पी

— क्रिस्टोफ
स्रोत
9
यह quines के लिए हमारे विनिर्देशों को पूरा नहीं करता है, यहां देखें । यह खुद को एनकोड नहीं करता है (यानी यह वास्तव में खुद को प्रिंट नहीं करता है, यह सिर्फ संकलक के कारण
— आउटपुट
@ आमतौर पर दुभाषिया हर चार का इलाज output this charतब तक करता है जब तक कि वह मिलता नहीं है <। मैं यह नहीं कह रहा हूं कि यह पेलोड-सक्षम है या sth मैं सिर्फ इतना कह रहा हूं कि एक चर कह रही भाषा के लिए कोई अंतर नहीं है output the source। यदि यह किसी भी भाषा की तुलना में भाग 1 के लिए मान्य उत्तर नहीं है जो त्रुटि के बिना किसी भी इनपुट को स्वीकार करता है, तो मान्य उत्तर भी नहीं है। मुझे नहीं लगता कि यह यहाँ के अधिकांश उत्तरों की तुलना में अधिक अपमानजनक है।
— क्रिस्टोफ़
4
@ क्रिस्टोफ यह भाग एक के लिए वैध है, लेकिन यह चुनौती से जुड़े नियमों से मान्य नहीं है। यह समुदाय एक क्वीन को वैध मानता है यदि आप उस स्रोत के एक भाग की पहचान कर सकते हैं जो कोड के एक अलग भाग को एन्कोड करता है । आपके कार्यक्रम में, हर चरित्र केवल खुद को एनकोड करता है।
— मार्टिन एंडर
@ मर्टिनएंडर: #! / बिन / बिल्ली को पहले एक क्वीन माना जाता था।
— जोशुआ
@ जोशुआ वास्तव में, लेकिन इन दिनों यह नहीं है और न ही बिल्ली को एक प्रोग्रामिंग भाषा माना जाता है।
— मार्टिन एंडर
2

गणितज्ञ, स्कोर ६ score

`A: = .1% *। 44y # +। 9 ^` H @ `$ I @` L @ (`$ O ~` Q ~ `Q ~` Q ~ `T ~ T ~ Z ~ e ~ e | च | मीटर | पी | x) !!!!! और \

ट्रेलिंग न्यूलाइन को नोटिस करें। मुझे विश्वास नहीं है कि गणित के साथ अन्य चुनौतियों में से किसी को भी प्राप्त किया जा सकता है।

— LegionMammal978
स्रोत
2

भूलभुलैया, स्कोर 74

AH)
IL)
OQ:
`=!)~`{+4.@ !!!$$%&(*..149@@TTZ\\^```eefmpxy||||~~~~~~~~
`Q#
`Q)
``!

मुझे पूरा यकीन है कि इन पात्रों में से कोई भी वर्गीकरण एक वैध भूलभुलैया कार्यक्रम का निर्माण करता है, लेकिन इसे कम से कम थोड़ा और अधिक रोचक बनाने के लिए, यह 2016अंक अंकों को प्रिंट करता है । (संक्षेप में: 2स्टैक पर 2 पुश करें , पॉप / प्रिंट एक, दूसरे को ऑक्स स्टैक पर ले जाएं, प्रिंट 0, 1स्टैक पर 2 पुश करें , पॉप / प्रिंट 1, वेतन वृद्धि, बिटवाइज़ नॉट, नेगेट (अंतिम) 1एक है 3इस बिंदु पर), राशि के साथ 2aux ढेर से, 5 * 10 + 4 = 54, ascii मूल्य के रूप में प्रिंट, समाप्त)

@कार्यक्रम को समाप्त करने के रूप में लंबी लाइन के अधिकांश को केवल अनदेखा किया जाता है ।

2, 3, और 4 की चुनौतियां असंभव हैं क्योंकि दोनों में से कोई भी भूलभुलैया के इनपुट कमांड उपलब्ध नहीं हैं ( ,या ?), और मैं 5 या 6 के लिए कुछ भी नहीं आया था।

— SnoringFrog
स्रोत
2

स्माइलबासिक, 48 अंक

चुनौती 1:

@LOQQQTTZ A$=H$+@efmy+@9414*!exp(!!.||!!.#||I%):

स्पष्टीकरण:

@LOQQTTZ 'label
A$= 'set value of A$ (string)
H$ 'string
+@efmy 'adds label, interpreted as string literal
+@9414 'adds label, interpreted as string literal
*!exp( 'multiplies by logical not e^x (= 0)
!!. 'not not 0.0 (= 0)
||!!.# 'or not not 0.0 converted to a float (= 0)
||I% 'or I% (integer variable)
: 'equivalent to a line break, does nothing here

अन्य:

कोई इनपुट / आउटपुट कमांड उपलब्ध नहीं हैं, इसलिए बाकी संभव नहीं हैं।

फिर भी, टिप्पणियों का उपयोग किए बिना एक वास्तविक भाषा के लिए बुरा नहीं है।

— 12Me21
स्रोत
+1 वास्तव में सुंदर। मैं सोच रहा था कि मैं इनमें से कोई कैसे करूंगा और कभी नहीं मिल सकता। यह भी क्या करता है?
— घोंघा_ २४'१
1

MATL , कुल स्कोर 74

1. भागो, स्कोर 74

`4.e4 1.$!!!!!T+Zyf9.)AH^ILx@Q@Q@Qm||||~~~~~~~~~:=Tp*O%#$&()))\\````````e{

%वास्तविक कोड तक सब कुछ है। %एक टिप्पणी प्रतीक है, इसलिए इसके दाईं ओर के पात्रों को अनदेखा किया जाता है।

कार्यक्रम 1त्रुटियों के बिना आउटपुट ।

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

— लुइस मेंडो
स्रोत
1

मार, स्कोर 74

1: भागो। हम सभी 74 चला सकते हैं

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

6: गूढ़तावाद:

खाली कार्यक्रम बैश में एक क्वीन है।

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

— यहोशू
स्रोत
नियम नोट: यदि कोई व्यक्ति चुनौती देता है कि खाली एक वैध quine नहीं है और जीतता है, तो मेरे पास अभी भी विजेता प्रविष्टि (w / o किसी भी quine) है। अगर दूसरी तरफ मैं इसे जगह नहीं देता और कोई और करता है और वे चुनौती जीतते हैं जो उन्होंने मुझे हराया। तो वहीं रहता है।
— जोशुआ
1

पर्ल 6 , कुल स्कोर 74

1. भागो, स्कोर 74

my @TOTAL=$!||(e*4...9^e)Z+1~4||!!Q`{fp)))\#\&`~Q!```HI````!~Q:x~~~$~@~@~%

कोई टिप्पणी नहीं।
( #सब कुछ टिप्पणी करने के लिए बस सामने वाले को डालने से भी काम चल जाता है, लेकिन यह अधिक मजेदार है।)

काम

यह पर्ल 6 भाषा का सबसेट है जो केवल अनुमत वर्णों का उपयोग करता है:

लगातार: ई

नाम टाइप करें: IO

कार्य: ऍक्स्प

तरीके:
    टाइप I पर: .e .f .x .x
    (... शायद अधिक है।)

संचालक: | infix: | उपसर्ग:
    ----------- + ----------------------- + ---------
    संख्यात्मक: | + * + ^ + | + और% | + + ^
    स्ट्रिंग: | ~ x ~ ^ ~ | ~ और | ~
    बूलियन: | || ~~ | !
    जंक्शन: | | & ^ |  
    misc: | =: = Z .. ... |  

वाक्य - विन्यास:
    नंबर शाब्दिक: 1 4 9
    स्ट्रिंग शाब्दिक: क्यू `` क्यू! ! आदि।
    शेल कमांड: क्यू: x` `क्यू: एक्स! ! आदि।
    जो भी तारा: *
    चर: my \ $ @ &
    समूहीकरण: ()
    टिप्पणियाँ: # # `()
    अनस्पेस: \ _

2-6 चुनौतियों को रोकने वाली तात्कालिक बाधा यह है कि I / O करने का कोई तरीका प्रतीत नहीं होता है:

  • यदि हम मानते हैं कि कोई फ़ाइल है f, तो हम Q`f`.IO.eयह जांचने के लिए उपयोग कर सकते हैं कि यह मौजूद है या Q`f`.IO.xयह जांचने योग्य है कि क्या यह निष्पादन योग्य है। लेकिन हम इसे पढ़ नहीं सकते हैं या इससे नहीं लिख सकते हैं।

  • हम Q:x` `एक शेल कमांड चलाने के लिए उपयोग कर सकते हैं (यह मानते हुए कि हम एक के लिए वर्ण पाते हैं)। लेकिन हम किसी भी चीज़ में हस्तक्षेप नहीं कर सकते हैं, इसलिए यह केवल पढ़ने के लिए अच्छा होगा, न कि लेखन के लिए।

  • चूंकि कोई समापन ब्रेस नहीं है, हम एक ब्लॉक लैम्ब्डा (जैसे {1 + $_}) नहीं बना सकते हैं जो स्वचालित रूप से अपने अंतिम विवरण का मूल्य लौटाता है।

  • हम एक अभिव्यक्ति लैम्ब्डा (जैसे ) बनाने के लिए तारांकन का उपयोग कर सकते हैं 1+*, लेकिन फिर हम केवल एक तर्क ले सकते हैं, इस तर्क को केवल एक बार देखें, और सिंटैक्स / ऑपरेटरों में और भी अधिक सीमित हैं जिनका हम उपयोग कर सकते हैं।

— SMLS
स्रोत
अच्छी तरह से किया, वास्तव में! :)
— दादा
0

लुआ, स्कोर 31

1. भागो (74 में से 31 अंक)

AHILOQQQTTZeefmpxy=1.%4+(4.*9.)
— Scribblemacher
स्रोत
3
आप अंतरिक्ष से चूक गए। variable =stuffअब 1 बाइट है।
— devRicher
0

/// , स्कोर: 146

1. भागो, स्कोर: 74

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

6. क्विन, स्कोर: 72

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ^`````````eefmpxy{||||~~~~~~~~~

हाँ, जब कोड में कोई भी आगे या पीछे स्लैश नहीं होते हैं, तो यह केवल प्रिंट करता है।

— कॉमरेड स्पार्कलपनी
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.