क्विन बाइनरी में ही आउटपुट करता है


10

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

नियम

  • स्रोत कम से कम 1 बाइट लंबा होना चाहिए।

  • आपके प्रोग्राम को इनपुट नहीं लेना चाहिए (या अप्रयुक्त, खाली इनपुट) होना चाहिए ।

  • आउटपुट किसी भी दृढ़ प्रारूप में हो सकता है।

  • वैकल्पिक अनुगामी न्यूलाइन की अनुमति है।

  • ध्यान दें कि एक बाइट 8 बिट्स है, और बाइनरी यूटीएफ -8 प्रतिनिधित्व की लंबाई आवश्यक रूप से 8 की एक बहु है।

  • यह इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

  • मानक खामियों को मना किया जाता है।

उदाहरण

मान लीजिए कि आपका स्रोत कोड है Aä$$€h, इसका संबंधित UTF-8 बाइनरी प्रतिनिधित्व है 010000011100001110100100001001000010010011100010100000101010110001101000

अगर मैं रन Aä$$€hकरता हूं तो आउटपुट होना चाहिए 010000011100001110100100001001000010010011100010100000101010110001101000

A      --> 01000001
ä      --> 1100001110100100
$      --> 00100100
$      --> 00100100
€      --> 111000101000001010101100
h      --> 01101000
Aä$$€h --> 010000011100001110100100001001000010010011100010100000101010110001101000

स्ट्रिंग बाइनरी UTF-8 कन्वर्टर्स के लिए


1
"बाइनरी" से, क्या आपका मतलब है बाइनरी मानों का एक स्ट्रिंग प्रतिनिधित्व, यानी एक स्ट्रिंग जिसमें केवल 1 और 0 का समावेश है?

1
@mdahmoune अब यह पहले से बहुत बेहतर है। सवाल यह है कि UTF-8 के रूप में कुछ का प्रतिनिधित्व कैसे करें। ध्यान दें कि यूनिकोड प्रतिनिधित्व मुख्य रूप से एक चरित्र के लुक पर आधारित है (केवल कभी-कभी अर्थ अर्थ पर)। क्या होगा यदि कोई नियत यूनिकोड ग्लिफ स्रोत कोड में एक चरित्र की तरह नहीं दिखता है? यूनिकोड में कई लुक-अलाइक (होमोग्लाइफ्स) भी हैं। कैसे तय करता है कि किसको इस्तेमाल करना है? Eg Dyalog APL के पास AND फ़ंक्शन है जो कि 01011110या 0010011100100010UTF-8 में एन्कोड किया जा सकता है (वे बहुत ही समान दिखते हैं: ^बनाम )
Adám

1
बेहतर उदाहरण: 01111100और 0010001100100010सांकेतिक शब्दों में बदलना |और
19

4
@ मुझे लगता है कि यह किसी भी द्विआधारी अनुक्रम का उत्पादन करने के लिए उचित होगा जो एक प्रतीक से मेल खाती है जो किसी भाषा के एक निश्चित कार्यान्वयन में संकलित / चलेगा।
20

1
मशीन कोड के बारे में कैसे? (कमोडोर C64 मशीन कोड खुद को "स्रोत" मानते हुए 28 बाइट्स लेता है)
मार्टिन रोसेनौ

जवाबों:


7

V , 28 (या 16?) लैटिन 1 बाइट्स (35 UTF-8 बाइट्स)

ñéÑ~"qpx!!xxd -b
ÎdW54|D
Íßó

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

हेक्सडंप (लैटिन में 1):

00000000: f1e9 d17e 2271 7078 2121 7878 6420 2d62  ...~"qpx!!xxd -b
00000010: 0ace 6457 3534 7c44 0acd dff3            ..dW54|D....

आउटपुट (UTF-8 में समान कोड का बाइनरी प्रतिनिधित्व, लैटिन 1 नहीं):

110000111011000111000011101010011100001110010001011111100010001001110001011100000111100000100001001000010111100001111000011001000010000000101101011000100000110111000011100011100110010001010111001101010011010001111100010001000000110111000011100011011100001110011111110000111011001100001010

स्पष्टीकरण:

ñéÑ~"qpx            " Standard quine. Anything after this doesn't affect the
                    " program's 'quine-ness' unless it modifies text in the buffer
        !!xxd -b    " Run xxd in binary mode on the text
