19

यह चुनौती आपके टर्मिनल, विंडो, कैनवास या स्क्रीन को शून्य से 10 समावेशी तक आउटपुट देने की है। प्रत्येक आउटपुट किए गए नंबर को 4-बिट वाइड नॉबल के रूप में दिखाया जाना चाहिए, इसलिए शून्य को 0000और इतने पर दिखाना होगा ।

आप स्पेस, कॉमा या कैरिज रिटर्न के साथ आउटपुट किए गए प्रत्येक नंबर को अलग कर सकते हैं। सबसे छोटा समाधान जीतता है लेकिन संख्याएँ आपको किसी भी क्रम में प्रदर्शित की जा सकती हैं जब तक कि आपके अनुक्रम में कोई दोहराई जाने वाली संख्या नहीं हैं।

निम्न-स्तरीय द्विआधारी भाषाओं में प्रविष्टियाँ अल्पविराम या श्वेत अंतरिक्ष विभाजकों के बारे में चिंता करने की आवश्यकता नहीं है यदि यह अल्पविराम या श्वेत स्थानों के साथ उत्पादन करना संभव नहीं है (अर्थात, मानक उत्पादन केवल बाइनरी तक सीमित है, या आपका समाधान एक प्रारंभिक कंप्यूटर किट के लिए है जैसे कि KIM-1 जिसमें एक सीमित डिजिटल डिस्प्ले है)।

code-golf kolmogorov-complexity binary

— शॉन बीबर
स्रोत

हां, रिक्त स्थान, अल्पविराम, एक अल्पविराम और फिर एक स्थान या आपकी चुनी हुई भाषा में "\ r \ n" समकक्ष।

— शॉन बेयबर्स

ऐसा नहीं है कि 4 व्यक्तिगत शून्य अंकों और 4-बिट वाइड बाइनरी नंबर की तरह दिखता है।

— शॉन बीबर्स

ऐसा नहीं है कि मैं वास्तव में इस तरह के उत्तर को लिखने के लिए निश्चित हूं, लेकिन 11 आवश्यक लोगों के अतिरिक्त कुछ अतिरिक्त निबल्स का उत्पादन करना ठीक होगा?

— अरनौलद

2

वे निबल्स हैं, निबल्स नहीं।

— 0WJYxW9FMN

कमोडोर 64 प्रोग्रामर के संदर्भ गाइड के अनुसार नहीं

— शॉन बीबर्स

2

स्माइलबासिक, 26 बाइट्स

FOR I=0TO&HA?BIN$(I,4)NEXT

— 12Me21
स्रोत

15

MATL , 6 बाइट्स

0:10YB

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

व्याख्या

0:10    % Create the array [0...10]
YB      % Convert this array to a binary string where each number is 
        % placed on a new row
        % Implicitly display the result

— Suever
स्रोत

15

05AB1E , 9 8 बाइट्स

T         # push 10
 4ã       # cartesian product repeat with 4
   R      # reverse list
    T>£   # take the first 11 elements of the list
      »   # join by newline and display

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

— Emigna
स्रोत

10

प्रतीक्षा करें ... किसी संख्या के अंकों का कार्टेशियन उत्पाद ? बस इतना ही ...

— ETHproductions

13

जावास्क्रिप्ट, 46 बाइट्स

for(i=15;i++<26;)alert(i.toString(2).slice(1))

जब आप केवल प्रत्येक संख्या में 16 जोड़ सकते हैं और पहले बाइनरी अंक को काट सकते हैं तो पैडिंग फ़ंक्शन का उपयोग क्यों करें?

— ETHproductions
स्रोत

9

जाप , 7 बाइट्स

GôA,_¤Å

और यहाँ मैं सोच रहा था कि जाप हर दूसरी गोल्फिंग भाषा की तुलना में लंबा था।

इसे ऑनलाइन टेस्ट करें!

व्याख्या

