30

এই দ্বারা অনুপ্রাণিত হয় অ পুনরায় বাইনারি - সমস্যা 13 এর এইচপি CodeWars 'সাম্প্রতিক প্রতিযোগিতা।

আসুন, একটি এলোমেলো দশমিক সংখ্যা নেওয়া যাক

727429805944311

এবং এর বাইনারি উপস্থাপনা দেখুন:

10100101011001011111110011001011101010110111110111

এখন সেই বাইনারি উপস্থাপনাটিকে উপ-বিভাগগুলিতে ভাগ করুন যেখানে অঙ্কগুলি 0এবং 1বিকল্প রয়েছে।

1010 010101 10 0101 1 1 1 1 1 10 01 10 0101 1 1010101 101 1 1 1 101 1 1

এবং প্রতিটি অনুবর্তন দশমিক মধ্যে ফিরে রূপান্তর।

10 21 2 5 1 1 1 1 1 2 1 2 5 1 85 5 1 1 1 5 1 1

কাজটি

ইনপুট হিসাবে একটি একক, ধনাত্মক পূর্ণসংখ্যা নিন এবং উপরের প্রক্রিয়া দ্বারা প্রাপ্ত ধনাত্মক পূর্ণসংখ্যার ক্রম আউটপুট নিন।

বিস্তারিত

ইনপুট এবং আউটপুট অবশ্যই দশমিক বা অবিচ্ছিন্ন থাকতে হবে।
আউটপুট নম্বরগুলি অবশ্যই একটি বোধগম্য, মানব-পঠনযোগ্য ফ্যাশনে পৃথক করা উচিত এবং সেগুলি অবশ্যই দশমিক বা একরকম হতে হবে। সাদা স্থানের কোনও বাধা নেই। বৈধ আউটপুট শৈলী: [1,2,3], 1 2 3, 1\n2\n3যেখানে \nআক্ষরিক নতুন লাইন, ইত্যাদি হয়

পরীক্ষার মামলা

 Input | Output
     0 | 0
     1 | 1
     2 | 2
     3 | 1 1
     4 | 2 0
     5 | 5
     6 | 1 2
     7 | 1 1 1
     8 | 2 0 0
     9 | 2 1
    10 | 10
    50 | 1 2 2
   100 | 1 2 2 0
  1000 | 1 1 1 1 10 0 0
 10000 | 2 1 1 2 0 2 0 0 0
 12914 | 1 2 2 1 1 2 2
371017 | 5 42 10 2 1

অতিরিক্ত দ্রষ্টব্য: আউটপুটে সমস্ত সংখ্যা ফর্মের (2^k-1)/3বা হওয়া উচিত 2*(2^k-1)/3। এটি 0 1 2 5 10 21, 42, 85, 170, ..., যা ওইআইএস- এ A000975 75

— এল'ইনিয়া স্টারম্যান
সূত্র

@ ডিজিটালট্রামা: হুমম ...... না, আমি মনে করি না এটি চ্যালেঞ্জের চেতনার মধ্যে রয়েছে।

— এল'েন্ডিয়া স্টারম্যান

ঠিক আছে. |tacতারপর আমার উত্তর থাকবে :)

— ডিজিটাল ট্রমা

11

পাইথ, 17 16 বাইট

জাকুবে 1 বাইট ধন্যবাদ

iR2cJ.BQx1qVJ+dJ

প্রদর্শন

একটি দুর্দান্ত, চতুর সমাধান। Pyth মত কিছু কম পরিচিত বৈশিষ্ট্য ব্যবহার x<int><list>এবং c<str><list>।

iR2cJ.BQx1qVJ+dJ
                    Q = eval(input())
    J.BQ            Store in J the input in binary.
          qV        Vectorize equality function over
            J+dJ    J and J with a leading dummy char, to get the offset right.
                    This calculates whether each element matches its successor.
        x1          Find all of the indexes of 1 (True) in this list.
   cJ                Chop J at those locations.
iR2                  Convert from binary back to base ten and output.

— isaacg
সূত্র

1

আপনি tJদ্বারা প্রতিস্থাপন যদি আপনি +dJঅপসারণ করতে পারেন hM।

— জাকুবে

@ জাকুব সুন্দর!

— isaacg

7

গণিত, 47 বাইট

#+##&~Fold~#&/@#~IntegerDigits~2~Split~Unequal&

Ungolfed:

FromDigits[#,2]&/@Split[IntegerDigits[#,2],Unequal]&

Split[list,f]একাধিক তালিকায় একটি তালিকা বিভক্ত করে aএবং biff এর মধ্যে অবস্থানটি না ভঙ্গ f[a,b]করে True।

FromDigits[n,2] => Fold[#+##&,n]আলেফালফার একটি ঝরঝরে টিপ is

— feersum
সূত্র

7

পাইথন, 86 বাইট

যেহেতু আমি পাইথের মধ্যে মারাত্মকভাবে ছড়িয়ে পড়েছি, পাইথনে এটি আবার করা যাক।

import re
lambda n:[int(s,2)for s in re.sub("(?<=(.))(?=\\1)"," ",bin(n)[2:]).split()]

এখানে চেষ্টা করুন!

ব্যাখ্যা

আমরা ইনপুট নম্বরটিকে nবাইনারি স্ট্রিংয়ে রূপান্তর করে শুরু করি । bin(n)[2:]যে যত্ন নেয়। bin()বিন্যাসে স্ট্রিংটি ফেরত দেওয়ার পরে আমাদের এই স্ট্রিংয়ের প্রথম 2 টি অক্ষর ফেলে দিতে হবে 0b10101।
পরবর্তী আমাদের উপসর্গগুলির সীমানা চিহ্নিত করতে হবে। (?<=(.))(?=\1)বাম এবং ডানদিকে একই সংখ্যা রয়েছে এমন স্ট্রিংয়ের শূন্য-দৈর্ঘ্যের অবস্থানগুলির সাথে মেলে এমন রেজেক্সের সাহায্যে এটি করা যেতে পারে ।
সমস্ত অনুচ্ছেদের একটি তালিকা পাওয়ার সুস্পষ্ট re.split()উপায়টি হ'ল কোনও নির্দিষ্ট রেজেক্সের উপর একটি স্ট্রিং বিভক্ত হওয়া ব্যবহার করা হবে । দুর্ভাগ্যক্রমে এই ফাংশনটি শূন্য দৈর্ঘ্যের ম্যাচের জন্য কাজ করে না। তবে ভাগ্যক্রমে এটি re.sub()হয়, সুতরাং আমরা কেবল শূন্য দৈর্ঘ্যের ম্যাচগুলিকে ফাঁকা জায়গাগুলির সাথে প্রতিস্থাপন করি এবং তার পরে স্ট্রিংগুলিকে বিভক্ত করি।
তারপরে আমাদের কেবলমাত্র সেই সমস্ত উপসংখ্যাকে দশমিক সংখ্যায় আবার পার্স int(s,2)করতে হবে এবং সম্পন্ন হয়েছে।

— Denker
সূত্র

4

জেলি, 12 বাইট

BI¬-ẋż@BFṣ-Ḅ

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

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

BI¬-ẋż@BFṣ-Ḅ  Main link. Argument: n

B             Convert n to base 2.
 I            Compute the increments, i.e., the differences of consecutive digits.
  ¬           Apply logical NOT.
   -ẋ         Repeat -1 that many times, for the logical NOT of each difference.
              [0, 0] / [1, 1] ->   0    -> 1 -> [-1]
              [0, 1] / [1, 0] -> 1 / -1 -> 0 -> []
       B      Yield n in base 2.
     ż@       Zip the result to the right with the result to the left.
        F     Flatten the resulting list of pairs.
         ṣ-   Split at occurrences of -1.
           Ḅ  Convert each chunk from base 2 to integer.

— ডেনিস
সূত্র

অবশ্যই 12 টি অক্ষর তবে 20 বাইট। বা আপনি CHAR_BIT >> 8 দিয়ে একটি সিস্টেম ব্যবহার করছেন?

— জেমস ইয়ংম্যান

1

@ জামেস ইয়ংম্যান জেলি ডিফল্টরূপে ইউটিএফ -8 ব্যবহার করে না। আসলে, এটির নিজস্ব কোড পৃষ্ঠা রয়েছে যা 256 টি অক্ষরের প্রতিটি এনকোড করে এটি প্রতিটি একক বাইট হিসাবে বোঝে।

— ডেনিস

4

বাশ + জিএনইউ ইউটিলিটিস, ৫১

dc -e2o?p|sed -r ':;s/(.)\1/\1 \1/;t'|dc -e2i?f|tac

এসটিডিআইএন থেকে নেওয়া ইনপুট।

dc -e2o?p STDIN থেকে ইনপুট পূর্ণসংখ্যা পড়ে এবং একটি বেস 2 স্ট্রিং আউটপুট করে
sed -r ':;s/(.)\1/\1 \1/;t' বেস 2 স্ট্রিংকে স্পেস দিয়ে স্পেস করে যেখানেই সেখানে একই ধারাবাহিক অঙ্ক রয়েছে
dc -e2i?fএকসাথে বিভক্ত বাইনারি পড়ে, প্রতিটি অংশ স্ট্যাকের উপর রেখে, তারপর fপুরো dcস্ট্যাকটি ফেলে দেয় (বিপরীত ক্রমে আউটপুট সংখ্যা) ...
... যা দ্বারা সংশোধন করা হয় tac।

— ডিজিটাল ট্রমা
সূত্র

4

জাভাস্ক্রিপ্ট (ES6) 58 62 63

1 বাইট সংরক্ষণ করা THX @ETH প্রোডাকশনগুলি সম্পাদনা করুন

4 বাইট সম্পাদনা করুন thx @ নীল

x=>x.toString(2).replace(/((.)(?!\2))*./g,x=>'0b'+x-0+' ')

f=x=>x.toString(2).replace(/((.)(?!\2))*./g,x=>'0b'+x-0+' ')

 
console.log=x=>O.textContent+=x+'\n'

;[
[     0,'0'],
[     1,'1'],
[     2,'2'],
[     3,'1 1'],
[     4,'2 0'],
[     5,'5'],
[     6,'1 2'],
[     7,'1 1 1'],
[     8,'2 0 0'],
[     9,'2 1'],
[    10,'10'],
[    50,'1 2 2'],
[   100,'1 2 2 0'],
[  1000,'1 1 1 1 10 0 0'],
[ 10000,'2 1 1 2 0 2 0 0 0'],
[ 12914,'1 2 2 1 1 2 2'],
[371017,'5 42 10 2 1']
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i)
  console.log(i+' -> '+r+(r.trim()==k.trim() ? ' ok':'ko (should be '+k+')'))
})

