বাইনারি nybbles মধ্যে গণনা

19

এই চ্যালেঞ্জটি হল আপনার টার্মিনাল, উইন্ডো, ক্যানভাসে আউটপুট দেওয়া বা শূন্য থেকে 10 অন্তর্ভুক্ত করে স্ক্রীন করা। প্রতিটি আউটপুটযুক্ত নম্বরটি অবশ্যই 4-বিট প্রশস্ত নিবিলে হিসাবে দেখানো উচিত, সুতরাং শূন্যটি অবশ্যই দেখায় 0000।

আপনি আউটপুট করা প্রতিটি নম্বরকে একটি স্থান, কমা বা ক্যারিজ রিটার্ন দিয়ে আলাদা করতে পারেন। ক্ষুদ্রতম সমাধান জিততে পারে তবে আপনার ক্রমটিতে কোনও পুনরাবৃত্তি সংখ্যা না থাকায় নম্বরগুলি আপনার পছন্দ অনুযায়ী যে কোনও ক্রমে প্রদর্শিত হতে পারে।

কমা বা সাদা স্পেস দিয়ে আউটপুট করা সম্ভব না হলে নিম্ন-স্তরের বাইনারি ভাষাগুলিতে কমা বা সাদা স্থান বিভাজক সম্পর্কে চিন্তা করার দরকার নেই (উদাহরণস্বরূপ, স্ট্যান্ডার্ড আউটপুট কেবল বাইনারিতে সীমাবদ্ধ, অথবা আপনার সমাধানটি প্রাথমিক কম্পিউটার কিটের জন্য রয়েছে) যেমন কিআইএম -১ এর সীমিত ডিজিটাল ডিসপ্লে রয়েছে)।

code-golf  kolmogorov-complexity  binary 
— শন বেবারস
সূত্র
হ্যাঁ, স্থান, কমা, একটি কমা এবং তারপরে আপনার নির্বাচিত ভাষায় একটি স্থান বা "\ r \ n" সমতুল্য।
— শন বেবারস
দু: খিত হিসাবে এটি 4 স্বতন্ত্র শূন্য অঙ্কের মতো দেখাচ্ছে এবং 4-বিট প্রশস্ত বাইনারি সংখ্যা নয়।
— শন বেবারস
এমনটি নয় যে আমি এই জাতীয় উত্তরটি লিখতে সত্যই নিশ্চিত, তবে 11 টি অতিরিক্ত 11 টি অতিরিক্ত ছাড়াও কিছু অতিরিক্ত স্তনবৃন্ত আউটপুট দেওয়া কি ঠিক হবে?
— আর্নৌল্ড
2
এরা নেবলস, কপাল নয়।
— 0WJYxW9FMN
কমোডোর 64 প্রোগ্রামারস রেফারেন্স গাইড অনুসারে নয়
— শন বেবারস

উত্তর:

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

বাশ + জিএনইউ ব্যবহার, 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

এটি অনলাইন চেষ্টা করুন!

এটি @ ডিজিটালট্রামা / @ ডেনিসের সমাধানের সমান দৈর্ঘ্য, তবে সম্পূর্ণ ভিন্ন পদ্ধতি ব্যবহার করে।

আউটপুট হল:

1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(যে কোনও আদেশ অনুমোদিত)

খাঁটি বাশ , 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ঠিক যেমন ভাল কাজ করা উচিত
— মাইল
এখনই মুছে ফেলা মন্তব্যের জবাব অনুসারে আমি নিশ্চিত নই যে এটি বৈধ কিনা ।
— অ্যাডাম
@ অ্যাডাম আমি এটি দেখতে পারি না। আপনি দয়া করে ব্যাখ্যা করতে পারেন কেন এটি বেড নয়?
— ব্লকগুলি
কারণ এটি একটি × 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), এসকে 2এস তে রূপান্তর করে 0।

— জোনাথন অ্যালান
সূত্র
4

সিজেম , 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

জেলি , 10, 9 , 8 বাইট

⁴r26BḊ€Y

এটি অনলাইন চেষ্টা করুন!

আমি জেলি তেমন দুর্দান্ত নই, তাই আমি কোনও পরামর্শের জন্য খোলা থাকব!

এটি এমিগিনার প্রথম অ্যালগরিদম ব্যবহার করে

আমাকে তার নিজের জবাব বাঁধিয়ে দেওয়ার জন্য দুটি বাইট শেভ করার জন্য ডেনিসকে ধন্যবাদ । : P: P

ব্যাখ্যা:

      Ḋ€    # 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
— ডিজেএমসিএমহেম
সূত্র
Ḋ€একটি বাইট সংরক্ষণ করে।
— ডেনিস
@ ডেনিস আহ, এটি উপলব্ধি করে। ধন্যবাদ!
— ডিজেএমসিএমহেম
⁴r27অন্য একটি সংরক্ষণ করে।
— ডেনিস
3

পাইথন 2 , 38 36 বাইট

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

2 ডি বাইট বন্ধ করে দেওয়ার জন্য @ ডিজেএমসিমেহেমকে ধন্যবাদ!

এটি অনলাইন চেষ্টা করুন!

— ডেনিস
সূত্র
for n in range(11):print bin(n+16)[3:]38 বাইটেও
— ETH প্রোডাকশনগুলি
n=16;exec"print bin(n)[3:];n+=1;"*11দুটি খাটো
— ডিজেএমসিএমহেম
@ ডিজেএমসিমেহেম এটি সত্যই। ধন্যবাদ! :)
— ডেনিস
2

আরপিগ্রন, 15 বাইট

~16.aL1{2B26q}:

এটি একটি ফাংশন যোগ করার জন্য একটি খুব ভাল পরিবর্তন হয়েছে pad। সম্পূর্ণতা ]L4\-'0'\m\., অর্ধেকের বেশি কোড, প্যাড হয়।

6 _Saved ধন্যবাদ বাইট @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বাইট সংরক্ষণের দুর্দান্ত উপায় ;-)
— ETH প্রোডাকশনগুলি
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, '¶চিত্রিত করে?
— ক্রিটসি লিথোস
@ ক্রিতিক্সিলিথোস দুঃখিত, আমি নির্দিষ্টকরণগুলি ব্যাখ্যা করতে পারি নি, এটি কিছুটা বিশৃঙ্খলাবদ্ধ: পি। $%`একই লাইনে ম্যাচের আগে সমস্ত কিছু উপস্থাপন করে এবং একই লাইনে $%'ম্যাচের পরে সবকিছু। একটি আক্ষরিক লাইনফিড। তাই মূলত প্রতিস্থাপন প্রথম ম্যাচ %একটি লাইন এবং সঙ্গে এটি প্রতিস্থাপন 0প্লাস লাইন এটিতে ছিল, একটি newline বাকি, লাইন শুরুতে এটা ছিল, এবং একটি 1। অবশ্যই, রেখার শুরু এবং শেষটি প্রতিস্থাপনের দ্বারা অচ্ছুত কারণ তারা ম্যাচের অংশ ছিল না।
— বিড়াল বিড়াল
সুতরাং এটি নিজের পরে লাইনের অনুলিপি রাখছে না, বরং রেখার শেষ, একটি নতুন লাইন এবং রেখার শুরু এবং শেষের মধ্যে রেখার শুরুটি অক্ষত থাকবে act
— বিড়াল বিড়াল
আহ ধন্যবাদ, এটি সহায়ক ছিল :) (আমি এখন রেটিনা শিখতে চেষ্টা করছি)
— ক্রিটিক্সী লিথোস
G11`সেক্ষেত্রে আমি মনে করি আপনি এর পরিবর্তে
— রেগেক্সের
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
আরসি এর অর্থ 'মুক্তির প্রার্থী' - অর্থাত্ আপনি সামান্য পার্থক্য সহ কয়েকটি সংস্করণ প্রেরণ করবেন এবং আপনার আরসি নম্বর দ্বারা কোনটি সবচেয়ে স্থিতিশীল তা দেখার জন্য অপেক্ষা করবেন it সুতরাং আপনার যদি সংস্করণ A এবং সংস্করণ বি থাকে তবে আপনার v1.0-RCa এবং v1.0-RCb বা অন্য কিছু থাকতে পারে।
— শন বেবারস
1
ওহ এই. না, যদি আমি অন্য প্রকাশ করি তবে আমি এখনই সংস্করণ নম্বর বাড়িয়ে দিচ্ছি ।
— auhmaan
2

সি 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("");}}

অবরুদ্ধ সংস্করণ:

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 থেকে শুরু হতে পারে You আপনি কেবল ব্যবহার করতে পারেন while(n), তবে whileলুপটিকে নীচে রেখে কমপ্যাক্ট করছেন একটি forলুপ আবার আরও সঞ্চয় করে। n/=2শিফটে আপনাকে একটি বাইটও বাঁচাতে হবে। আপনি }গল্ফযুক্ত সংস্করণে একটি সমাপ্তিও মিস করছেন যা সংকলনের ক্ষেত্রে ত্রুটির সৃষ্টি করেছে।
— অহমোন
@ অহমোন }আপনার ধারণার উপর ভিত্তি করে 50 বাইট সংক্ষিপ্ততর কোডটি ঠিক করেছে এবং উন্নত করেছে।
— আবেল টম
— সিলিংক্যাট
2

আর - 23

আমরা প্যাকেজ intToBinথেকে ফাংশন ব্যবহার করতে পারেন R.utils:

R.utils::intToBin(0:10)

[1] "0000" "0001" "0010" "0011" "0100" "0101" "0110" "0111" "1000" "1001" "1010"
— লাফানো বল
সূত্র
1

পাইথন 2, 44 বাইট

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

এটি সর্বদা প্যাডগুলি বাদ দিয়ে zfillকাজ করে এমন ফাংশনটি ব্যবহার করে যাতে আপনি কোনও যুক্তি দিয়ে বাইটগুলি অপচয় করবেন না।rjust0

— গম উইজার্ড
সূত্র
অপেক্ষা করুন, এই পুরো সময়টি আমি আমার নিজস্ব প্যাডিং ফাংশন বাইটগুলি নষ্ট করছি? ( lambda k,l:' '*(len(k)-l)+k) বাহ ... +1 কেবল
— এটির
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

বিএফ , 134 বাইট

আমি নিশ্চিত যে এটি সংক্ষিপ্ত করা যায় - এটি আমার প্রথম বিএফ গল্ফের চেয়ে অনেক বেশি।

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

এটি অনলাইন চেষ্টা করুন! উভয় দিকেই একটি টেপকে অসীম বলে ধরেছেন, যেমন টিআইওর দোভাষীর ব্যবহার। <টেপের বাম প্রান্তে কোনও দোভাষী যে কোনও নো-ওপেন রয়েছে সেখানে তিনটি বাইট সংরক্ষণ করতে পারবেন।

ব্যাখ্যা

কোডটির অর্ধেকেরও বেশি (প্রথম 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। এখন আমরা আমাদের লুপের ১১ টি পুনরাবৃত্তি চালাতে এই সেলটি ব্যবহার করি:

[>          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
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.