GôA,_¤Å  // Implicit: A = 10, G = 16
GôA      // Create the inclusive range [G...G+A].
    _    // Map each item Z to Z
     ¤   //   .toString(2)
      Å  //   .slice(1).
         // Implicit: output result of last expression

आम तौर पर जाप में कॉमा को हटाया जा सकता है, लेकिन यह एक बग के कारण है: _सामान्य रूप से इसका मतलब है function(Z){Z, लेकिन किसी कारण से संकलक का A_मतलब है function(A,Z){Z।

— ETHproductions
स्रोत

अच्छा है। मैं अटक गयाAô_¤

— ओलिवर

8

बाश + GNU बर्तन, 26

4 बाइट्स @ डेनिस की बदौलत बच गए

seq -w 0 1010|sed /[2-9]/d

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

— डिजिटल आघात
स्रोत

1

seq -w 0 1010कार्य करना चाहिए।

— डेनिस

@ डेनिस धन्यवाद - मुझे पहले -wविकल्प का उपयोग करना याद नहीं है seq।

— डिजिटल ट्रॉमा

7

बैश + यूनिक्स उपयोगिताओं, 29 26 बाइट्स

dc -e2o8927II^*8/p|fold -4

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

यह @ DigitalTrauma / @ डेनिस के समाधान के समान लंबाई है, लेकिन पूरी तरह से अलग विधि का उपयोग करता है।

आउटपुट है:

(किसी भी आदेश की अनुमति है)

शुद्ध बैश , 34 बाइट्स

echo 0{0,1}{0,1}{0,1} 10{00,01,10}

शुद्ध बैश संस्करण को ऑनलाइन आज़माएं!

आउटपुट है:

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

— मिशेल स्पेक्टर
स्रोत

7

जे, 6 बाइट्स

#:i.11

इसे 6 बाइट्स तक काटने के लिए मीलों धन्यवाद!

— ब्लाकों
स्रोत

#:i.11बस के रूप में अच्छी तरह से काम करना चाहिए

— मील

मुझे यकीन नहीं है कि यह अब तक की गई टिप्पणी के उत्तर के अनुसार वैध है ।

— आदम

@ Adám मैं इसे नहीं देख सकता। क्या आप बता सकते हैं कि यह क्यों नहीं है?

— ब्लॉक

क्योंकि यह एक × 4 बुलियन सरणी उत्पन्न करता है, जो बीच-बीच में रिक्त स्थान के साथ अंकों के रूप में प्रिंट करता है। लेकिन टिप्पणी से लगता है कि बाइनरी संख्या के अंदर रिक्त स्थान की अनुमति नहीं है।

— आदम

6

जेली , 7 बाइट्स

2Bṗ4ṫ6Y

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

(5 बाइट्स यदि नायबल्स की अनुगामी रेखाओं की अनुमति है, 2Bṗ4Y)

कैसे?

अवरोही क्रम में प्रिंट।

2Bṗ4ṫ6Y - Main link, no arguments
2B      - 2 converted to binary -> [1,0]
  ṗ4    - Cartesian 4th power -> [[1,1,1,1], [1,1,1,0], ..., [0,0,0,0]]
                            i.e.  16       , 15         ..., 0
    ṫ6  - tail from 6th item  -> [[1,0,1,0], [1,0,0,1], ..., [0,0,0,0]]
                            i.e.  10       , 9        , ..., 0
      Y - join with line feeds
        - implicit print

एक वैकल्पिक 7-बायटर है 2ṗ4Ịṫ6Y, को [1,0]इसके साथ बदल दिया जाता है [1,2]और Ịयह "महत्वहीन" मोनाड ( abs(z)<=1) है, जो 2s को 0s में परिवर्तित करता है ।

— जोनाथन एलन
स्रोत

6

पायथन 3.6, 36 35 बाइट्स

i=11
while i:i-=1;print(f"{i:04b}")

-1 बाइट @JonathanAllan को धन्यवाद

पायथन 3.5 और इससे पहले:

i=11
while i:i-=1;print("{:04b}".format(i))

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

— OVS
स्रोत

1

i=11(नई लाइन) while i:i-=1;print(f"{i:04b}"), 35 के लिए।

— जोनाथन एलन

4

PHP, 33 बाइट्स

while($i<11)printf('%04b ',$i++);

— user63956
स्रोत

4

CJam , 12 बाइट्स

B{G+2b1>}%N*

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

व्याख्या

कार्टेशियन शक्ति दृष्टिकोण मेरी पसंद होगा, लेकिन पहले से ही लिया गया था।

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

B             e# Push 11
 {      }%    e# Map over "11", implicitly converted to the array [0 1 ... 10]
  G+          e# Add 16. This makes sure there will be 5 binary digits: a leading 1
              e# which will have to be removed and the remaining, valid digits
    2b        e# Convert to array of binary digits
      1>      e# Remove first digit
          N*  e# Join by newlines. Implicitly converts arrays to strings

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

3

MATLAB / ऑक्टेव, 13 बाइट्स

dec2bin(0:10)

ऑनलाइन डेमो

— Suever
स्रोत

3

जेली , 10, 9 , 8 बाइट्स

⁴r26BḊ€Y

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

मैं जेली में उतना महान नहीं हूं, इसलिए मैं किसी भी सुझाव के लिए खुला रहूंगा!

यह एमिग्ना के पहले एल्गोरिथ्म का उपयोग करता है

डेनिस के लिए धन्यवाद ~~दो बाइट शेविंग के~~ लिए मुझे अपना जवाब टाई करने के लिए। : पी

स्पष्टीकरण:

      Ḋ€    # Return all but the first element of each item in the list:
⁴r26        #   [16, 17, 18, ... 26]
     B      #   Converted to binary
        Y   # And joined with newlines

— DJMcMayhem
स्रोत

Ḋ€ एक बाइट बचाता है।

— डेनिस

@ डेनिस आह, जो समझ में आता है। धन्यवाद!

— DJMcMayhem

⁴r27 एक और बचाता है।

— डेनिस

3

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

n=16;exec"print bin(n)[3:];n+=1;"*11

2 बाइट बंद करने के लिए @DJMcMayhem को धन्यवाद!

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

— डेनिस
स्रोत

for n in range(11):print bin(n+16)[3:]38 बाइट्स में भी।

— ETHproductions

n=16;exec"print bin(n)[3:];n+=1;"*11 दो छोटे है

— DJMcMayhem

@DJMcMayhem यह वास्तव में है। धन्यवाद! :)

— डेनिस

2

जेली , 8 बाइट्स

2Ḷṗ4ḣ11Y

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

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

2Ḷṗ4ḣ11Y  Main link.

2Ḷ        Unlength 2; yield [0, 1].
  ṗ4      Take the fourth Cartesian power.
    ḣ11   Head 11; discard all but the first eleven elements.
       Y  Join, separating by linefeeds.

— डेनिस
स्रोत

2

RProgN, 15 बाइट्स

~16.aL1{2B26q}:

यह एक फ़ंक्शन जोड़ने के लिए एक बहुत अच्छा संशोधन रहा है pad। ]L4\-'0'\m\.आधे से अधिक कोड की संपूर्णता , पैड करना है।