Î                   " On every line...
 dW                 "   delete a WORD
   54|              "   Go to the 54'th character on this line
      D             "   And delete everything after the cursor
Í                   " Remove on every line...
  ó                 "   Any whitespace
 ß                  "   Including newlines

या ...

वी , 16 बाइट्स

ñéÑ~"qpx!!xxd -b

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

आउटपुट:

00000000: 11000011 10110001 11000011 10101001 11000011 10010001  ......
00000006: 01111110 00100010 01110001 01110000 01111000 00100001  ~"qpx!
0000000c: 00100001 01111000 01111000 01100100 00100000 00101101  !xxd -
00000012: 01100010 00001010                                      b.

ओपी ने कहा:

आउटपुट किसी भी सुविधाजनक प्रारूप में हो सकता है।

यह वी: पी के लिए बहुत अधिक सुविधाजनक प्रारूप में आउटपुट करता है (लेकिन मुझे यकीन नहीं है कि अगर यह नियम खींच रहा है)



4

05AB1E , 105 बाइट्स

0"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J

05AB1E में कोई UTF-8 रूपांतरण बिल्डिंग्स नहीं हैं, इसलिए मुझे मैन्युअल रूप से सब कुछ करना होगा

इसे ऑनलाइन आज़माएं या सत्यापित करें कि यह एक क्वीन है

स्पष्टीकरण:

:

लिए सबसे छोटी यह एक है: 0"D34çý"D34çý( 14 बाइट्स ) @OliverNi द्वारा प्रदान की गई । मेरा जवाब में जोड़कर कि Quine का एक संशोधित संस्करण का उपयोग करता है ...यहां: 0"D34çý..."D34çý...। इस क्वीन का संक्षिप्त विवरण:

0               # Push a 0 to the stack (can be any digit)
 "D34çý"        # Push the string "D34çý" to the stack
        D       # Duplicate this string
         34ç    # Push 34 converted to an ASCII character to the stack: '"'
            ý   # Join everything on the stack (the 0 and both strings) by '"'
                # (output the result implicitly)

चुनौती हिस्सा:

अब कोड के चुनौती वाले हिस्से के लिए। जैसा कि मैंने शीर्ष पर उल्लेख किया है, 05AB1E में कोई UTF-8 रूपांतरण बिल्डिंग्स नहीं है, इसलिए मुझे इन चीजों को मैन्युअल रूप से करना होगा। मैंने इस स्रोत का उपयोग कैसे करें के संदर्भ के रूप में किया है: यूनिकोड कोडपॉइंट्स को मैन्युअल रूप से यूटीएफ -8 और यूटीएफ -16 में परिवर्तित करना । यहाँ यूटीएफ -8 में यूनिकोड वर्णों के रूपांतरण के बारे में संक्षिप्त सारांश दिया गया है:

  1. यूनिकोड वर्णों को उनके यूनिकोड मानों में बदलें (अर्थात "dЖ丽"बन जाता है [100,1046,20029])
  2. इन यूनिकोड मानों को बाइनरी में परिवर्तित करें (अर्थात [100,1046,20029]बन जाता है ["1100100","10000010110","100111000111101"])
  3. निम्न में से किस श्रेणी में वर्ण देखें:
    1. 0x00000000 - 0x0000007F (0-127): 0xxxxxxx
    2. 0x00000080 - 0x000007FF (128-2047): 110xxxxx 10xxxxxx
    3. 0x00000800 - 0x0000FFFF (2,048-65,535): 1110xxxx 10xxxxxx 10xxxxxx
    4. 0x00010000 - 0x001FFFFF (65536-2097151): 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

5 या 6 बाइट्स के लिए रेंज भी हैं, लेकिन चलो उन्हें अभी के लिए छोड़ दें।

चरित्र dपहली श्रेणी में होगा, इसलिए UTF-8 में 1 बाइट; चरित्र Жदूसरी श्रेणी में है, इसलिए UTF-8 में 2 बाइट्स; और चरित्र तीसरी श्रेणी में है, इसलिए UTF-8 में 3 बाइट्स हैं।

