"অনন্ত" থেকে গণনা করুন


47

এক অসম্ভব কাজ ঠিক মনে হচ্ছে? ঠিক আছে, এটি আসলে এতটা কঠিন নয়। যদি আমরা Infinity8-বিট বাইনারি ASCII কোড হিসাবে শব্দটি লিখি তবে আমরা পাবেন:

01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

এটি সংমিশ্রিত হতে পারে এবং দশমিক মানকে রূপান্তর করা যায় 5291279215216915577। এখন এটি এমন একটি সংখ্যা যা আমরা কাজ করতে পারি ...

আপনি যেভাবে গণনা করছেন তা হ'ল:

  1. দশমিক সংখ্যা হিসাবে মূল স্ট্রিং আউটপুট (উপরে প্রদর্শিত হিসাবে)
  2. এর বাইনারি উপস্থাপনায় শীর্ষস্থানীয় 0 গুলি সরান (যদি থাকে)
  3. বাইনারি উপস্থাপনায় বিটগুলি টগল করুন (1-> 0, 0-> 1)
  4. দশমিক দশমিক আউটপুট
  5. আপনি 0 পৌঁছানোর আগ পর্যন্ত 2-4 পদক্ষেপ পুনরাবৃত্তি করুন।

চ্যালেঞ্জ:

একটি প্রোগ্রাম বা ফাংশন তৈরি করুন যা স্ট্রিংটিকে ইনপুট হিসাবে গ্রহণ করে এবং উপরের প্রক্রিয়াটি সম্পাদন করার সময় আপনি যে নম্বরগুলি পাবেন সেগুলি (কোনও উপযুক্ত বিন্যাসে) আউটপুট করে।

পরীক্ষা ক্ষেত্রে:

আমি মনে করি যে চ্যালেঞ্জটি কেবলমাত্র একটি পরীক্ষার ক্ষেত্রে হলেও, এটি বুঝতে মোটামুটি সহজ হবে। আমি এটিকে মোটামুটি সংক্ষিপ্ত রাখার Infপরিবর্তে ব্যবহার করব Infinity

Inf
4812390  (10010010110111001100110)
3576217  ( 1101101001000110011001)
618086   (   10010110111001100110)
430489   (    1101001000110011001)
93798    (      10110111001100110)
37273    (       1001000110011001)
28262    (        110111001100110)
4505     (          1000110011001)
3686     (           111001100110)
409      (              110011001)
102      (                1100110)
25       (                  11001)
6        (                    110)
1        (                      1)
0        (                      0)

Input: Inf 
Output:
4812390, 3576217, 618086, 430489, 93798, 37273, 28262, 4505, 3686, 409, 102, 25, 6, 1, 0 

Input: Infinity
Output:
5291279215216915577, 3932092821637860230, 679593196789527673, 473328307817319302, 103132444486104185, 40982743589751686, 31074850448176249, 4953946570787718, 4053252683953273, 450346943417222, 112603010004089, 28134478351238, 7049893737593, 1746199284614, 452823970937, 96931842950, 40507110521, 28212366214, 6147372153, 2442562438, 1852404857, 295078790, 241792121, 26643334, 6911097, 1477510, 619641, 428934, 95353, 35718, 29817, 2950, 1145, 902, 121, 6, 1, 0

আপনার কোড অবশ্যই এমন স্ট্রিংগুলিকে সমর্থন করবে যা আপনার ভাষার সীমা পর্যন্ত বাইনারি সংখ্যা হিসাবে উপস্থাপিত হতে পারে। সমস্ত স্ট্রিংয়ে কেবল 32-126 (স্পেস থেকে টিলডে) প্রিন্টযোগ্য এএসসিআইআই-অক্ষর থাকবে।


লিডারবোর্ড



2
@ লুইস মেন্ডো চক নরিস 'ন্যারস-এপিএল:∞..0
অ্যাডাম

5
@ লুইসমেডো আপনি কি নিশ্চিতরূপে জন স্কিইটকে বোঝাতে চাইছেন না ?
mbomb007

উত্তর:


12

জেলি , 15 10 বাইট

-5 বাইটস @ ডেনিসকে ধন্যবাদ (মূল 256 বেস থেকে সরাসরি রূপান্তর করুন)

Oḅ⁹µBCḄµÐĿ

TryItOnline!

কিভাবে?

Oḅ⁹µBCḄµÐĿ - Main link: s                     e.g. "Inf"
O          - cast to ordinals                 e.g. [73,110,102]
 ḅ⁹        - convert from base 256 to integer e.g. 4812390
   µ   µ   - monadic chain separations
    B      -     convert to binary
     C     -     complement
      Ḅ    -     convert to integer
        ÐĿ - loop until no longer unique and collect results 

1
প্রথম অংশটি ঠিক Oḅ⁹
ডেনিস

ওহ আমার, আমি কীভাবে মিস করেছি?!
জোনাথন অ্যালান

11

পাইথন 2, 89 82 77 76 75 বাইট

n=0
for c in input():n=n<<8|ord(c)
while 1:print n;n^=2**n.bit_length()-n/n

আইডিয়নে এটি পরীক্ষা করুন ।

কিভাবে এটা কাজ করে

N থেকে 0 শুরু করার পরে , দ্বিতীয় লাইনটি নিম্নলিখিতভাবে চ্যালেঞ্জগুলিতে নির্দিষ্ট করা স্ট্রিং-টু-ইন্টিজার রূপান্তর সম্পাদন করে।