_Saved 6 बाइट्स @ETHProductions की बदौलत , कि पैड फंक्शन आधे में कट गया है।

व्याख्या की

~16.aL1{2B26q}:
~               # Zero Space Segment
 16.            # The literal number 16
    aL          # The length of the Alphabet
      1         # The literal number 1
       {     }: # For each number between 16 and 26 inclusive
        2B      # Convert to base 2
          26q   # Get the characters between 2 and 6 inclusive.

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

— Ataco
स्रोत

length of the Alphabet एक बाइट बचाने के लिए अच्छा तरीका ;-)

— ETHproductions

2

रेटिना , 36 33 बाइट्स


%%%%
+`(^|\b)%
0$%'¶$%`1
11!`\d+

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

व्याख्या


%%%%

रिक्त (गैर-मौजूद) इनपुट के साथ बदलें %%%%।

+`(^|\b)%
0$%'¶$%`1

इस चरण के पहले भाग में, यह मेल खाएगा ^%और अनिवार्य रूप से पाठ %%%%को दो लाइनों 0%%%और के साथ बदल देगा 1%%%। जब तक आउटपुट बदलना बंद नहीं हो जाता तब तक स्टेज लूप करेगा। इसके दूसरे भाग पर, यह से मेल खाएगी \b%(के बाद से अंक शब्द पात्रों के रूप में गिनती और %नहीं करता है), और उन्हें डुप्लिकेट करने और जोड़कर समूहों की जगह 0एक प्रतिलिपि करने के लिए और 1अन्य के लिए: 0%%%लाइनों हो जाता है 00%%और 01%%(और के लिए बात की एक ही प्रकार 1%%%)। इस लूप के माध्यम से सभी 16 बिटस्ट्रिंग्स का उत्पादन किया जाएगा, लाइनफेड को अलग किया जाएगा।

