आउटपुट द सोर्स, वन बिट एट ए टाइम

Question

एक गैर-रिक्त प्रोग्राम या फ़ंक्शन लिखें, जिसे आउटपुट को एकल मान, 1 या 0 कहा जाता है, और जब कई बार कॉल किया जाता है, तो आउटपुट नंबर आपके प्रोग्राम के स्रोत कोड के बाइनरी प्रतिनिधित्व का उत्पादन करते हैं (उसी कोड पृष्ठ में जहां से आपका कोड संकलित किया जाता है। / व्याख्या)।

उदाहरण के लिए, यदि आपका स्रोत कोड abc(ASCII में) था, तो आउटपुट होगा:

1st call:  0           // ASCII letter 'a'
2nd call:  1
3rd call:  1
4th call:  0
5th call:  0
6th call:  0
7th call:  0
8th call:  1

9th call:  0           // ASCII letter 'b'
10th call: 1
11th call: 1
12th call: 0
13th call: 0
14th call: 0
15th call: 1
16th call: 0

17th call: 0           // ASCII letter 'c'
18th call: 1
19th call: 1
20th call: 0
21st call: 0
22nd call: 0
23rd call: 1
24th call: 1

After the 24th call, the behaviour is undefined.

स्रोत के द्विआधारी प्रतिनिधित्व में कम से कम एक 0 बिट और एक 1 बिट होना चाहिए।

1 और 0 के बजाय, आप किसी भी दो अलग, सुसंगत मूल्यों (जैसे कि trueऔर false) को आउटपुट कर सकते हैं ।

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

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है।

Answer 1

फंकी , 47 41 37 बाइट्स

एक बिट का प्रतिनिधित्व करने वाली संख्या लौटाता है।