প্রতিটি পদক্ষেপে, n টি 8 ইউনিট বাম দিকে স্থানান্তরিত হয় , তারপরে বিটওয়্যারস বা পরবর্তী অক্ষরের সি কোড পয়েন্টের সাথে OR- করা হবে । ইনপুট ইনফের জন্য , এটি নিম্নলিখিত হিসাবে যায়।

n                                  0
a = n<<8                           0
b = 'I'                      1001001
n = a ^ b                    1001001
a = n<<8             100100100000000
b = 'n'                      1101110
n = a ^ b            100100101101110
a = n<<8     10010010110111000000000
b = 'f'                      1100110
n = a ^ b    10010010110111001100110

এখন আমরা আউটপুট উত্পন্ন করতে প্রস্তুত। এন এর বিটগুলি উল্টাতে , আমরা নীচে এগিয়ে চলি।

প্রথমত, আমরা নেতৃস্থানীয় জিরো ছাড়াই এন এর বাইনারি উপস্থাপনায় বিটগুলি গণনা করি । আসুন রেজাল্ট কে । তারপরে, আমরা 2 এর কে কে পাওয়ার গণনা করি , যার কে + 1 বাইনারি সংখ্যা রয়েছে: একটি একক 1 , তারপরে কে 0 এর গুলি। আমরা বিয়োগ 1 ফলাফল থেকে, গঠিত একটি সংখ্যা ফলনশীল যা আমরা তারপর XOR যাও বেশী, এন তার বিট উল্টানো। ইনপুট ইনফের জন্য এটি নিম্নলিখিত হিসাবে যায়।

n         4812390   10010010110111001100110
k              23 
t = 2**k           100000000000000000000000
t -= 1              11111111111111111111111
n ^= t    3576217    1101101001000110011001
k              22
t = 2**k            10000000000000000000000
t -= 1               1111111111111111111111
n ^= t     618086      10010110111001100110
.
.
.
n               6                       110
k               3
t = 2**k                               1000
t -= 1                                  111
n ^= t          1                         1
k               1
t = 2**k                                 10
t -= 1                                    1
n ^= t          0                         0

বাস্তবায়ন অতিরিক্ত হার্ডল আমরা প্রিন্ট আছে যে এন প্রথম পদক্ষেপ আগে, পরে শেষ ধাপে, এবং এর মধ্যে সব পদক্ষেপে। পাইথনের ডু-উইল লুপ নেই এবং একটি একক মুদ্রণের বিবৃতিতে 8 বাইটের দাম রয়েছে , তাই আমরা পরিবর্তে নিম্নলিখিতটি করি।

আপডেট পদক্ষেপের সরাসরি প্রয়োগে, অর্থাত্,

while n:print n;n^=2**n.bit_length()-1
print n

আমরা একটি অসীম এক ( while 1) এর সাথে লুপটি প্রতিস্থাপন করি এবং 1লুপ হিসাবে লুপটি গণনা করি n/n। এটি সমান যখন n> 0

একবার এন = 0 হয়ে গেলে আমরা লুপে থাকি, আবার একবার রাষ্ট্রটি মুদ্রণ করি, তারপরে এটি আপডেট করার চেষ্টা করি। যাইহোক, 0/0একটি জিরো ডিভিশনইরির ট্রিগার করে, লুপটি ভেঙে ত্রুটি সহ প্রস্থান করে। নোট করুন যে এটি STDERR এ বিপথগামী আউটপুট তৈরি করে, যা ডিফল্টরূপে অনুমোদিত


2
আমি সেই -n/nকৌশলটি পছন্দ করি :-)
ETH প্রোডাকশন

n/nকৌতুকের চেয়ে কি আপনি ব্যাখ্যা করতে পারেন ? এটি সম্ভবত অন্য কোনও উত্তরে ব্যাখ্যা করা হয়েছে তবে আমি এটি পাইনি। এটি এখানে কি করে?
স্টিভি গ্রিফিন

@ স্টিভিগ্রিফিন এন / এন 1 0 না হওয়া অবধি 1, তারপরে এটি একটি ত্রুটি ছুঁড়ে দেয় এবং প্রোগ্রামটি বন্ধ করে দেয়।
jazzpi

একটি ত্রুটি বার্তা সহ (আমি আশা করি)?
স্টিভি গ্রিফিন

1
পছন্দ করেছেন পাইথন যখন ত্রুটি প্রতিবেদন করার বিষয়টি আসে তখন যন্ত্রণাদায়কভাবে ভার্বোজ হয়। আমি আমার ব্যাখ্যা সম্পাদনা করেছি একটি ব্যাখ্যা অন্তর্ভুক্ত করতে।
ডেনিস

8

জাভাস্ক্রিপ্ট, 82 বাইট

@ অর্নুয়ালডকে একটি বাইট ধন্যবাদ সংরক্ষণ করা হয়েছে

for(y of prompt(n=0))n=n<<8|y.charCodeAt()
for(;alert(n)|n;)for(i=1;i<=n;i*=2)n^=i

খুব কম সময়ের মধ্যে একটি যখন একটি সম্পূর্ণ প্রোগ্রাম কোনও ফাংশনকে ছাড়িয়ে যায় (এবং ES6 ES5 কে ছাড়িয়ে যায় না) ...


উপরেরটি 4-বর্ণের শব্দগুলিকে সমর্থন করে। 6-অক্ষরের শব্দ পর্যন্ত সমর্থন করতে 4 বাইট যুক্ত করুন:

for(y of prompt(n=0))n=n*256+y.charCodeAt()
for(;alert(n)|n;n=i-n-1)for(i=1;i<=n;)i*=2