11!`\d+

के पहले 11 मैचों \d+(कम से कम 1 अंक का एक रन) को पुनः प्राप्त किया जाता है। मैचों को एक लाइन-अलग-अलग सूची में आउटपुट किया जाता है।

— बिजनेस कैट
स्रोत

मैं यह समझने में उत्सुक हूं कि यह 0$%'¶$%1` लाइन कैसे काम करती है। क्या करते हैं $%, `1, '¶प्रतिनिधित्व करते हैं?

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

@KritiiLithos क्षमा करें, मैंने बारीकियों की व्याख्या नहीं की है, यह थोड़ा जटिल है: पी। $%`एक ही लाइन पर मैच से पहले सब कुछ का प्रतिनिधित्व करता है, और $%'एक ही लाइन पर मैच के बाद सब कुछ है। ¶शाब्दिक लाइनफ़ीड है। तो मूल रूप से प्रतिस्थापन %एक लाइन पर पहले से मेल खाता है और इसे 0बाकी की पंक्ति के साथ बदल देता है जो एक लाइन पर था, एक नई रेखा, उस पर शुरू होने वाली लाइन की शुरुआत, और ए 1। बेशक, लाइन की शुरुआत और अंत यह प्रतिस्थापन से अछूता था क्योंकि वे मैच का हिस्सा नहीं थे।

— बिजनेस कैट

इसलिए यह अपने बाद लाइन की एक कॉपी नहीं डाल रहा है, बल्कि लाइन के अंत, एक नई लाइन, और लाइन के शुरुआत और अंत के बीच में लाइन की शुरुआत को सम्मिलित करता है जो बरकरार रहता है।

— बिजनेस कैट

आह धन्यवाद, यह उपयोगी था :) (मैं अब रेटिना सीखने की कोशिश कर रहा हूँ)

— क्रिक्टी लिथोस