f=_=>1&("%b"%("f="+f)[i//8])>>7-i++%8

यह क्वीन प्रारूप का उपयोग करता है f=_=>"f="+f। यह चरित्र को takesi / 8 the की स्थिति में ले जाता है, फिर, वर्तमान वर्ण के ascii मान को n >> 7-i%8कहां ले जाता है, इसकी मात्रा को लेकर थोड़ा सा हो जाता है n।

यह एक पुनरावृत्त फ़ंक्शन है जो iप्रत्येक कॉल के साथ वृद्धि करता है , एक बार स्रोत कोड से बाहर हो जाने पर, यह कोड को nहमेशा के लिए लिख देगा ।

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

Comments

क्या यह जावास्क्रिप्ट के साथ एक बहुभुज है?

— स्टेन स्ट्रोम

Answer 2

बैश , 105 बाइट्स

trap -- 'trap|xxd -b -c1|cut -d\  -f2|tr -d \\n|cut -c`x=\`cat f||echo 1\`;echo $((x+1))>f;echo $x`' EXIT

नोट : सुनिश्चित करें कि आपके पास fउस निर्देशिका में एक महत्वपूर्ण फ़ाइल नहीं है जिसे आप इसका परीक्षण कर रहे हैं।

---

यदि आप इसका परीक्षण करना चाहते हैं, तो आप निम्नलिखित कमांड का उपयोग कर सकते हैं:

for i in $(seq 848); do bash path/to/script.sh 2> /dev/null; done | tr -d \\n

जो एक ही आउटपुट देना चाहिए xxd -c1 -b path/to/script.sh|cut -d\ -f2|tr -d \\n।

व्याख्या

यह trapचाल का उपयोग कर रहा है - कार्रवाई के trapअंदर कॉलिंग trapबस उस रेखा को प्रिंट करता है। इसके बाद उस आउटपुट को पाइप किया जाता है xxdजो इसे बाइनरी में कनवर्ट xxd -bpकरता है (दुर्भाग्य से काम नहीं करता है - इस प्रकार cut& के साथ वर्कअराउंड tr):

xxd -c1 -b $0|cut -d\  -f2|tr -d \\n

इससे हम केवल एक बिट (कहते हैं N) में रुचि रखते हैं जिसे हम चुन सकते हैं cut -cN।

यह जानने के लिए कि Nहम क्या उपयोग कर रहे हैं (याद रखें कि वह भाग जिसे प्रत्येक कॉल के बाद बढ़ाना होगा), बस xफ़ाइल की सामग्री पर सेट करने का प्रयास करें fऔर यदि यह मौजूद नहीं है तो इसे 1 पर सेट करें:

x=`cat f||echo 1`

अंतिम कार्य करने के लिए, फ़ाइल को अद्यतन करना है f- x+1इसे लिखना :

echo $((x+1))>f

Answer 3

टीआई-बेसिक (TI-83 श्रृंखला), 592 357 309 बाइट्स

"123456789ABCDEF02A3132333435363738394142434445463004AA003FB958833404593FB9588338045A3F3230363FDA582B383F303FCE5A405A6B3232333F5A70BB0FAA002BBB0CAA002B5A2B313FB932BA32F01058713459713511BB0FAA002BBB0CAA002B597031377132722B31→Str1
iPart(X/4→Y
iPart(X/8→Z
206
IS>(X,8
0
If Z and Z<223
Z+inString(Str1,sub(Str1,Z,1
iPart(2fPart(2^(X-4Y-5)inString(Str1,sub(Str1,Y+17-2Ans,1

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

तुलना और / या ऐतिहासिक अभिरुचि के लिए: TI-Basic में लिखा गया पहला उद्धरण ।

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

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

हम मान रहे हैं कि कार्यक्रम एक कैलकुलेटर पर शुरू होता है, जिसकी मेमोरी को अभी-अभी क्लियर किया गया Xहै 0। हर बार कार्यक्रम के माध्यम से, हम वेतन वृद्धि करते हैं X।

आमतौर पर, हम केवल उस आधे-बाइट का पता लगाते हैं जिसे हम थोड़ा बाहर निकालने की कोशिश कर रहे हैं, इसे पढ़ते हैं Str1, हेक्साडेसिमल से बाइनरी में परिवर्तित करते हैं, और इसे प्रिंट करते हैं। हम स्रोत कोड है कि भंडारण की ओर से कर रहे हैं Str1(जो कार्यक्रम की कुल लंबाई का दो तिहाई है), तो हम स्ट्रिंग के इसी हिस्से के लिए पहला कदम भंडारण 31, 32, और इतने पर।

Answer 4

जावा 8, 249 241 237 234 148 बाइट्स

int i;v->{String s="int i;v->{String s=%c%s%1$c;return s.format(s,34,s).charAt(-i/8)>>(--i&7)&1;}";return s.format(s,34,s).charAt(-i/8)>>(--i&7)&1;}

अग्रिम में लंबे स्पष्टीकरण के लिए क्षमा करें। :)

• व्हिपिंग 89 बाइट्स ने @Nevay को धन्यवाद दिया ।

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

स्पष्टीकरण:

int i;                     // Index-integer on class-level
v->{                       // Method with empty unused parameter and integer return-type
  String s="int i;v->{String s=%c%s%1$c;return s.format(s,34,s).charAt(-i/8)>>(--i&7)&1;}";
                           //  String containing the unformatted source code
  return s.format(s,34,s)  //    Quine to get the source code,
      .charAt(-i/8)        //     and get the character at index `-i/8`
     >>                    //    And bitwise right-shift it with:
       (--i&7)             //     `i-1` bitwise-AND 7
                           //     by first decreasing `i` by 1 with `--i`
      &1;                  //   Then bitwise-AND everything above with 1
}                          // End of method

अतिरिक्त स्पष्टीकरण:

क्वीन -पार्ट :

• String s इसमें बिना स्रोत वाला कोड होता है
• %s इस स्ट्रिंग को अपने साथ रखने के लिए उपयोग किया जाता है s.format(...)
• %c, %1$cऔर 34डबल-कोट्स को फॉर्मेट करने के लिए उपयोग किया जाता है ( ")
• s.format(s,34,s) यह सब एक साथ रखता है

इसे अपने स्वयं के स्रोत कोड वाले क्विन आउटपुट को सत्यापित करने के लिए हटाए गए / संशोधित किए गए कुछ हिस्सों के साथ यहाँ आज़माएँ।

बाइनरी -पार्ट:

• -i/8स्वचालित रूप से पूर्णांक विभाजन पर छोटा हो जाएगा, इसलिए जब i-7 से 0 होता है, तो यह बन जाएगा 0; अगर i-15 से -8 है, तो यह बन जाएगा 1; आदि।
• तो s.charAt(-i/8)स्रोत-कोड के वर्तमान चरित्र को एक दूसरे के बाद आठ बार लेता है। इसे संशोधित संस्करण के साथ यहाँ आज़माएँ।
• --i&7हो जाएगा 7,6,5,4,3,2,1,0,7,6,5,4,3,2,1,0,..., जहां पहला 7है जब i=0(जो -1पहली वजह से बन जाता है --i, और घटता रहेगा)।
• s.charAt(-i/8)>>(--i&7)पात्रों के आधार पर दृश्यों का उत्पादन करेगा। कुछ उदाहरण ( 'A'65) 'E'(69) हैं:
  • ए 0,1,2,3,4,8,16,32,65,0,1,2,4,8,16,32,65,...:;
  • बी 0,1,2,4,8,16,33,66,0,1,2,4,8,16,33,66,...:;
  • सी 0,1,2,4,8,16,33,67,0,1,2,4,8,16,33,67,...:;
  • डी 0,1,2,4,8,17,34,68,0,1,2,4,8,17,34,68,...:;
  • ई 0,1,2,4,8,17,34,69,0,1,2,4,8,17,34,69,...:;
  • आदि।
• ...&1फिर एक आउटपुट 0अगर यह सम संख्या है, और 1अगर यह एक विषम संख्या है, जिसमें आउटपुट ऊपर दृश्यों सही परिणाम के साथ संयोजन में।

---

पुराने 233 बाइट्स उत्तर:

int i;v->{String s="int i;v->{String s=%c%s%1$c;return Long.toString((s.format(s,34,s).charAt(i/8)&255)+256,2).substring(1).charAt(i++%%8);}";return Long.toString((s.format(s,34,s).charAt(i/8)&255)+256,2).substring(1).charAt(i++%8);}

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

स्पष्टीकरण:

int i;                           // Index-integer on class-level
v->{                             // Method with empty unused parameter and char return-type
  String s="int i;v->{String s=%c%s%1$c;return Long.toString((s.format(s,34,s).charAt(i/8)&255)+256,2).substring(1).charAt(i++%%8);}";
                                 //  String containing the unformatted source code
  return Long.toString(
          (s.format(s,32,s)      //  Quine-formatting
          .charAt(i/8)           //  Take the current character
           &255)+256,2).substring(1)
                                 //  Convert it to an 8-bit binary-String 
         .charAt(i++%8);         //  And return the bit at index `i` modulo-8
                                 //  and increase index `i` by 1 afterwards with `i++`
}                                // End of method

अतिरिक्त स्पष्टीकरण:

क्वीन -पार्ट :

इसके अलावा के रूप में एक ही स्पष्टीकरण:

• %%मॉडुलो-साइन ( %) का बचा हुआ रूप है

इसे अपने स्वयं के स्रोत कोड वाले क्विन आउटपुट को सत्यापित करने के लिए हटाए गए / संशोधित किए गए कुछ हिस्सों के साथ यहाँ आज़माएँ।

बाइनरी -पार्ट:

• i/8स्वचालित रूप से पूर्णांक विभाजन पर छोटा हो जाएगा, इसलिए जब i4-7 है, तो यह बन जाएगा 0; अगर i8-15 है, तो यह बन जाएगा 1; आदि।
• तो s.charAt(i/8)स्रोत-कोड के वर्तमान चरित्र को एक दूसरे के बाद आठ बार लेता है। इसे संशोधित संस्करण के साथ यहाँ आज़माएँ।
• 255है 0xFFया11111111 (एक अहस्ताक्षरित बाइट के लिए अधिकतम मूल्य)
• 256है 0x100या100000000 ।
• &एक पूर्णांक के लिए ASCII-चरित्र upcasts। उस बिंदु पर, यह ( 0और से ) के बीच कहीं भी है ।2550000000011111111
• Long.toString(...,2) इसे 9-बिट बाइनरी स्ट्रिंग प्रतिनिधित्व में कनवर्ट करता है
• +256और .substring(1)यह सुनिश्चित करेगा कि अग्रणी शून्य हैं, और 9-बिट को 8-बिट में बदल देगा।

संपूर्ण बाइट्स को सत्यापित करने के लिए हटाए गए / संशोधित किए गए कुछ हिस्सों के साथ यहां पर प्रयास करें।

Comments

149 बाइट्स:int i;v->{String s="int i;v->{String s=%c%s%1$c;return 1&s.format(s,34,s).charAt(-i/8)>>(--i&7);}";return 1&s.format(s,34,s).charAt(-i/8)>>(--i&7);}

— नेवे

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

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

Answer 5

जावास्क्रिप्ट ईएस 6, 73 58 52 बाइट्स

o=_=>`o=${o}`.charCodeAt((o.n=1+o.n|0)/8)>>(7-o.n%8)&1

व्याख्या

कोड का टूटना:

• o=_=>: एक फ़ंक्शन को परिभाषित करें।
• `o=${o}`: एक तार का निर्माण; oको स्ट्रिंग में परिवर्तित किया जाता है, जो इस मामले में फ़ंक्शन का स्रोत कोड है।
• .charCodeAt(: अपने ASCII वर्ण कोड के रूप में स्ट्रिंग में एक चरित्र प्राप्त करें।
• (o.n=1+o.n|0)/8: एक चरित्र का चयन करें। यह वह जगह भी है जहां काउंटर बढ़ा हुआ है।
• )>>(7-o.n%8): परिणामी वर्ण कोड को स्थानांतरित करें ताकि वांछित बिट सही स्थिति में हो।
• &1: अन्य सभी बिट्स को 0 पर सेट करें।

Comments

आप इसे एक मेमने के साथ छोटा कर सकते हैं o=_=>(o+'').charCodeAt(('n'in top?++n:n=0)/8|0)>>(7-n%8)&1

— अताको

यह एक फ़ंक्शन को परिभाषित करने के रूप में गिना जाता है।

— अताको

कोशिश करेंo=_=>('o='+o).charCodeAt(('n'in top?++n:n=0)/8|0)>>(7-n%8)&1

— अताको

इसके बजाय 'n'in top?++n:n=0आप उपयोग कर सकते हैं ++n||(n=0)या ++n?n:n=0या n=++n||0या n=1+n||0जो सभी का उपयोग का falsiness NaNकि incrementing द्वारा निर्मित हैundefined

— Bergi

o=_=>('o='+o).charCodeAt((o.n=1+o.n|0)/8)>>(~o.n&7)&1

— tsh

Answer 6

क्यू / केडीबी + , ४५ बाइट्स

समाधान:

a:-1;f:{((,/)0b vs'4h$"a:-1;f:",($).z.s)a+:1}

उदाहरण:

q)f[] / call function f with no parameters
0b   
q)f[]
1b   
q)f[]
1b   
q)f[]
0b   
q)f[]
0b   
q)f[]
0b   
q)f[]
0b   
q)f[]
1b   
q)f[]  
q)"c"$0b sv 01100001b / join back to a byte and cast to a character
"a"

स्पष्टीकरण:

मुझे लगता है कि मैं संक्षिप्त समझ गया।

पहले aमूल्य के साथ एक वैश्विक चर सेटअप -1। फ़ंक्शन फ़ंक्शन fके स्ट्रिंग प्रतिनिधित्व के बाइनरी प्रतिनिधित्व का निर्माण करता है (सब कुछ सहित {}) a:-1;f:कबाड़ के साथ पहले से तैयार है , और इस बाइनरी सूची में अनुक्रमणिका (जो प्रत्येक कॉल बढ़ जाती है) पर अनुक्रमित होती है।

a:-1;f:{(raze 0b vs'4h$"a:-1;f:",string .z.s)a+:1} / ungolfed solution
a:-1;                                              / stick -1 in variable a
     f:{                                         } / define function f
                                             a+:1  / increment a by 1 (:: is required as a is a global variable), indexes into the left
        (                                   )      / do all this together
                                 string .z.s       / z.s is the function, string converts it to a string
                       "a:-1;f:",                  / prepend "a:-1;f:" to the start
                    4h$                            / cast to bytes
              0b vs'                               / convert each byte to binary
         raze                                      / flatten binary into long list

Answer 7

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

lambda s='lambda s=%r,i=[]:i.append(1)or"{:08b}".format(ord((s%%s)[~-len(i)/8]))[~-len(i)%%8]',i=[]:i.append(1)or"{:08b}".format(ord((s%s)[~-len(i)/8]))[~-len(i)%8]

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

व्याख्या

चलो एक मानक पायथन 2 क्वीन के साथ शुरू करते हैं।

s = '...'; print s % s

ठीक है, ठीक है, यह इसे इस तरह से आउटपुट करता है। हमें बाइनरी की आवश्यकता है!

s = '...'; print "\n".join("\n".join("{:08b}".format(ord(i))) for i in s % s)

ठीक है, कि बस सब कुछ बाइनरी में कनवर्ट करता है। लेकिन शीर्षक "एक समय में एक बिट" कहता है। हमें कई रन बनाने के लिए कुछ करने की जरूरत है। मुझे पता है, चलो इसे एक समारोह बनाते हैं!

lambda s = '...': "\n".join("\n".join("{:08b}".format(ord(i))) for i in s % s)

रुको, यह मदद नहीं करता है ... हम्म, हम आउटपुट होने के लिए आवश्यक बिट के सूचकांक का ट्रैक कैसे रख सकते हैं? ऊह, ऊह, चलो ट्रैक रखने के लिए एक पूर्णांक है।

lambda s = '...', i = 0: "{:08b}".format(ord((s % s)[i / 8]))[i % 8]

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

... खैर, काफी नहीं। अजगर करता सूचियों की अनुमति देने के रूप में डिफ़ॉल्ट तर्क संशोधित करने की। (और यह पायथन प्रोग्रामर्स को हर समय काटता है।) इसकी लंबाई का उपयोग करें!

lambda s = '...', i = []: "{:08b}".format(ord((s % s)[len(i) / 8]))[len(i) % 8]

हालांकि यह अभी भी ट्रैकर को संशोधित नहीं करता है ... हम इसकी लंबाई बढ़ाने के लिए इसे कुछ जोड़ सकते हैं ... लेकिन कैसे? आह, ठीक है, हमें मिल गया है list.append। lst.append(1)के बराबर है lst += [1]। महान!

lambda s = '...', i = []: i.append(1) and "{:08b}".format(ord((s % s)[len(i) / 8]))[len(i) % 8]

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

lambda s = '...', i = []: i.append(1) and "{:08b}".format(ord((s % s)[(len(i) - 1) / 8]))[(len(i) - 1) % 8]

वहाँ यह है, दोस्तों! यह गोल्फ और तुम मेरे समाधान मिल गया है!

Answer 8

पर्ल 5 , 59 बाइट्स

sub{$_=q{unpack(B.++$-,"sub{\$_=q{$_};eval}")=~/.$/g};eval}

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