<pre id=O></pre>

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

আপনি কি রেজেক্সের সাহায্যে দুটি বাইট বাঁচাতে পারবেন /(01)*0?|(10)*1?/g, বা এই গোলমাল কিছু হবে ??

— ইটিএইচ প্রডাকশনগুলি

1

এছাড়াও, আমি মনে করি আপনি x=>'0b'+x-0+' 'বাইট সংরক্ষণ করতে পারেন ।

— ইটিএইচ প্রডাকশনগুলি

@ এথ প্রডাকশনগুলি আমি সংক্ষিপ্ত রেজিপ্স্প চেষ্টা করেছি, কোনও ভাল নেই :( অন্য ইঙ্গিতটির জন্য

— থেক্স

লিডবোর্ড বলছে আপনার কাছে 1 টি বাইট উত্তর রয়েছে। আমি ধরে নিলাম কারণ এটি আপনার পরিবর্তে পুরানো নম্বর ()৩) এর আগে সংখ্যার ()২) নম্বর রয়েছে।

— কাইল কানোজ

আমি মনে করি রেজেক্স /((.)(?!\2))*./gআপনাকে একটি দুর্দান্ত 4 বাইট সংরক্ষণ করবে।

— নীল

3

পাইথ, 26 বাইট

iR2c:.BQ"(?<=(.))(?=\\1)"d

এখানে চেষ্টা করুন!

ব্যাখ্যা

iR2c: .BQ "(? <= (।)) (? = \\ 1)" ডি # কিউ = ইনপুট নম্বর

     .বিকিউ # ইনপুটটিকে বাইনারি রূপান্তর করুন
    : "(?? = (())) (? = \\ 1)" ডি # উপগতির মধ্যে একটি সাদা স্থান pোকান?
   সাদা # স্পেসে সি # বিভক্ত স্ট্রিং
আইআর 2 # প্রতিটি অনুচ্ছেদে দশমিক হিসাবে রূপান্তর করে

যেহেতু পাইথনের স্প্লিট () ফাংশন শূন্য দৈর্ঘ্যের ম্যাচে বিভক্ত হয় না, তাই আমাকে সেই ম্যাচগুলিকে একটি স্পেস দিয়ে প্রতিস্থাপন করতে হবে এবং ফলাফলটি বিভক্ত করতে হবে।

— Denker
সূত্র

3

পাইথ, 22 21 বাইট

&Qu?q%G2H&
GH+yGHjQ2Z

অনলাইনে চেষ্টা করুন: বিক্ষোভ

সত্যই পাইথের এক ক্লান্তিকর কাজ।

ব্যাখ্যা:

&Qu?q%G2H&\nGH+yGHjQ2Z   implicit: Q = input number
                  jQ2    convert Q to base 2
  u               jQ2Z   reduce ^: for each digit H update the variable G=0:
   ?q%G2H                   if G%2 == H:
          \nG                  print G
         &   H                 then update G with H
              +yGH           else: update G with 2*G+H
  u                      print the last G also
&Q                       handle Q=0 special: only print 0 once

— Jakube
সূত্র

3

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

কোড:

b2FNð«N«Dð-s:}ð¡)C

ব্যাখ্যা:

b                   # Convert input to binary
 2F          }      # Do the following twice ( with N as range variable)
   Nð«N«            #    N + space + N
        D           #    Duplicate this
         ð-         #    Delete spaces from the duplicate string
           s        #    Swap the top two elements
            :       #    Replace the first string with the second
              ð¡    # Split on spaces
                )   # Wrap into an array
                 C  # Convert all element back to decimal

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

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

— আদনান
সূত্র

3

এমএটিএল , 18 17 বাইট