किस मामले में, मुझे लगता है कि आप G11`इसके बजाय रेगेक्स की अंतिम पंक्ति के रूप में उपयोग कर सकते हैं

— क्रिति लिथोस

2

रूबी, 25 बाइट्स

11.times{|n|puts"%04b"%n}

— जीबी
स्रोत

2

बीएफ, 121 101 बाइट्स

,....>,.<...+.>.<-..+.-.>.<..+..>.<-.+.-..>.<.+.-.+.>.<-.+..-.>.<.+...>.<.-...>.<+.-..+.>.<.-.+.-.!0

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

यदि प्रत्येक ऑपरेटर को 4 बिट माना जाता था, तो संभावित रूप से 51 बाइट्स

— Timtech
स्रोत

!चेकबॉक्स सक्षम होने के लिए आपको (या अतिरिक्त रूप से बाइट जोड़ना होगा) निर्दिष्ट करना चाहिए।

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

वूप्स, मैं इसके लिए नया हूं और सोचा था कि इसे URL में एन्कोड किया गया है। निर्दिष्ट करेगा ... प्रतीक्षा करें, वास्तव में, मुझे लगता है कि यह पहले से ही दूसरे वाक्य (?) में निर्दिष्ट है, थोड़ा स्पष्ट करेगा

— टिमटेक

2

सी #, 96 बाइट्स

golfed

()=>{for(int i=0;i++<11;)System.Console.WriteLine(System.Convert.ToString(i,2).PadLeft(4,'0'));}

Ungolfed

() => {
    for( int i = 0; i++ < 1; )
        System.Console.WriteLine( System.Convert.ToString( i, 2 ).PadLeft( 4, '0' ) );
}

पूर्ण कोड

using System;

namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            m();

            Console.ReadLine();
        }

        static void m() {
            for( Int32 i = 0; i++ < 11; )
                Console.WriteLine(
                    Convert.ToString( i, 2 ). // Converts the number to binary code
                    PadLeft( 4, '0' ) );      // Fills the number with the missing '0's
        }
    }
}

विज्ञप्ति

v1.0 - 96 bytes- प्रारंभिक समाधान।

— auhmaan
स्रोत

मुझे आपके द्वारा जोड़ा गया रिलीज़ संस्करण पसंद है - क्या आप आरसी संस्करणों को भी शामिल करने जा रहे हैं? \ O /

— शॉन बेयबर्स

1

ईमानदार होने के लिए, आरसी का मतलब क्या है पता नहीं ... यह है कि मैं PPCG में अपने समाधान पोस्ट करने की कोशिश करता हूं

— auhmaan

RC का अर्थ है 'रिलीज़ कैंडिडेट' - यानी, आप मामूली अंतर के साथ कुछ संस्करण भेजेंगे और यह देखने के लिए इंतजार करेंगे कि कौन सी RC नंबर से सबसे अधिक स्थिर है। इसलिए यदि आपके पास संस्करण ए और संस्करण बी था, तो आपके पास v1.0-आरसीए और v1.0-आरसीबी या कुछ और हो सकता है।

— शॉन बेयबर्स

1

ओह वो। नहीं, अगर मैं एक और रिलीज करता हूं, तो मैं अभी वर्जन नंबर बढ़ाता हूं ।

— auhmaan

2

C 170 120 बाइट्स

n,i,m,k[4]={0};f(){for(m=0;m<=10;m++){n=m;i=0;for(;n;i++){k[i]=n;n/=2;}for(i=4;i>0;i--)printf("%d",k[i-1]%2);puts("");}}

Ungolfed संस्करण:

void f()
{
    int n,i,m,k[4]={0};


   for(m=0;m<=10;m++)
   {
      n=m;
      i=0;

      for(;n;i++)
      {
         k[i]=n;
         n/=2;
      }  
      for(i=4;i>0;i--)
         printf("%d",k[i-1]%2);

      puts("");        
   }
}

निश्चित रूप से छोटा किया जा सकता है !?

@ बहुत बढ़िया विचार, धन्यवाद!

अब काम करना चाहिए! इसे ऑनलाइन आज़माएं!

— हाबिल टॉम
स्रोत

forआपके गोल्फ संस्करण में पहला लूप 3 के बजाय 4 पर जाना चाहिए, लेकिन इससे कोई फर्क नहीं पड़ता क्योंकि लूप को पूरी तरह से समाप्त किया जा सकता है और लूप के लिए दूसरा शुरू हो सकता है। 0. आप केवल उपयोग कर सकते हैं while(n), लेकिन whileलूप को नीचे संकुचित कर सकते हैं एक forलूप फिर से बचाता है। n/=2आपको शिफ्ट पर एक बाइट भी बचाएगा। तुम भी }संकलन पर एक त्रुटि के कारण गोल्फ संस्करण पर एक समाप्ति याद आ रही है।

— अहमोन

@Ahemone फिक्स्ड }और कोड में सुधार, आपके विचार के आधार पर 50 बाइट्स छोटे।

— हाबिल टॉम

102 बाइट्स

— छत

2

आर - 23

हम पैकेज intToBinसे फ़ंक्शन का उपयोग कर सकते हैं R.utils:

R.utils::intToBin(0:10)

[1] "0000" "0001" "0010" "0011" "0100" "0101" "0110" "0111" "1000" "1001" "1010"

— उछालभरी
स्रोत

2

सी, 75 68 69 बाइट्स

दृष्टिकोण 1: 75 73 74 बाइट्स

m;p(i){putchar(i?m&i?49:48:9);}r(){for(m=11;m--;p(4),p(2),p(1),p(0))p(8);}

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

दृष्टिकोण 2: 68 69 बाइट्स

m,n,o;f(){for(m=11;m--;)for(n=m,o=5;o--;n*=2)putchar(o?n&8?49:48:9);}

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

— Ahemone
स्रोत

के m,n;f(o)बजाय सुझाव देंm,n,o;f()

— छत

1

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

for x in range(11):print bin(x)[2:].zfill(4)

यह zfillफ़ंक्शन का उपयोग करता है जो rjustहमेशा की तरह काम करता है सिवाय इसके कि आप हमेशा पैड करते हैं 0ताकि आप एक तर्क पर बाइट बर्बाद न करें।

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

रुको, इस पूरे समय मैं बाइट बर्बाद कर रहा है अपने स्वयं के गद्दी समारोह बना? ( lambda k,l:' '*(len(k)-l)+k) वाह ... +1 इस कारण: डी

— हाइपरएनुट्रीनो

1

पाइके, 8 बाइट्स

TFw0+b2t

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

TFw0+b2t - for i in range(10):
  w0+    -    i+16
     b2  -   bin(^)
       t -  ^[:-1]

इसके अलावा 8 बाइट्स:

TF 4@b2t

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

   4@    - set_bit(4, i)

— नीला
स्रोत

1

पायथ - 8 7 बाइट्स

<5^_`T4

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