g=a=>a[0]?a.pop().charCodeAt()+g(a)*256:0(-1)
তিতাস

@ টিটাস ধন্যবাদ! আমি কেন এটি ভেবে দেখিনি তা নিশ্চিত নয়
ETH প্রোডাকশনগুলি

n<<8|y.charCodeAt()একটি বাইট সংরক্ষণ করা উচিত। for(;n;)for(i=!alert(n);i<=n;i*=2)n^=iঅন্য বাইট সংরক্ষণ করতে পারে, কিন্তু আপনি প্রদর্শিত হবে না 0, যা সম্ভবত প্রয়োজন হয়।
আর্নল্ড

@ আরনাউল্ড ধন্যবাদ আমি n<<8আগে করার বিষয়ে ভেবেছিলাম কিন্তু সিদ্ধান্ত নিয়েছি এটি কাজ করবে না কারণ এটি 31 টিরও বেশি বিটের সাথে ব্রেক করবে। আমি মনে করি এখন এটি কোনও ব্যাপার নয় যে আমি ইতিমধ্যে এটি একটি 31-বিট সংস্করণ এবং 53-বিট সংস্করণের মধ্যে বিভক্ত করেছি ... এবং দুঃখের বিষয়, আমি মনে করি না যে আমি প্রথম উভয়কে সতর্ক করার সময় সতর্কতায় কিছু সংরক্ষণ করতে পারি পুনরাবৃত্তি এবং শেষ।
ETH প্রোডাকশনগুলি


6

05 এ বি 1 ই , 18 বাইট

ব্যবহার সিপি-1252 এনকোডিং।