YBTyd~Thhfd1wY{ZB

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

YB      % input number. Convert to binary string
T       % push true value
y       % duplicate binary string and push it at the top of the stack
d~      % true for each value that equals the previous one
T       % push true value
hh      % concatenate: true, indices, true
f       % find indices of true values
d       % consecutive differences: lenghts of alternating sequences
1wY{    % split binary string according to those lengths
ZB      % convert each substring into decimal number

— লুইস মেন্ডো
সূত্র

3

zsh, 67 63 55 বাইট

for i in `grep -oP '1?(01)*0?'<<<$[[##2]$1]`;<<<$[2#$i]

কেন জানি না, তবে এটি বাশে কাজ করে না।

ডেনিসকে 8 বাইটের জন্য ধন্যবাদ !

— ডোরকনব
সূত্র

এটি forসিনট্যাক্স। ... দাঁড়াও, forএস না?

— ক্যালকুলেটরফ্লাইন

বাশের পাটিগণিতের বিস্তৃতি আপনাকে আউটপুট বেস নির্দিষ্ট করতে দেয় না। এক্সার্গস থেকে মুক্তি পেতে, আপনি এটি ব্যবহার করতে পারেন for i in `grep -oP '1?(01)*0?'<<<$[[##2]$1]`;<<<$[2#$i]।

— ডেনিস

2

পিএইচপি, 171 168 162 160 158 121 120 131 124 118 116 113 112 বাইট

function d($i){for(;$d<$l=strlen($b=decbin($i));){$c.=$u=$b[$d];echo$u==$b[++$d]||$d==$l?bindec($c).$c=" ":"";}}

বিস্তারিত দেখুন

function d($i) {
  for ( ; $d < $l = strlen($b = decbin($i)); ) {
    $c .= $u = $b[$d];
    echo $u == $b[++$d] || $d == $l ? bindec($c) . $c = " "
                                    : "";
  }
}

ব্যবহার করুন d(int)এবং আপনি অফ, আউটপুট একটি স্পেস দ্বারা পৃথক s এর একটি echoএড স্ট্রিং int।

সম্পাদনা:
-৩: কলটিতে $bসংজ্ঞা স্থানান্তরিত strlen()।
-6:$c ইনস্ট্যান্টেশন সরানো ।
-২: অবশেষে কনকনেটেশন ইস্যুটি ঠিক করে।
-2: একক-লাইনের জন্য কোনও বন্ধনী নেই for()।
-37: মোট ওভারহল। Arrayপুনরাবৃত্তি Array-> String-> Arrayকলগুলির পরিবর্তে চুনকলেটগুলি নিয়ে যাচ্ছেন ।
-1: স্নিগ্ধ $cপুনরায় সেট।
+11: বাগফিক্স। অনুপস্থিত ছিল চূড়ান্ত খণ্ড। আর না.
-7: আদৌ ইনস্ট্যান্ট $dকরার দরকার নেই ? খুশী হলাম।
-6: return -> echo।
-2: ক্রাঞ্চিং $c।
-3:টার্নারি, আমার প্রথম ভালবাসা।
-1: লুক্কায়িত লুক্কায়িত $u।

— ricdesi
সূত্র

আমার মনে হয় আপনি 2 বাইট সংরক্ষণ করতে পারেন: function d($i){for(;$d<$l=strlen($b=decbin($i));print$u==$b[++$d]||$d==$l?bindec($c).$c=" ":"")$c.=$u=$b[$d];}।

— ব্ল্যাকহোল

2

উত্তল 0.2+, 25 বাইট

উত্তল হ'ল একটি নতুন ভাষা যা আমি বিকাশ করছি যা সিজেএম এবং গল্ফস্ক্রিপ্টের উপর ভিত্তি করে তৈরি। দোভাষী এবং আইডিই এখানে পাওয়া যাবে । কমান্ড লাইন আর্গুমেন্টগুলির মধ্যে ইনপুট একটি পূর্ণসংখ্যা। এটি সিপি -1222 এনকোডিং ব্যবহার করে।

2bs®(?<=(.))(?=\\1)"ö2fbp

ব্যাখ্যা:

2bs                         Convert to binary string
   ®(?<=(.))(?=\\1)"        Regex literal
                    ö       Split string on regex
                     2fb    Convert each split string into decimal integer
                        p   Print resulting array

— GamrCorps
সূত্র

2

জাভা 8, 127 119 বাইট

l->new java.util.ArrayList<Long>(){{for(String s:l.toBinaryString(l).split("(?<=(.))(?=\\1)"))add(l.parseLong(s,2));}};

স্ট্রিংটি বিভক্ত করার জন্য সম্ভবত আরও ভাল নিয়মিত অভিব্যক্তি রয়েছে। আমি রেজেক্সে দক্ষ নই, তবে আমি পরীক্ষা চালিয়ে যাব।

-8 বাইটস @ ফ্রাইআমডেজিগম্যানকে ধন্যবাদ জানায়

— টিঅ্যান্ডটি
সূত্র

2

এপিএল (এপিএল) , 21 25 বাইট

এখন 0 পাশাপাশি পরিচালনা করে।

{0::0⋄2⊥¨⍵⊂⍨1,2=/⍵}2⊥⍣¯1⊢

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

2⊥⍣¯1⊢ প্রয়োজনীয় হিসাবে অনেক বিট ব্যবহার করে বেস -২ তে রূপান্তর করুন (লিটার। বিভ্যাস-বেস -২ থেকে রূপান্তর)

{… } নিম্নলিখিত বেনামী ফাংশন প্রয়োগ করুন

0:: যদি কোনও ত্রুটি ঘটে:

0 ফিরে 0

⋄ এখন চেষ্টা করুন:

2=/⍵ যুক্তিযুক্ত যুক্তিযুক্ত সমতা (এক 0 দৈর্ঘ্যের -0 বাইনারি উপস্থাপনা ব্যর্থ হবে)

1, প্রিপেন্ড 1

⍵⊂⍨ যুক্তিটি বিভাজন করতে এটি ব্যবহার করুন (প্রতিটি 1 তে নতুন বিভাগ শুরু হয়)

2⊥¨ বেস -২ থেকে প্রতিটি রূপান্তর করুন

— আদম
সূত্র

1

⊂এখানে সত্যিই দরকারী। আমি জেলি এটি যোগ করা উচিত।

— ডেনিস

@ ডেনিস দুটি সংস্করণ সম্পর্কে সচেতন হন R←X⊂Y: ⎕ML<3(অর্থাত ডায়ালগ স্টাইল) দিয়ে এক্স এর প্রতিটি 1 এর সাথে এক্সের পরবর্তী 1 এর আগে (বা এক্স এর শেষ উপাদান) হওয়ার পূর্বে একটি নতুন পার্টিশন শুরু হয় আর এর ধারাবাহিক আইটেম ⎕ML=3(অর্থাত্ আইবিএম শৈলী) দিয়ে, এক্সের সাথে সম্পর্কিত উপাদান পূর্ববর্তীটির চেয়ে বেশি হলে ফলাফলটিতে নতুন পার্টিশন শুরু করা হয়। এক্স এর সাথে 0 এর সাথে সম্পর্কিত ওয়াইয়ের আইটেমগুলি ফলাফলের অন্তর্ভুক্ত নয়। সুতরাং ⎕ML←1 ⋄ 1 0 0 1 0 1 1 ⊂ ⍳7সমান ⎕ML←3⋄ 4 3 2 4 4 5 7 ⊂ ⍳7`

— অ্যাডাম

2

জাপট , 7 বাইট

¤ò¥ mn2

এটা পরীক্ষা করো

ব্যাখ্যা

¤ò¥ mn2
           :Implicit input of integer U.
¤          :Convert to binary string.
 ò¥        :Split to an array by checking for equality.
    m      :Map over array.
     n2    :Convert to base-10 integer.

— রোমশ
সূত্র

1

পাইথন 3, 115 বাইট

def f(s):
 s=bin(s);r=[s[2]]
 for i in s[3:]:
  if i==r[-1][-1]:r+=[i]
  else:r[-1]+=i
 return[int(x,2)for x in r]

ব্যাখ্যা

def f(s):
 s=bin(s)                   # convert input in binary
 r=[s[2]]                   # initialize the result with the first char after the 'b' in binary string
 for i in s[3:]:            # loop on other element
  if i==r[-1][-1]:          # if the last element of the last string equal the current element 
   r+=[i]                   # we add the current element in a new string
  else:
   r[-1]+=i                 # we add the current element to the last sting
 return[int(x,2)for x in r] # convert binary string in integer

ফলাফল

>>> [print(i,f(i)) for i in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 50, 100, 1000, 10000, 12914, 371017]]
0 [0]
1 [1]
2 [2]
3 [1, 1]
4 [2, 0]
5 [5]
6 [1, 2]
7 [1, 1, 1]
8 [2, 0, 0]
9 [2, 1]
10 [10]
50 [1, 2, 2]
100 [1, 2, 2, 0]
1000 [1, 1, 1, 1, 10, 0, 0]
10000 [2, 1, 1, 2, 0, 2, 0, 0, 0]
12914 [1, 2, 2, 1, 1, 2, 2]
371017 [5, 42, 10, 2, 1]

পূর্ববর্তী সমাধান (118 বাইট)

def f(s):
 s=bin(s);r=s[2]
 for i in s[3:]:
  if i==r[-1]:r+='a'+i
  else:r+=i
 return[int(x,2)for x in r.split('a')]

— Erwan
সূত্র

1

হাস্কেল, 147 , 145 বাইট

x%[]=[x]
x%(y:z)|or.(zipWith(==)<*>tail)$y:x=x:[]%(y:z)|1<2=(y:x)%z
b x|x<2=[x]|1<2=b(div x 2)++[mod x 2]
map(sum.zipWith((*).(2^))[0..]).([]%).b

map(sum.zipWith((*).(2^))[0..]).([]%).b একটি নামবিহীন ফাংশন যা তালিকার গণনা করে।

কম গল্ফড:

alternating :: Eq a => [a] -> Bool
alternating = or . (zipWith (==) <*> tail)

-- (%) is the partitioning function
(%) :: Eq a => [a] -> [a] -> [[a]]
x % [] = [x]

x % (y:z) | alternating (y : x) = x : [] % (y:z)
          | otherwise = (y : x) % z

bits :: Integral t => t -> [t]
bits x | x < 2     = [x] 
       | otherwise = bits (div x 2) ++ [mod x 2]

unBits :: Num c => [c] -> c
unBits = sum . zipWith ((*) . (2^)) [0..]

f :: Integer -> [Integer]
f = map unBits . ([]%) . bits

— মাইকেল ক্লিন
সূত্র

1

পার্ল, 53 বাইট

এর জন্য +1 অন্তর্ভুক্ত -p

STDIN এ নম্বরটি দিয়ে চালান

perl -p alterbits.pl <<< 371017

alterbits.pl:

$_=sprintf"0b%b",$_;s/(.)\K(?=\1)/ 0b/g;s/\S+/$&/eeg

— টন হসপেল
সূত্র

1

পাওয়ারশেল, 103 বাইট

[regex]::Matches([convert]::ToString($args[0],2),"(01)+0?|(10)+1?|.").Value|%{[convert]::toint32($_,2)}

যেহেতু আমি রেজেক্সে ভয়ঙ্কর, তাই আমি edc65 এর উত্তর হিসাবে একই অভিব্যক্তিটি ব্যবহার করছি ।

সম্পূর্ণ লম্বা .NET বাইনারি / থেকে রূপান্তর করতে কল করে এবং রেজেক্স ম্যাচগুলি পাওয়ার জন্য .NET কল করে একেবারে ধ্বংস হয়ে গেছে। নাহলে বেশ সোজা। ইনপুট নেয় $args[0], convertএটি বাইনারি করে, এটিকে ফিড দেয় Matches, ফলস্বর গ্রহণ করে .Value, একটি লুপের মাধ্যমে সেগুলি পাইপ করে |%{...}এবং convertসেই মানগুলি ফিরে ফেরায়int । আউটপুটটি পাইপলাইনে ফেলে রাখা হয়েছে এবং স্পষ্টভাবে নিউলাইনগুলি দিয়ে মুদ্রিত হয়েছে।

অতিরিক্ত creditণের জন্য - একটি (বেশিরভাগ) 126 বাইটে নন-রেজেক্স সংস্করণ

$l,$r=[char[]][convert]::ToString($args[0],2);$l+-join($r|%{(" $_",$_)[$l-bxor$_];$l=$_})-split' '|%{[convert]::toint32($_,2)}

আমরা আবার ইনপুট $args[0]এবং convertএটি বাইনারি নিতে । আমরা চর-অ্যারে হিসাবে পুনরায় কাস্ট করেছি, প্রথম অক্ষরটি $lএবং বাকী অক্ষরগুলিকে মধ্যে সংরক্ষণ করছি $r। তারপরে আমরা $rএকটি লুপের মাধ্যমে প্রেরণ করি |%{...}যেখানে প্রতিটি পুনরাবৃত্তির মাধ্যমে আমরা কোনও স্থান দিয়ে প্রবর্তিত অক্ষর বা কেবল অক্ষর থেকে বাাইনারি জোরের ফলাফলের উপর নির্ভর করে নির্বাচন করি with$l এবং তারপরে সেট করি$l অক্ষরের সমান । এটি কার্যকরভাবে নিশ্চিত করে যে আমাদের যদি পর পর দু'বার একই চরিত্র থাকে তবে আমরা তাদের মধ্যে একটি স্পেস রেখে দেই।

লুপের আউটপুট -joinএকসাথে এড করা হয় এবং প্রথম চরিত্রের সাথে যুক্ত হয় $l, তারপরে -splitস্পেসে (যা প্রযুক্তিগতভাবে একটি রেজেক্স, তবে আমি এটি গণনা করছি না)। এরপরে আমরা রেজিেক্স উত্তর convertএবং আউটপুট পূর্ণসংখ্যার মতো একই লুপটি করি ।

— AdmBorkBork
সূত্র

1

জাভা 345 বাইট

package com.ji.golf;
import java.util.regex.*;
public class Decompose {
  public static String decompose(long l) {
    String o="";
    String s=Long.toBinaryString(l);
    Matcher m=Pattern.compile("(01)+(0)?|(10)+(1)?|(1)|(0)").matcher(s);
    while(m.find()){String c=s.substring(m.start(),m.end());o+=Integer.parseInt(c, 2)+" ";}
    return o;
  }
}

পরীক্ষা

package com.ji.golf;
public class DecompseTest {
  public static void main(String[] args) {
    String[] inOut = new String[]{
        "0,0",
        "1,1",
        "2,2",
        "3,1 1",
        "4,2 0",
        "5,5",
        "6,1 2",
        "7,1 1 1",
        "8,2 0 0",
        "9,2 1",
        "10,10",
        "50,1 2 2",
        "100,1 2 2 0",
        "1000,1 1 1 1 10 0 0",
        "10000,2 1 1 2 0 2 0 0 0",
        "12914,1 2 2 1 1 2 2",
        "371017,5 42 10 2 1"
    };
    for (String s : inOut) {
      String[] io = s.split(",");
      String result = Decompose.decompose(Long.parseLong(io[0]));
      System.out.println("in: " + io[0] + ", reusult: [" +  result.trim() + "], validates? " + result.trim().equals(io[1].trim()));
    }
  }
}

আউটপুট

in: 0, reusult: [0], validates? true
in: 1, reusult: [1], validates? true
in: 2, reusult: [2], validates? true
in: 3, reusult: [1 1], validates? true
in: 4, reusult: [2 0], validates? true
in: 5, reusult: [5], validates? true
in: 6, reusult: [1 2], validates? true
in: 7, reusult: [1 1 1], validates? true
in: 8, reusult: [2 0 0], validates? true
in: 9, reusult: [2 1], validates? true
in: 10, reusult: [10], validates? true
in: 50, reusult: [1 2 2], validates? true
in: 100, reusult: [1 2 2 0], validates? true
in: 1000, reusult: [1 1 1 1 10 0 0], validates? true
in: 10000, reusult: [2 1 1 2 0 2 0 0 0], validates? true
in: 12914, reusult: [1 2 2 1 1 2 2], validates? true
in: 371017, reusult: [5 42 10 2 1], validates? true

— জেফ আই
সূত্র

4

প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ স্বাগতম! যেহেতু এটি একটি কোড-গল্ফ প্রতিযোগিতা, তাই আপনার কোডটি যতটা সম্ভব সংক্ষিপ্ত করা উচিত। জাভাতে গল্ফ করার জন্য এখানে কিছু টিপস। আপনি বয়লারপ্লেট ছাড়াই আপনার ফাংশনটি সংজ্ঞায়িত করে packageএবং class, এবং অপ্রয়োজনীয় সাদা স্থান সরিয়ে শুরু করতে পারেন । যদি আপনার কোন প্রশ্ন থাকে তাহলে আমার জানতে দিন!

— অ্যালেক্স এ।

1

জুলিয়া, 70 57 বাইট

n->map(i->parse(Int,i,2),split(bin(n),r"(?<=(.))(?=\1)"))

এটি একটি বেনামে ফাংশন যা একটি পূর্ণসংখ্যা গ্রহণ করে এবং পূর্ণসংখ্যার অ্যারে প্রদান করে। এটি কল করতে, এটি একটি ভেরিয়েবলের জন্য বরাদ্দ করুন।

এখানে অ্যাপ্রোচটি ডেনকারএফির চমৎকার পাইথন উত্তরের মতো । আমরা nব্যবহারের বাইনারি উপস্থাপনা পাই bin(n)এবং নিয়মিত প্রকাশের সমস্ত ম্যাচে ফলাফল স্ট্রিংকে বিভক্ত করি (?<=(.))(?=\1)। এটি আসলে একটি শূন্য দৈর্ঘ্যের ম্যাচ; (?<=(.))এটি একটি ইতিবাচক চেহারা যা কোনও একক অক্ষরকে খুঁজে পায় এবং (?=\1)এটি ইতিবাচক চেহারা যা মিলনীয় চরিত্রটি লুকের পিছনে খুঁজে পায়। এটি এমন জায়গাগুলির অবস্থান নির্ধারণ করে যেখানে বাইনারি উপস্থাপনায় একটি নম্বর নিজের দ্বারা অনুসরণ করা হয়। শুধু parseএকটি পূর্ণসংখ্যা হিসাবে প্রতিটি বেস 2 ব্যবহারে mapএবং voila!

— অ্যালেক্স এ।
সূত্র

1

সি, 137 129 বাইট

main(){unsigned long a,b=scanf("%lu",&a),c=!!a;while(a>=b*2)b*=2;while(b)b/=2,c=c*(~(a^a/2)&b|!b?!printf("%lu\n",c):2)+!!(a&b);}

ইনপুট এবং আউটপুট মানক স্ট্রিমগুলিতে রয়েছে।

— শিয়াল
সূত্র

আমি মনে করি না যে আপনার এটি প্রয়োজন puts, যদিও এটি ব্যবহার করা অপ্রীতিকর হবে, তবে চশমাটির জন্য একটি নতুন লাইনের প্রয়োজন নেই।

— FryAmTheEggman

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

— ফক্স

1

জে , 16 বাইট

#:#.;.1~1,2=/\#:

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

ব্যাখ্যা

#:#.;.1~1,2=/\#:  Input: integer n
              #:  Convert from decimal to list of binary digits
          2  \    For each overlapping sublist of size 2
           =/       Reduce using equals
        1,        Prepend 1
#:                Binary digits
    ;.1~          Partition those binary digits at the 1s in the previous list
  #.                Convert each partition from a list of binary digits to decimal

— মাইল
সূত্র

1

q / kdb +, 52 বাইট

সমাধান:

{2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}

উদাহরণ:

q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}0
,0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}1
,1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}3
1 1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}8
2 0 0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}10000
2 1 1 2 0 2 0 0 0
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}12914
1 2 2 1 1 2 2
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}371017
5 42 10 2 1
q){2 sv'cut[0,(&)(~)differ a]a:(63^(*)(&)a)_a:0b vs x}727429805944311
10 21 2 5 1 1 1 1 1 2 1 2 5 1 85 5 1 1 1 5 1 1

ব্যাখ্যা:

q ডান থেকে বাম ব্যাখ্যা করা হয়।

বাইনারিগুলিতে ইনপুট কাস্ট করুন, শীর্ষস্থানীয় শূন্যগুলি ছাঁটাই করুন, সূচকগুলি যেখানে আলাদা হবে তা সন্ধান করুন যেখানে এই সূচকগুলিতে একই, বিভাজন তালিকা, বেস -10 এ ফিরে রূপান্তর করুন। এপিএল সমাধানের তুলনায় কিছুটা ভারী মনে হচ্ছে যদিও ...

{2 sv'cut[0,where not differ a]a:(63^first where a)_a:0b vs x} / ungolfed solution
{                                                            } / lambda function
      cut[                    ]                                / cut a list at indices, cut[indices]list
                                                      0b vs x  / converts to 64bit binary representation
                                                    a:         / save as a
                                                   _           / drop 'n' elements from a
                                 (                )            / evaluate this
                                     first where a             / returns first occurance of true in list a
                                  63^                          / fill result with 63 if null (to handle input of 0)
                               a:                              / save as a, we've stripped off all the left-most 0s
                      differ a                                 / whether or not item in list a is different to previous
                  not                                          / the inversion of this result
            where                                              / these are the points where we have 00 or 11
          0,                                                   / add the first index too!
  2 sv'                                                        / 2 sv converts binary back to base-10, ' for each list

— streetster
সূত্র

0

পিএইচপি, 147

$b=decbin($argv[1]);$a=[$t=$b[0]];$k=0;for($i=1;$i<strlen($b);$i++){$v=$b[$i];if($v==$t)$k++;$t=$v;$a[$k].=$v;}foreach($a as$c)echo bindec($c).' ';

আউটপুট শেষে তাদের অতিরিক্ত কোনও স্পেস রাখতে হবে কারণ এগুলির কোনও বাধা নেই। শর্ট কোডিংয়ের জন্য বিজ্ঞপ্তিগুলি প্রদর্শিত হয়।

উদার সংস্করণ

$n=$argv[1];
$b=decbin($n);
$l=strlen($b);
$t=$b[0];
$a=[0=>$t];$k=0;
for($i=1;$i<$l;$i++){
    $v=$b[$i];
    if($v==$t){
        $k++;
    }
    $t=$v;$a[$k].=$v;    
}
foreach($a as $c){
    echo bindec($c).' ';
}

— kuldeep.kamboj
সূত্র

0

রেটিনা, 60

+`(1+)\1
$1a
a1
1
(?<=(.))(?=\1)
¶
+`1(a*)\b
a$.1$*1;
a

;
1

এটি অনলাইন চেষ্টা করুন! অথবা সমস্ত পরীক্ষার ক্ষেত্রে (দশমিক I / O সহ) সামান্য পরিবর্তিত সংস্করণ ব্যবহার করে দেখুন ।

দুর্ভাগ্যক্রমে, শূন্য দৈর্ঘ্যের ম্যাচগুলির দুটি "পক্ষ" আছে বলে মনে হয়, তৃতীয় স্তর থেকে রেজেক্সের সাথে ব্যবহৃত হলে সদৃশ হয়। যদিও শুধুমাত্র এক বাইট ব্যয় হয়।

আনারি হিসাবে ইনপুট নেয়, অ্যানারি হিসাবে আউটপুট দেয়। অ্যানারি মানগুলিতে / আউট আলাদা ব্যবহার সম্পর্কে সত্যই নিশ্চিত নয়, তবে এটি 4 বাইট সংরক্ষণ করতে পারে।

— FryAmTheEggman
সূত্র

0

জেলি , 9 বাইট (প্রতিযোগী নয়?)

BI¬0;œṗBḄ

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

— এরিক দ্য আউটগল্ফার
সূত্র

বাইনারিগুলি বিকল্প সাবকোয়েন্সগুলিতে বিভক্ত করুন

কাজটি

বিস্তারিত

পরীক্ষার মামলা

পাইথ, 17 16 বাইট

গণিত, 47 বাইট

পাইথন, 86 বাইট

ব্যাখ্যা

জেলি, 12 বাইট

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

বাশ + জিএনইউ ইউটিলিটিস, ৫১

জাভাস্ক্রিপ্ট (ES6) 58 62 63

পাইথ, 26 বাইট

ব্যাখ্যা

পাইথ, 22 21 বাইট

ব্যাখ্যা:

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

এমএটিএল , 18 17 বাইট

zsh, 67 63 55 বাইট

পিএইচপি, 171 168 162 160 158 121 120 131 124 118 116 113 112 বাইট

উত্তল 0.2+, 25 বাইট

জাভা 8, 127 119 বাইট

এপিএল (এপিএল) , 21 25 বাইট

জাপট , 7 বাইট

ব্যাখ্যা

পাইথন 3, 115 বাইট

ব্যাখ্যা

ফলাফল

হাস্কেল, 147 , 145 বাইট

পার্ল, 53 বাইট

পাওয়ারশেল, 103 বাইট

অতিরিক্ত creditণের জন্য - একটি (বেশিরভাগ) 126 বাইটে নন-রেজেক্স সংস্করণ

জাভা 345 বাইট

পরীক্ষা

আউটপুট

জুলিয়া, 70 57 বাইট

সি, 137 129 বাইট

জে , 16 বাইট

ব্যাখ্যা

q / kdb +, 52 বাইট

পিএইচপি, 147

রেটিনা, 60

জেলি , 9 বাইট (প্রতিযোগী নয়?)