— माल्टीसेन
स्रोत

1

खड़ी , 30 बाइट्स

11:>[2 baserep'0'4 pad out]map

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

11:>से एक सीमा 0है 10। बाकी बल्कि आत्म-व्याख्यात्मक है।

अन्य समाधान जो मुझे मिले हैं:

11:>[bits 4 dpad''join out]map
11:>[bits 4 dpad$tostrmap]map out
11~>15+[bits behead''join out]map
16 26|>[bits behead''join out]map

— कोनोर ओ ब्रायन
स्रोत

1

रूबी, 38 बाइट्स

11.times{|i|puts i.to_s(2).rjust 4,?0}

— dkudriavtsev
स्रोत

कोष्ठकों से छुटकारा पाकर -1 बाइट: 11.times{|i|puts i.to_s(2).rjust 4,?0}

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

1

बीएफ , 134 बाइट्स

मुझे यकीन है कि इसे छोटा किया जा सकता है - यह मेरा पहला BF गोल्फ है।

++++++++++[>+>+>+++++>>>+++++>>>+++++>>>+++++[<<<]>>>-]>>+>[-->>+>]<<<[<<<]>>[>[>>-[<<+.->]<[>]>-[<<.>]<[>]>++>]<-[<<<-]++<<[<<<]>.>-]

इसे ऑनलाइन आज़माएं! TIO उपयोग में दुभाषिया की तरह, दोनों दिशाओं में एक टेप को अनंत मानता है। एक दुभाषिया जहां <टेप के बाएं छोर पर एक नो-ऑप है, तीन बाइट्स को बचाएगा।