इसके xपीछे के पैटर्न में इन पात्रों के बाइनरी के साथ भरा हुआ है, दाएं से बाएं। तो पैटर्न के साथ d( 1100100) 0xxxxxxxबन जाता है 01100100; Ж( 10000010110) पैटर्न के साथ 110xxxxx 10xxxxxxहो जाता है 11010000 10010110; और ( 100111000111101) पैटर्न के साथ 1110xxxx 10xxxxxx 10xxxxxxहो जाता है 1110x100 10111000 10111101, जिसके बाद शेष xबदल दिए जाते हैं 0: 11100100 10111000 10111101

तो, वह तरीका जो मैंने अपने कोड में भी इस्तेमाल किया है। वास्तविक सीमाओं की जांच करने के बजाय, मैं सिर्फ बाइनरी की लंबाई को देखता हूं और इसकी तुलना xपैटर्न में इसकी मात्रा से करता हूं , क्योंकि यह कुछ बाइट्स को बचाता है।

Ç               # Convert each character in the string to its unicode value
 b              # Convert each value to binary
  ε             # Map over these binary strings:
   Dg           #  Duplicate the string, and get its length
     Xó•       #  Push compressed integer 8657
         18в    #  Converted to Base-18 as list: [1,8,12,17]
            @   #  Check for each if the length is >= to this value
                #  (1 if truthy; 0 if falsey)
   ƶ            #  Multiply each by their 1-based index
    à           #  Pop and get its maximum
     ©          #  Store it in the register (without popping)
   i            #  If it is exactly 1 (first range):
    7j          #   Add leading spaces to the binary to make it of length 7
      0ì        #   And prepend a "0"
   ë            #  Else (any of the other ranges):
    R           #   Reverse the binary
     6ô         #   Split it into parts of size 6
       Rí       #   Reverse it (and each individual part) back
    ć           #   Pop, and push the remainder and the head separated to the stack
     7®-        #   Calculate 7 minus the value from the register
        j       #   Add leading spaces to the head binary to make it of that length
         š      #   Add it at the start of the remainder-list again
    Tì          #   Prepend "10" before each part
      J         #   Join the list together
    1®<×        #   Repeat "1" the value from the register - 1 amount of times
        ì       #   Prepend that at the front
  ]             # Close both the if-else statement and map
   ð0:          # Replace all spaces with "0"
      J         # And join all modified binary strings together
                # (which is output implicitly - with trailing newline)

मेरा 05AB1E उत्तर देखें (वर्गों को बड़े पूर्णांकों को कैसे संपीड़ित करें ? और पूर्णांक सूचियों को कैसे संपीड़ित करें? ) यह समझने के लिए कि क्यों •Xó•18вहै [1,8,12,17]


3

जावास्क्रिप्ट (Node.js) , 60 बाइट्स

-15 बाइट @Neil और @ शैगी से

f=_=>[...Buffer(`f=`+f)].map(x=>x.toString(2).padStart(8,0))

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


padStart(8,0)2 बाइट्स बचाता है।
नील

युक्ति आउटपुट को किसी भी सुविधाजनक प्रारूप में रखने की अनुमति देती है ताकि आप बिट्स के एक सरणी को आउटपुट करने mapके joinलिए औसत और रख सकते हैं
झबरा

बाइट्स की एक सरणी के रूप में उत्पादन के साथ 60 बाइट्स
झबरा

धन्यवाद @ नील और @ शगुन !!
लुइस फेलिप डी जीसस मुनोज




2

जावा 10, 339 308 265 227 225 186 184 बाइट्स

v->{var s="v->{var s=%c%s%1$c;return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);}";return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);}

-8 बाइट्स धन्यवाद @NahuelFouilleul को हटाने के लिए अनावश्यक &255(और मेरे ध्यान में लाने के लिए एक अतिरिक्त -35 कि मेरा चुनौती चुनौती का पूरा कार्यक्रम चश्मा रद्द कर दिया गया था और अब एक समारोह की अनुमति दी गई है)
-41 बाइट्स @ OlivierGrégoire के लिए धन्यवाद ।

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

स्पष्टीकरण:

:

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

चुनौती हिस्सा:

v->{                         //  Method with empty unused parameter and String return-type
  var s="...";               //   Unformatted source code String
  return 0+                  //   Return, with a leading "0":
   new java.math.BigInteger( //    A BigInteger of:
     s.format(s,34,s)        //     The actual source code String
      .getBytes())           //     Converted to a list of bytes (UTF-8 by default)
   .toString(2);}            //    And convert this BigInteger to a binary-String      