Çžz+b€¦J[CÐ,_#bS_J

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

ব্যাখ্যা

Ç                     # convert string to list of ascii codes
 žz+                  # add 256 to each
    b                 # convert to binary
     €¦               # remove the first digit of each list of digits
       J              # join
        [             # start loop
         C            # convert to decimal
          Ð           # triplicate
           ,          # print 1 copy
            _#        # if the 2nd copy is 0, break loop
              b       # convert 3rd copy to binary
               S      # split to list
                _     # negate each in list
                 J    # join


4

গণিত, 99 বাইট

a=FromDigits;b=IntegerDigits;NestWhileList[a[1-#~b~2,2]&,a[Join@@b[ToCharacterCode@#,2,8],2],#>0&]&

বেনামে ফাংশন। ইনপুট হিসাবে একটি স্ট্রিং নেয় এবং আউটপুট হিসাবে সংখ্যার একটি তালিকা প্রদান করে।


4

হাস্কেল, 109 123 118 102 97 বাইট

5 বাইট বাঁচানোর জন্য @ নিমিকে ধন্যবাদ!

c 0=0
c n=1-mod n 2+2*c(div n 2)
(++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum

ব্যবহার: (++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum $ "Infinity"

ভাষা দ্বারা 29 বিট পর্যন্ত সংখ্যাগুলিতে কাজ করার গ্যারান্টিযুক্ত, সাধারণত 64৪-বিট সিস্টেমে 63৩-বিট সংখ্যা পর্যন্ত কাজ করে। map(fromIntegral.fromEnum)ইচ্ছামত বৃহত সংখ্যার সমর্থন করতে (+14 বাইট) পরিবর্তে ব্যবহার করুন ।

ইউনিকোড ব্যাপ্তির জন্য কাজ করে [0..255]। পুনরাবৃত্তি বিট ফ্লিপ।


1
আপনি প্রতিস্থাপন করতে পারেন takeWhile(>0)সঙ্গে fst.span(>0)। আপনি যদি পয়েন্টফ্রি যান তবে আপনি নামটি ফেলে দিতে পারেন f, তাই আপনার মূল কাজটি (++[0]) ... map fromEnum
নিমি

@ নিমি ধন্যবাদ, নাম বাদ দিলে আমার যে ধরণের অনুক্রমের সমস্যাটি হয়েছিল তা সমাধান করা যায় f
Angs

কেন fromIntegral? চ্যালেঞ্জ থেকে: "অবশ্যই সমর্থন করা উচিত ... 63 বাইট অবধি ... বা আপনার ভাষার সীমা", তাই ঠিক Intহওয়া উচিত। আপনি এটা রাখতে চান, তাহলে এটি সরাতে map, অর্থাত্ আপনার পুরোনো সংস্করণ foldl1এবং map(fromIntegral.fromEnum)
নিমি

@ নিমিমি ওপি এখানে একটি মন্তব্য পোস্ট করেছেন (যেহেতু মুছে ফেলা হয়েছে), এটি জিজ্ঞাসা করেছে যে এটি 63৩ বিট সমর্থন করে কিনা, তাই আমি ধরে নিলাম যে এটি তার উদ্দেশ্য ছিল। আমাকে মারছে।
Angs

4

পিএইচপি, 132 126 123 120 108 107 বাইট

foreach(unpack("C*",$argv[1])as$i)$n=$n*256+$i;for(print$n;$n;)echo _.$n=bindec(strtr(decbin($n),"01",10));
  • লুপের পরে 0 মুদ্রণ করা লুপের পরে 6 বাইট সংরক্ষণের আগে প্রাথমিক মানের পরিবর্তে হয়।
  • unpackঅপ্রচলিত -> -3 বাইট str_splitরেন্ডারগুলির পরিবর্তেord()
  • _বিভাজক হিসাবে 3 সংরক্ষণ করে আন্ডারস্কোর
  • bindecপরিবর্তে ltrimনেতৃস্থানীয় শূন্যগুলি অপসারণ করার পরিবর্তে : -12
  • echoলুপের শরীরে printলুপ মাথায় 1 বাইট ওভার সাশ্রয় করে ।

$n=$n*256+$i;for(print$n;$n;)হিসাবে লেখা যায় না for(print$n=$n*256+$i;$n;)? যেহেতু অ্যাসাইনমেন্ট অংশটি একবার কার্যকর হবে, এটি কাজ করা উচিত। এবং পরিবর্তে echo _.$n=[...], আপনার echo _,$n=[...]পরিবর্তে ব্যবহার করা উচিত । এটি কোনও বাইট সংরক্ষণ করবে না, তবে কোডটি একটি ক্ষুদ্র ক্ষুদ্র ক্ষুদ্র ক্ষুদ্র ক্ষুদ্র কিছুটা গতিবে এবং বিবৃতি পৃথক করবে। তার মানে হল, উদাহরণস্বরূপ, echo _,$a?5:6;পরিবর্তে লেখা যেতে পারে echo _.($a?5:6);। এটি ভবিষ্যতে সহায়ক হতে পারে।
ইসমাইল মিগুয়েল

@ ইসমাইলমিগুয়েল অ্যাসাইনমেন্ট অংশটি একটি লুপ। আমার যখন বিন্দু লাগবে না তখন আমি আসলে কমা ব্যবহার করি; এটি printএই ক্ষেত্রে একটি অবশিষ্টাংশ । একা এডিট করার যোগ্য নয়; কিন্তু ধন্যবাদ.
টাইটাস

ওহ, ঠিক আছে ... এটি foreach(unpack("C*",$argv[1])as$i)... মূর্খ আমাকে ... এবং হ্যাঁ, কমাতে একই প্রভাব ফেলতে একটি সময়কাল পরিবর্তন করা সমস্যার জন্য উপযুক্ত নয়।
ইসমাইল মিগুয়েল

4

পার্ল, 65 বাইট

53 বাইট কোড + 12 এর জন্য -Mbigint -p

আমাকে 13 বাইট সংরক্ষণ করার জন্য @ দাদাকে ধন্যবাদ !

$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0

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

ব্যবহার

echo -n 'Inf' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0
echo -n 'Infinity' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0

1
আমার বন্ধুকে আনপ্যাক করুন! perl -Mbigint -lpE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'(আমি কোন ধারণা কিভাবে ব্যবহার করবেন তা আছে আনপ্যাক সাধারণত, আমি শুধু যখন কিভাবে বাইনারি ;-) করার জন্য একটি স্ট্রিং রূপান্তর করতে googling ভাগ্যবান)
দাদা

আহ, আমি unpackসিনট্যাক্সটি সবসময় ভুলে যাই আমার মন সবসময় উড়ে যায়! আমি আপডেট করব, ধন্যবাদ!
ডোম হেস্টিংস

নেই perlpacktut যে সাহায্য করা উচিত ... আমি সময় প্রথম 10 লাইন ডজন পড়েছি, কিন্তু আমি সত্যিই বাকীটা পড়তে সময় লাগবে উচিত!
দাদা

@ দাদা আমি নিশ্চিত যে আমি এটি অনেক বার পড়েছি, এটি কখনই থাকে না ... ধন্যবাদ আবার -13 কোনও ছোট কীর্তি নয়! আমাকে পরিবর্তন করতে echo -nহবে অন্য একমাত্র পরিবর্তন।
ডোম হেস্টিংস

4

পাইথ, 12 বাইট

.usi!MjN2 2C

এমন একটি প্রোগ্রাম যা উদ্ধৃত স্ট্রিংয়ের ইনপুট নেয় এবং ফলাফলটির পূর্ণসংখ্যার তালিকা হিসাবে মুদ্রণ করে।

সমস্ত পরীক্ষার কেস যাচাই করুন

কিভাবে এটা কাজ করে

.usi!MjN2 2C  Program. Input: Q
           C  Convert Q to an integer by code-points using base-256 (implicit input)
.u            Apply the following function A(N) until a repeat occurs, storing the results
              in a list:
      jN2       Convert to binary as a list
    !M          Map negation over the above
   i      2     Convert from binary to integer
  s             Integer (Converts final False to 0)
              Implicitly print

3

পাইথন 3, 99 95 বাইট

x=int.from_bytes(bytes(input(),'utf-8'),'big')
while x:print(x);x^=2**x.bit_length()-1
print(0)

মূল ধারণাটি হ'ল স্ট্রিংকে বাইটে সংখ্যায় রূপান্তর করা। প্রতিটি পুনরাবৃত্তি শূন্যের দিকে অগ্রগতিতে 1s সহ আউটপুট এবং XOR মুদ্রণ করে।


আপনার চারপাশে প্রথম বন্ধনী প্রয়োজন নেই 2**x.bit_length()-1। পাওয়ার এবং বিয়োগের জন্য ক্রিয়াকলাপের ক্রম জোওরের চেয়ে বেশি। এছাড়াও, whileএটি একটি একক লাইনে থাকতে পারে।
mbomb007

এক লাইনে
উইল

প্রোগ্রামটি শুরু করার চেষ্টা করুন P=printএবং তার P()পরিবর্তেprint()
সাইওস

3

পাইথন 2, 117 115 বাইট

সাইওসকে ধন্যবাদ 2 বাইট সংরক্ষণ করা।

অনুমান ইনপুট কোট মধ্যে বদ্ধ, যেমন "Inf"

s=input()
n=sum(ord(s[-i-1])<<i*8for i in range(len(s)))
while n:
 print n;k,m=n,1
 while k:k/=2;m*=2
 n^=m-1
print 0

mসর্বোচ্চ অঙ্ক পর্যন্ত গণনা করা হয়, তাই m-1কাঙ্ক্ষিত ক্রিয়াকলাপ সম্পাদনের জন্য একটি এক্সওআর মাস্ক। দীর্ঘতম অংশটি ইনপুটটিকে প্রাথমিক বিট ক্রমের মধ্যে রূপান্তর করছে।

উদাহরণ:

"Inf"
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0

"Infinity"
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0

আপনি প্রতিস্থাপন করতে পারেন -i-1সঙ্গে~i
Cyoce

3

রুবি, 104 101 100 81 80 65 বাইট

19 বাইট সংরক্ষিত হয়েছে @ ওয়াইনকনরাডকে ধন্যবাদ!
15 ফিল্ডের জন্য বাইটস সংরক্ষণ করা হয়েছে!
1 বাইট সংরক্ষিত @ লাইভকে ধন্যবাদ!

p n=$*[0].unpack('B*')[0].to_i(2)
p n^=2**n.bit_length-1while n>0

কমান্ড লাইন আর্গুমেন্টের মাধ্যমে ইনপুট নেয়।

@ জিমি জনসনের পাইথন উত্তরটি দ্বারা অনুপ্রাণিত


আপনি প্রতিস্থাপন কয়েকটি অক্ষর সংরক্ষণ করতে সক্ষম হতে পারে i.to_s(2).rjust 8,'0'সঙ্গে"%08b"%i
ওয়েন কনরাড

এছাড়াও, আমি মনে করিinject(:+)join
ওয়েন কনরাড

@ ওয়াইনকনরড সাহায্যের জন্য ধন্যবাদ! আমি কীভাবে সেগুলি সম্পর্কে ভুলে গেছি তা নিশ্চিত নয়
সাইয়েস

আমি সাহায্য করতে পেরে আনন্দিত! আমাকে # বিট_লেন্থ পদ্ধতিটি শেখানোর জন্য ধন্যবাদ, যার সম্পর্কে আমি জানতাম না।
ওয়েইন কনরাড

1
মেসে না গিয়ে বরং unpackঅনুসরণ করে স্যুইচ করা 11 বাইট সাশ্রয় করবে। পরিবর্তে (কনসোল ইনপুট পরিবর্তে কমান্ড লাইন যুক্তি ব্যবহার করে) স্যুইচ করা অন্য 9 টি সংরক্ষণ করবে, প্রথম লাইনটি হয়ে যায় । [0]gsub$*[0]gets.chopp n=$*[0].unpack('B*')[0].to_i(2)
ফিলোমোরি

3

ল্যাবরেথ , 104 103 বাইট

'  )25 }_';:_';_2/;{
''', 6 2 1   1   { (
 ' | / _ _   _}*2_ $
 * _ :!\ }2_\     !:
 652       @'''''''

অনলাইনে চেষ্টা করে দেখুন!

ব্যাখ্যা:

উত্স কোডের রঙিন কোডিং চিত্র

উপরের বাম দিকের বেশিরভাগ প্রাচীরবিহীন অক্ষর (নির্দেশে দেয়াল ফাঁকা স্থান এবং অন্য কোনও অক্ষর অন্তর্ভুক্ত v) থেকে নির্দেশিকা নির্দেশকটি শুরু হয় ।

অরেঞ্জ:

এই লুপটি ASCII কোড হিসাবে একবারে ইনপুটটির একটি অক্ষর পায়, এটি বর্তমান মানটিতে যুক্ত করে এবং বর্তমান মানকে 256 দিয়ে গুণ করে।

  • ' No-op
  • ,পরবর্তী ইনপুট চরের ascii কোডটি স্ট্যাকের শীর্ষে বা E-E-1 চাপান ush এই মুহুর্তে যদি ইনপুট পাওয়া যায়, কোড ডানদিকে ঘুরবে (নীচে সরানো) কারণ স্ট্যাকের শীর্ষটি পটিভ রয়েছে। অন্যথায় এটি বামে পরিণত হবে কারণ স্ট্যাকের শীর্ষটি নেতিবাচক is
  • | স্ট্যাক থেকে উপরের দুটি আইটেমগুলি পপ করুন এবং ফলাফলটিকে কিছুটা ধাক্কা দিন OR।
  • _ শূন্য পুশ
  • 256প্রতিটি অঙ্ক পপ xএবং ধাক্কা দেখা x*10+digit। সুতরাং এটি স্ট্যাকের শীর্ষে 256 পুশ শিরোনামের সাথে মিলিত হয়েছে।
  • *পপ y, পপ x, ধাক্কা x*y। এই মুহুর্তে স্ট্যাকের শীর্ষটি ইতিবাচক হওয়ায় লুপটির চারপাশে চালিয়ে যাওয়ার জন্য কোডটি ডানদিকে ঘুরবে।

নীল:

  • )স্ট্যাকের শীর্ষটি বৃদ্ধি করুন। ইনপুটটির শেষে পৌঁছে গেলে কোডটি স্ট্যাকের একটি -1 দিয়ে এই পয়েন্টে যেতে বাম দিকে ঘুরবে যা শূন্যে বৃদ্ধি পাবে।
  • 256 স্ট্যাক 0 এর শীর্ষটি থাকা আমাদের 256 টি ধাক্কা দিতে দেয়।
  • /পপ y, পপ xপুশ x/y(পূর্ণসংখ্যা বিভাগ)। যেহেতু আমরা প্রতিটি লুপকে 256 দিয়ে ইনপুটটি গুণিত করছিলাম, তাই আমাদের শেষ গুণটি ফিরিয়ে আনতে হবে।
  • : স্ট্যাকের শীর্ষটিকে নকল করুন যাতে আমাদের কাছে পরবর্তী মানটির একটি অনুলিপি থাকে।
  • ! স্ট্যাকের শীর্ষে পপ করুন এবং পূর্ণসংখ্যা মানটি STDOUT এ মুদ্রণ করুন।
  • \ একটি নতুন লাইন মুদ্রণ করুন।
  • _2 স্ট্যাকের শীর্ষে একটি দুটি চাপুন।
  • } সহায়ক স্ট্যাকের শীর্ষে স্ট্যাকের শীর্ষে সরান।

লাল:

এই লুপটি অভ্যন্তরীণ (সবুজ) লুপে গণনা করা একটি নির্দিষ্ট মান সহ এক্সওআর দ্বারা বর্তমান মানের বিটগুলি ফ্লিপ করে। এরপরে এটি বর্তমান মানকে আউটপুট করে এবং বর্তমান মানটি শূন্য হলে প্রোগ্রামটি প্রস্থান করে।

  • _ শূন্য পুশ (নিয়ন্ত্রণ প্রবাহ)।
  • ; স্ট্যাকের উপরের অংশটি বাতিল করুন (নিয়ন্ত্রণ প্রবাহ)।
  • :বর্তমান মানটি সদৃশ করুন। অনুলিপি গণনা করার জন্য অনুলিপিটি ব্যবহার করা হবে।
  • _ শূন্য পুশ (নিয়ন্ত্রণ প্রবাহ)।
  • (সবুজ লুপ)
  • $পপ yপপ xধাক্কা x XOR y
  • :! বর্তমান মানটি সদৃশ করুন এবং পূর্ণসংখ্যার উপস্থাপনা মুদ্রণ করুন।
  • যদি বর্তমান মান 0 হয় তবে আমরা সরাসরি অবিরত @এবং সমাপ্তি।
  • \ একটি নতুন লাইন মুদ্রণ করুন।
  • _2} 2 টিপুন এবং অক্স স্ট্যাকের দিকে যান।
  • _1 1 চাপুন (নিয়ন্ত্রণ প্রবাহ)

সবুজ:

এই লুপটি সেই মানটি গণনা করে যার মাধ্যমে আমাদের বর্তমান মানটি XOR করা দরকার। এটি মূল স্ট্যাকের স্টপটিতে বর্তমান মানটির একটি অনুলিপি 0 পর্যন্ত না পৌঁছানো অবধি আধিকারিক স্ট্যাকের শীর্ষে দ্বিগুণ করার মাধ্যমে এটি করা হয়।

  • _ শূন্য পুশ (নিয়ন্ত্রণ প্রবাহ)।
  • ; বর্তমান নিয়ন্ত্রণ বাতিল করুন যা কেবলমাত্র নিয়ন্ত্রণ প্রবাহ প্রয়োগ করতে ব্যবহৃত হয়।
  • _2 বর্তমান মান অর্ধেক করতে 2 টিপুন।
  • / বিভক্ত করা
  • { অ্যাক্স স্ট্যাকের শীর্ষটিকে মূল স্ট্যাকের শীর্ষে সরান।
  • _2* স্ট্যাকের শীর্ষে দ্বিগুণ
  • } মূল স্ট্যাকের শীর্ষটিকে অ্যাক্স স্ট্যাকের দিকে ফিরে যান।
  • _1 নিয়ন্ত্রণ প্রবাহের জন্য একটি চাপুন।
  • লুপটি প্রস্থান করার পরে:
  • ; এক্সওআর গণনা করা থেকে শূন্যের বাম দিকে বাদ দিন।
  • { গণনা করা XOR প্রধান স্ট্যাকের দিকে সরান Move
  • ( এক্সওআর মান থেকে একটিকে বিয়োগ করুন।

2

পাওয়ারশেল ভি 2 +, 158 বাইট

for($a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)});$a){[convert]::ToInt64($a,2);$a=$a.TrimStart('0')-split0-replace1,0-join1}

হ্যাঁ, সুতরাং, পাওয়ারশেলের ঘাঁটি রূপান্তর করা সত্যই দু: খজনক । এবং আমরা এটি এখানে দুইবার করতে পারি।

ঠিক আছে, সুতরাং এটি কেবলমাত্র একটি forলুপ $a- যেমন, আমরা যতক্ষণ $aবিদ্যমান ততক্ষণ লুপ করব । আমরা অবশেষে একটি খালি স্ট্রিংয়ে পৌঁছব (যা মিথ্যা), যাতে আমরা এভাবেই শেষ করব।

লুপটির সেটআপ $a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)}), ইনপুট নেয় $args[0], এটিকে charঅ্যারে হিসাবে কাস্ট করে এবং প্রতিটি চরিত্রের মধ্য দিয়ে লুপ করে। আমরা [convert]::ToString(int,base)প্রত্যেককে বাইনারি স্ট্রিংয়ে রূপান্তর করতে .NET ব্যবহার করি । তবে এর মধ্যে নেতৃস্থানীয় শূন্যগুলি অন্তর্ভুক্ত নয়, সুতরাং আমাদের সেই স্ট্রিংটিকে একটি হিসাবে পুনরায় কাস্ট করতে হবে [int]এবং এর .ToString() পদ্ধতিটি 8মাস্ক হিসাবে শূন্যগুলির সাথে কল করতে হবে। তারপরে str স্ট্রিংগুলি পেরেনগুলিতে আবদ্ধ হয় এবং -joinএকসাথে এড করা হয়, তারপরে সেভ করা হয় $a

লুপের ভিতরে, আমরা [convert]::ToInt64(string,base)বাইনারি সংখ্যাটিকে দশমিক সংখ্যায় রূপান্তর করি। এটি পাইপলাইনে ছেড়ে যায় এবং লুপটি পুনরায় সেট করার পরে (এবং তাই স্পষ্টভাবে মুদ্রিত হয়) ফ্লাশ করা হয়। পরের অধ্যায় সঞ্চালিত গণনার - আমরা .TrimStart()কোন বসানো শূন্যগুলি মুছে ফেলার জন্য, -split0বিভক্ত করার zeros এবং পেতে, একটি উপর stringএর -array 1এস, -replaceসেই বেশী zeros সঙ্গে, এবং পরিশেষে -joinসঙ্গে অ্যারে ফিরে একসঙ্গে 1গুলি। তারপরে, লুপটি আবার শুরু হয়।

PS C:\Tools\Scripts\golfing> .\count-down-from-infinity.ps1 'PPCG'
1347437383
800046264
273695559
263175352
5260103
3128504
1065799
1031352
17223
15544
839
184
71
56
7
0

2

সিজেম , 17 16 18 বাইট

q256b0{_p2b:!2bj}j

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

q256b   e# read printable ascii to integer
0       e# value for terminal case
{       e# recursive function
  _p    e#   print current number
  2b    e#   create binary representation with no leading zeros
  :!    e#   flip bits
  2b    e#   convert binary back to integer
  j     e#   recursive call
}j      e# end

দ্রষ্টব্য: পুরাতন 16 বাইট সংস্করণ খালি স্ট্রিংয়ের সাথে সঠিকভাবে আচরণ করে নি:

q256b{_p2b:!2b}h

এছাড়াও, ডেনিসকে পরামর্শ দেওয়ার জন্য ধন্যবাদ যে স্ট্যাকের মধ্যে নতুন লাইনে রাখার pচেয়ে 1 বাইট সংরক্ষণ N\করে।


_p2b:!2bএকটি বাইট সংরক্ষণ করে। এছাড়াও, আপনার ব্যবহার করা উচিত l; rযদি ইনপুটটিতে স্পেস থাকে তবে ব্যর্থ হবে।
ডেনিস

@ ডেনিস ধন্যবাদ, যদিও এটি এখন শঙ্কিত করে তোলে যদি খালি স্ট্রিংয়ের সমস্যা হয়।
লিনাস

ঠিক। qখালি স্ট্রিং দিয়ে সঠিকভাবে কাজ করবে।
ডেনিস


1

রেটিনা, 116 বাইট

বাইট গণনাটি আইএসও 8859-1 এনকোডিং ধরেছে। লাইন 5-এ প্রিন্টযোগ্য বাইট রয়েছে। এটা T`\x00-\xFF

-2`
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+
$*
+`(1+)\1
${1}0
01
1


{*(`1
01
+`10
011
^0+

)M`1
^0+

T`01`10

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

দুটি অক্ষরের চেয়ে দীর্ঘতর ইনপুট দিয়ে এটি চেষ্টা করবেন না। (এটি অনলাইনে দোভাষী ব্যবহার করে সময় শেষ করে দেয়) : ডি

দুর্ভাগ্যক্রমে, পিছনে শূন্য এবং লাইনফিড রয়েছে, তবে আমি ঠিক করেছি যে ধরে নিলাম ঠিক আছে কারণ আউটপুটটি এখনও সঠিক।

ব্যাখ্যা

-2`         # Convert ASCII to decimal (ord)
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+         # Decimal to binary
$*
+`(1+)\1
${1}0
01
1


{*(`1       # Loop; Loop print and undo; Convert binary to unary
01
+`10
011
^0+

)M`1        # Unary to decimal; End print and undo
^0+         # Remove leading zeros

T`01`10     # Flip bits; (implicit loop end)

1

রুবি - 70 বাইট

λ cat inf.rb
n,=$*[0].unpack 'B*';loop{p n.to_i(2);n.tr!('10','01').sub!(/^0*/,'')}
λ ruby inf.rb Hello
310939249775
788572378000
310939249775
238816564112
36061342831
32658133904
1701604463
445879184
90991727
43226000
23882863
9671568
7105647
1282960
814191
234384
27759
5008
3183
912
111
16
15
0
inf.rb:1:in `block in <main>': undefined method `sub!' for nil:NilClass (NoMethodError)
        from inf.rb:1:in `loop'
        from inf.rb:1:in `<main>'

প্রোগ্রামটি সম্পন্ন করার পরে একটি ব্যাতিক্রম দিয়ে বেরিয়ে আসে, তবে আমার বোধগম্যতা যে ততক্ষণ ত্রুটি আউটপুটটি STDOUT (যা এটি করে) এর পরিবর্তে STDERR এ যায় ততক্ষণ তা ঠিক।


1

সি, 147 135 133 125 122 121 117 115 103 বাইট

সংরক্ষিত 5 বাইট @ কায়োসকে ধন্যবাদ!

@ কোয়েস এবং @ ক্লেব্ল্যাঙ্ককে ধন্যবাদ 2 বাইট সংরক্ষণ করা!

12 বাইট সংরক্ষণ করেছেন @ সাইলিংক্যাটকে ধন্যবাদ

i,n;main(p,v)char**v;{while(*v[1])i=i*256+*v[1]++;for(;printf("%d\n",n=i),i;i^=p-1)for(p=2;n/=2;)p*=2;}

Ungolfed:

int i;
int main (c,v) {
    char**v;
    while (*v[1]) /* put first command line argument into i as binary */
        i = i*256 + *v[1]++;
    while (i != 0) { 
        printf("%d\n",i);
        int p = 2,n = i;
        while (n /= 2) /* calculate smallest power of 2 > i */
            p *= 2;
        i ^= p - 1; /* flip bits */
    }
}

আমি মনে করি আপনি intঘোষণাগুলি ছেড়ে দিতে পারেন
সাইয়েস

আপনি শেষ whileলুপটিকে একটি forলুপে রূপান্তর করে একটি
বাইটও

আর তুমি পরিবর্তন করতে পারেন while(1)থেকেfor(;;)
Cyoce

@ কয়েস আমি intসর্বত্র ঘোষণাগুলি সরিয়ে দেওয়ার চেষ্টা করেছি এবং gcc -std=89ত্রুটি পেয়েছি । তবে টিপটির জন্য ধন্যবাদ for(;;)। আমি intঘোষণাগুলি সরিয়ে দেওয়ার চেষ্টা চালিয়ে যাব :)))
নুডল 9

দুঃখিত, আমি এটি পরীক্ষা করিনি। আমি মনে করি আপনি এটিকে শীর্ষে স্থানান্তর করলে (এটি i;main(c,v)char**v;{...}) কাজ করবে। এখনই মোবাইলে তাই আমি নিশ্চিত হতে পারি না
সাইয়েস

0

সি, 129 120 117 110 107 105 বাইট

long long i,m,n;f(char*v){for(;*v;i<<=8,i+=*v++);for(;printf("%llu,",i),n=i;i^=m-1)for(m=2;n>>=1;m<<=1);}

পরীক্ষিত

main (int c, char**v) {
    f(v[1]);
}

আউটপুট

5291279215216915577,3932092821637860230,679593196789527673,473328307817319302,103132444486104185,40982743589751686,31074850448176249,4953946570787718,4053252683953273,450346943417222,112603010004089,28134478351238,7049893737593,1746199284614,452823970937,96931842950,40507110521,28212366214,6147372153,2442562438,1852404857,295078790,241792121,26643334,6911097,1477510,619641,428934,95353,35718,29817,2950,1145,902,121,6,1,0,

আমি মনে করি আপনি i=0ঘোষণার ঘোষণায় যেতে পারেন iএবং for
লুপটির

@ কায়স ফাংশনটি যতবার বলা হয় ততবার কাজ করা দরকার এবং যেহেতু iঅন্তর্নিহিত বিশ্বব্যাপী অন্তর্গত প্রতিটি বার চ (...) বলা হয় তখন এটি আরম্ভ করা দরকার।
ক্লাব্ল্যাঙ্ক

@ কিয়েস আপনি ঠিক ছিলেন। iআবার শূন্য না হওয়া পর্যন্ত ফাংশনটি প্রস্থান করে না তাই এটি এখনও পুনরায় ব্যবহারযোগ্য।
ক্লাব্ল্যাঙ্ক


0

সি #, 360 359 বাইট

using w=System.Console;using q=System.Convert;s={System.Func<int,int,string>S=q.ToString;string t="",f="";for(int i=0;i<s.Length;i++)t+=i>0?S(s[i],2).PadLeft(8,'0'):S(s[i],2);w.WriteLine(q.ToInt64(t,2).ToString());while(t!="0"){f="";foreach(var n in t)f+=n=='0'?'1':'0';t=f.TrimStart(new char[]{'0'});t+=t==""?"0":"";w.WriteLine(q.ToInt64(t,2).ToString());}};

সম্পূর্ণ প্রোগ্রাম:

using w = System.Console;
using q = System.Convert;

class a
{
    static void Main()
    {
        System.Action<string> b = s =>
        {
            System.Func<int,int,string> S = q.ToString;
            string t = "", f = ""; // Var does not work here
            for(int i = 0; i < s.Length; i++)
                t += i > 0 ? S(s[i], 2).PadLeft(8, '0') : S(s[i], 2);
            w.WriteLine(q.ToInt64(t, 2).ToString());
            while(t != "0")
            {
                f = "";
                foreach (var n in t) f += n== '0' ? '1' : '0';
                t = f.TrimStart(new char[] { '0' });
                t += t == "" ? "0" : "";
                w.WriteLine(q.ToInt64(t, 2).ToString());
            }
        };

        b("Inf");
        b("Infinity");
        w.Read(); // prevent close in VS
    }
}

আমি সি # করি না, তবে এর পরিবর্তে হতে var t="";var f="";পারে var t="",f=""? 5 বাইট সঞ্চয়
corsiKa

@ কর্সিকা হ্যাঁ আমি চেষ্টা করেছিলাম কিন্তু এটি আমাকে একটি ত্রুটি দিয়েছে, আমার ধারণা এটির স্ট্রিং নয় এবং এর কারণ।
Yodle

প্রকৃতপক্ষে, স্ট্রিং একটি বাইট সংরক্ষণ করে, তাই আমি অনুমান করি যে আমি এটি সেভাবে করব।
Yodle

এছাড়াও আপনি এই দুষ্টু উদ্ধৃতিগুলি সংরক্ষণ করতে শূন্যের জন্য আজ পরিবর্তনশীল করতে পারেন?
corsiKa

কেবল চেষ্টা করেই, এটি আসলে বাইটোকন্ট উত্থাপন করে কারণ আমি "0" এবং চর '0' উভয়ই প্রতিস্থাপন করতে পারি না :(
ইয়ডল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.