व्याख्या

आधे से अधिक कोड (पहले 77 बाइट्स, सटीक होना) को टेप को इनिशियलाइज़ करने में खर्च किया जाता है। कदम इस तरह हैं:

++++++++++
10|

[>+>+>+++++>>>+++++>>>+++++>>>+++++[<<<]>>>-]
 0|10|10|50| 0| 0|50| 0| 0|50| 0| 0|50|

>>+>[-->>+>]<<<[<<<]>>
 0|10|11|48| 0| 1|48| 0| 1|48| 0| 1|48| 0| 1|

कोशिकाओं 1ने हमारे नंबर 1 के बिट्स को स्टोर करने के लिए इनिशियलाइज़ किया : 1एक शून्य बिट का 2प्रतिनिधित्व करता है और एक बिट का प्रतिनिधित्व करता है।

प्रारंभिक चरण सूचक पर सूचक के साथ समाप्त हुआ 11। अब हम अपने लूप के 11 पुनरावृत्तियों को चलाने के लिए इस सेल का उपयोग करते हैं:

[>          Move to the first 48
 [>>-       While we're still on a 48, move 2 cells over and decrement
  [         The cell's value now equals the bit it represents; if it's not 0:
   <<+.-    Move to the 48, increment, output, and decrement again
   >        Move to the next cell, which holds a 0
  ]         Leave the loop
  <[>]>     Pointer shenanigans to get back on the cell representing the bit
  -         Decrement again: cell is 255 for a zero bit, 0 for a one bit
  [         If cell is not 0:
   <<.>     Move to the 48, output, and move to the 0 cell
  ]
  <[>]>++   Get back on the bit's cell; increment back to original value
  >         Move to the next 48
 ]          Loop exits once we've output all four bits
            Now we increment the binary number: a one bit turns into a zero bit and
            carries; a zero bit turns into a one bit and doesn't carry
 <-         Move back to the rightmost bit cell and decrement
 [          If it is not 0, it must represent a one
  <<<-      Leave it decremented, go to the next bit cell and decrement it too
 ]          Loop exits on a bit cell that represented a zero
 ++         Increment it twice (to represent a one)
 <<[<<<]    Move back to first cell on tape
 >.         Move to 10 cell and output (newline)
 >-         Move to loop counter cell and decrement
]

— DLosc
स्रोत

बाइनरी नेबल्स में गिनती

स्माइलबासिक, 26 बाइट्स

MATL , 6 बाइट्स

05AB1E , 9 8 बाइट्स

जावास्क्रिप्ट, 46 बाइट्स

जाप , 7 बाइट्स

व्याख्या

बाश + GNU बर्तन, 26

बैश + यूनिक्स उपयोगिताओं, 29 26 बाइट्स

शुद्ध बैश , 34 बाइट्स

जे, 6 बाइट्स

जेली , 7 बाइट्स

कैसे?

पायथन 3.6, 36 35 बाइट्स

पायथन 3.5 और इससे पहले:

PHP, 33 बाइट्स

CJam , 12 बाइट्स

व्याख्या

MATLAB / ऑक्टेव, 13 बाइट्स

जेली , 10, 9 , 8 बाइट्स

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

जेली , 8 बाइट्स

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

RProgN, 15 बाइट्स

व्याख्या की

रेटिना , 36 33 बाइट्स

रूबी, 25 बाइट्स

बीएफ, 121 101 बाइट्स

सी #, 96 बाइट्स

C 170 120 बाइट्स

आर - 23

सी, 75 68 69 बाइट्स

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

पाइके, 8 बाइट्स

पायथ - 8 7 बाइट्स

खड़ी , 30 बाइट्स

रूबी, 38 बाइट्स

बीएफ , 134 बाइट्स

व्याख्या