@NahuelFouilleul मूल प्रश्न में कहा गया है, " आपको एक पूर्ण कार्यक्रम बनाना चाहिए। " और " आपके आउटपुट को STDOUT में प्रिंट करना होगा। ", इसलिए वर्बोज़ बॉर्डर-प्लेट कोड मेरे पास एक लैम्बडा फ़ंक्शन के बजाय एक स्ट्रिंग है। &255हालांकि हम किसी भी गैर- ASCII वर्ण का उपयोग नहीं करते हैं, लेकिन जरूरत के बारे में अच्छी बात है , धन्यवाद!
केविन क्रूज़सेन

ठीक है, मैं अभी तक बहुत उपयोगी नहीं हूं, लेकिन जावास्क्रिप्ट जैसी अन्य भाषाओं में एक स्ट्रिंग लौटाने वाला लैम्ब्डा दिया जाता है, मुझे यह भी समझ में नहीं आता कि जावा में हम लैम्ब्डा का उपयोग करते समय प्रकार और अंतिम अर्धविराम की गणना क्यों नहीं करते हैं? नियम खोजें?
नहुएल फौलीउल

1
खैर, यही वह जगह है जहाँ मैं हार गया हूँ। हालाँकि मैंने कोशिश की और यहाँ 184 बाइट्स के लिए एक नया उम्मीदवार है । मुझे बताइए कि क्या मैं कहीं गलत हूं?)
ओलिवियर ग्रेजायर

1
@ OlivierGrégoire आह, अच्छा दृष्टिकोण! पूरी तरह BigIntegerसे बाइनरी-स्ट्रिंग्स में कनवर्ट करने के लिए बहुत कम होने के बारे में भूल गया । और बदलकर 2 अधिक बाइट्स return'0'+करने के लिए return 0+। हम्म, क्यों है कि 0आवश्यक btw अग्रणी ? यह मुझे भ्रमित करता है कि सभी आंतरिक बाइनरी-स्ट्रिंग्स में यह अग्रणी है 0, लेकिन बहुत पहले एक का उपयोग करते समय नहीं BigInteger.toString(2)..
केविन क्रूज़सेन

2

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

_="print''.join(bin(256|ord(i))[3:]for i in'_=%r;exec _'%_)";exec _

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

इस उत्तर का एक संशोधन

-1 बाइट्स में 'के बाद' को हटाकर (धन्यवाद @mdahmoune)


-1 बाइट: यू के बाद स्पेस गिरा सकता हैin
mdahmoune

आपने अपना TIO लिंक अपडेट नहीं किया है। इसके अलावा, मैंने '%08b'%ord(i)इसके बजाय करने की कोशिश की bin(256|ord(i))[3:], लेकिन यह किसी कारण से काम नहीं किया
जो किंग

2

आर , 138 114 बाइट्स

x=function(){rev(rawToBits(rev(charToRaw(sprintf("x=%s;x()",gsub("\\s","",paste(deparse(x),collapse="")))))))};x()

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

कार्यों के उनके चरित्र प्रतिनिधित्व को निरूपित करने की आर की क्षमता का उपयोग करता है। revरों क्योंकि जरूरत है rawToBitsकहते हैं कम से कम महत्वपूर्ण बिट पहले। as.integerजरूरत है क्योंकि अन्यथा बिट्स को एक अग्रणी शून्य के साथ प्रदर्शित किया जाता है।

एक बार संपादित होने के बाद मुझे महसूस हुआ कि किसी भी सुविधाजनक आउटपुट की अनुमति है। मूल बाइट काउंट पर भी एक-एक करके आउट हुआ।


1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 221 बाइट्स

var s="var s={0}{1}{0};Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));

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

ध्वज के साथ C # (विजुअल C # इंटरएक्टिव कंपाइलर)/u:System.String , 193 बाइट्स

var s="var s={0}{1}{0};Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));

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


1

बैश + जीएनयू उपकरण, 48 बाइट्स

trap -- 'trap|xxd -b|cut -b9-64|tr -dc 01' EXIT

TIO


धन्यवाद, वास्तव में अद्यतन यह सबसे छोटी भिन्नता है अन्यथा इसे ट्रैप आउटपुट से हटा दिया जाना चाहिए
नाहुएल फौइउल
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.