নিম্নলিখিত প্রক্রিয়াটি বিবেচনা করুন:

কিছু অ-নেতিবাচক পূর্ণসংখ্যা এন নিন।

যেমন এন = 571
কোনও অগ্রণী শূন্যের সাথে এটি বাইনারিতে প্রকাশ করুন। (জিরো নিজেই একমাত্র ব্যতিক্রম, হয়ে উঠছে 0))

যেমন 571= 1000111011বাইনারি মধ্যে
এই বাইনারি উপস্থাপনায় টানা এক রান এবং শূন্য বিরতি।

যেমন 1000111011→ 1, 000, 111, 0,11
দীর্ঘতম থেকে সংক্ষিপ্ততম পর্যন্ত রানগুলি সাজান।

যেমন 1, 000, 111, 0, 11→ 000, 111, 11, 1,0
সর্বদা 'গুলি' এর সাথে শুরু করে বিকল্পের 1এবং এর দিয়ে প্রতিটি রানের সমস্ত অঙ্কগুলি ওভাররাইট করুন ।01

যেমন 000, 111, 11, 1, 0→ 111, 000, 11, 0,1
নতুন বাইনারি নম্বর পেতে ফলাফলটি কনটেনেট করুন।

যেমন 111, 000, 11, 0, 1→ 1110001101= 909দশমিক মধ্যে

আপনি যখন এই প্রক্রিয়া দ্বারা উত্পাদিত মানগুলি প্লট করেন আপনি একটি সুন্দর ঝরঝরে গ্রাফ পাবেন:

এবং এটি আশাকরি স্পষ্ট যে কেন আমি ফলস্বরূপ ক্রমটিকে মন্দিরের স্কাইলাইন অনুক্রম বলছি :

চ্যালেঞ্জ

একটি প্রোগ্রাম বা ফাংশন লিখুন যা একটি অ-নেতিবাচক পূর্ণসংখ্যক এন নেবে এবং এটি সম্পর্কিত টেম্পল স্কাইলাইন সিকোয়েন্স নম্বর মুদ্রণ করে বা প্রদান করে। আপনার ইনপুট এবং আউটপুট উভয় দশমিক হওয়া উচিত।

যেমন ইনপুট 571হলে আউটপুট হওয়া উচিত 909।

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

রেফারেন্সের জন্য, এখানে এন = 0 থেকে 20 পর্যন্ত ক্রমের শর্তাদি রয়েছে:

এখানে 0 থেকে 1023 পর্যন্ত পদ রয়েছে।

code-golf sequence binary

— ক্যালভিনের শখ
সূত্র

4

পাইথ, 20 19 বাইট

ACr.BQ8|is*V_SGH2 1

1 বাইট জাকুবে সংরক্ষণ করেছেন

পরীক্ষা স্যুট

রান-লেংথ-এনকোডিংয়ের পরে, রানগুলি আউটপুটটিতে কাঙ্ক্ষিত রান হয় Uses

3 বাইট বিশেষ কেসিং 0 হারিয়েছেন।

— isaacg
সূত্র

14

সিজেম, 25 23 22 বাইট

ri1e>2be`z($W%a\+ze~2b

রান-লেংথের কিছুটা এনকোডিং। -১ @ মার্টিনব্যাটনারকে ধন্যবাদ।

এটি অনলাইন / টেস্ট স্যুটটি ব্যবহার করে দেখুন ।

ব্যাখ্যা

ri        Read n from input as int
1e>       Take max with 1 (special case for n = 0)
2b        Convert n to binary
e`        Run length encode
z         Zip, giving a pair [<counts> <10101.. array>]
($W%      Drop the counts array and sort decending
a\+z      Add it back to the 10101.. array and re-zip
e~        Run length decode
2b        Convert from binary

— Sp3000
সূত্র

11

পাইথ - 21 20 বাইট

আমাকে এক বাইট বাঁচানোর জন্য @ এসোককে ধন্যবাদ!

is.em%hk2hb_Sr.BQ8 2

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

— Maltysen
সূত্র

আপনি এর .BQপরিবর্তে ব্যবহার করতে পারেন jQ2, যার অর্থ আপনি 8আগের এবং পূর্ববর্তীগুলির মধ্যে স্থান হারাতে পারেন 2।

— Sok

is*R`s=!Z_ShMr.BQ8 2একটি আকর্ষণীয় একই দৈর্ঘ্যের সমাধান। বেশিরভাগ পোস্ট করা কারণ আমি সত্যিই কাজের মানচিত্রের যুক্তিতে নির্ধারিত কাজটি আশা করি না।

— FryAmTheEggman

1

প্রতিস্থাপন @FryAmTheEggman `sসঙ্গে ]। একটি বাইট সংরক্ষণ করুন।

— জাকুব

6

পাইথন 2, 121 125 বাইট

121: 4 বাইট বন্ধ শেভ করার জন্য Sp3000 ধন্যবাদ!

import re;print int("".join(n*`~i%2`for i,n in enumerate(sorted(map(len,re.split('(1*|0+)',bin(input())[2:])))[::-1])),2)

125

import re;print int("".join("10"[i%2]*n for i,n in enumerate(sorted(map(len,re.split('(1*|0+)',bin(input())[2:])))[::-1])),2)

— enpenax
সূত্র

1

নিস! আমি আপনার কাছে কি করতে পারেন বিশ্বাস n*`~i%2`forপরিবর্তে"10"[i%2]*n for

— Sp3000

সম্পাদনার জন্য ধন্যবাদ! আমাকে দ্রুত ছুটে যেতে হয়েছিল তবে জমা দিতে চেয়েছিলাম কারণ আমি ভেবেছিলাম এটি একটি সুন্দর চ্যালেঞ্জ এবং প্রথম জমা দেওয়ার জন্য এটি একটি ভাল one আমি শীঘ্রই আপনার জমাটি পরীক্ষা করে দেখব!

— এনপেনেক্স

আমি মনে করি আপনি ব্যবহারের sorted(...,key=len)পরিবর্তে কিছু বাইট সংরক্ষণ করতে পারবেন map(len,...তবে আমি এখনই আপনার প্রোগ্রামটি পুরোপুরি বুঝতে পারছি না তাই আমি ইতিবাচক নই যা আপনার উপকারে আসবে।

— কোল

আরে @ কোল আমি ম্যাপিং করছি lenকারণ এটিই কেবলমাত্র 1 এবং 0 এর পরিমাণ প্রতিলিপি করার প্রয়োজন আমার তথ্যটি আমি চেষ্টা করেছি এবং এটিতে 2 বাইট যুক্ত করা হয়েছে, কারণ আমাকে lenতখন দু'বার ব্যবহার করতে হবে , তবে পরামর্শের জন্য ধন্যবাদ!

— এনপেনাক্স

5

জাভাস্ক্রিপ্ট ES6, 110 বাইট 113 116 119 120

@Intrepidcoder ধন্যবাদ 3 বাইট সংরক্ষণ করা

@ নিনজাবিয়ারমনকিকে 3 বাইট সংরক্ষণ করা হয়েছে

n=>+('0b'+n.toString(2).split(/(0+)/).sort((b,a)=>a.length-b.length).map((l,i)=>l.replace(/./g,i-1&1)).join``)

সরাসরি এগিয়ে যোগাযোগ বাছাই ফাংশনটির দৈর্ঘ্যটি পছন্দ করবেন না তবে আমি এটি গল্ফ করার কোনও উপায় সম্পর্কে ভাবতে পারি না।

— Downgoat
সূত্র

আমি মনে করি আপনি এর +পরিবর্তে একটি ব্যবহার করতে পারেন eval।

— ইন্ট্রিপিডকোডার

@ সিন্ট্রেপিডকোডার ধন্যবাদ, এটি 3 বাইট সংরক্ষণ করেছে!

— ডাউনগোট

আমি এটি পরীক্ষা করতে পারি না, তবে split(/(0+)/g)প্রতিস্থাপন করতে সক্ষম হওয়া উচিত match(/(.)\1*/g)।

— নিনজাবিয়ারমোনকি

@ নিনজাবিয়ারমনিকে ধন্যবাদ, 3 বাইট সেভ করেছে!

— ডাউনওয়েট

একটি বাইট সংরক্ষণ করা: +(s=0, ... .map(l=>l.replace(/./g,s^=1))...)

— আশা করি

5

সি ++, 535 527 বাইট

(কিছু বাইট ছাঁটাই করার জন্য ধন্যবাদ জেরেজস।)

এখন আমরা সেই বাইটগুলি থেকে মুক্তি পেয়েছি প্রোগ্রামটি এখন প্রতিযোগিতামূলক;)

#include<iostream>
#include<cmath>
int main(){int I,D;std::cin>>I;while(I>int(pow(2,D))){D++;}int L[99];int X=0;int Z=0;int O=0;for(int i=D-1;i>=0;i--){if( int(pow(2,i))&I){if(Z>0){L[X]=Z;Z=0; X++;}O++;}else{if(O>0){L[X] = O;O=0;X++;}Z++;}}if(Z>0){L[X]=Z;Z=0;X++;}if(O>0){L[X]=O;O=0;X++;}int P=0;bool B = true;int W = D-1;for(int j=0;j<X;j++){int K=0;int mX=0;for(int i=0;i<X;i++){if(L[i]>K){K=L[i];mX=i;}}L[mX]=0;if(B){for(int k=0;k<K;k++){P+=int(pow(2,W));W--;}}else{for(int k=0;k<K;k++){W--;}}B^=1;}std::cout<<P;return 0;}

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

"আপনার সেই ব্র্যাকেটের দরকার নেই" বা "প্রিন্টফ ব্যবহার করুন" এর মতো বিষয়গুলি সমস্ত সহায়ক, তবে আমি যুক্তির পরামর্শেরও প্রশংসা করি। আগাম ধন্যবাদ!

পড়ার স্বাচ্ছন্দ্যের জন্য, আমি অসম্পূর্ণ সংস্করণটি উপস্থাপন করছি:

#include<iostream>
#include<cmath>
int main()
{
int input,digits;

std::cin>>input;
while(input > int(pow(2,digits))){digits++;}

int list[99];
int index=0;
int zCounter=0;
int oCounter=0;

for(int i=digits;i>0;i--)
{
    if( int(pow(2,i-1))&input)
    {
        if(zCounter>0)
        {
            list[index] = zCounter;
            zCounter=0;
            index++;
        }
        oCounter++;
    }
    else
    {
        if(oCounter>0)
        {
            list[index] = oCounter;
            oCounter=0;
            index++;
        }
        zCounter++;
    }
}
if(zCounter>0)
{
        list[index] = zCounter;
        zCounter=0;
        index++;
}
if(oCounter>0)
{
        list[index] = oCounter;
        oCounter=0;
        index++;
}

int output = 0;
bool ones = true;
int power = digits-1;
for(int j=0;j<index;j++)
{
    int max=0;
    int mIndex=0;
    for(int i=0;i<index;i++)
    {
        if(list[i]>max){max=list[i];mIndex=i;}
    }
    list[mIndex]=0;

    if(ones)
    {
        for(int k=0;k<max;k++)
        {
            output+=int(pow(2,power));
            power--;
        }
    }
    else
    {
        for(int k=0;k<max;k++)
        {
            power--;
        }
    }
    ones^=1;

}
std::cout<<output;
return 0;
}

সম্পাদনা golfed সংস্করণ নিচে আনা একটি দম্পতি বাইট, ungolfed সংস্করণ অপরিবর্তিত

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

আপনি পরিবর্তে int a; int b;ব্যবহার করতে পারেন int a,b;। এছাড়াও গ্লোবাল স্কোপে ভেরিয়েবলগুলি দিয়ে শুরু করা হয় 0। এছাড়াও যখন কেবলমাত্র একটি কমান্ড কার্যকর করতে হয় তখন আপনাকে কুঁকড়ানো বন্ধনী ব্যবহার করতে হবে না। এছাড়াও ones=!ones;সরলীকৃত করা যেতে পারেones ^= 1;

— জেরেজেস

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

— লিয়াম

আপনার প্রথম forলুপটি শিফট করুন 1, for(int i=D;i;i--)এবং pow(2,i-1)লুপের অভ্যন্তরে ব্যবহার করুন।

— নিমি

@ লিয়ামনোরোনহা আপনি যা প্রস্তাব করেছিলেন তা আপনি আসলে সংরক্ষণ করেননি :)

— জেরেজেস

1

@LiamNoronha এটি ব্যবহার করে দেখুন । উন্নতির জন্য এখনও অনেক জায়গা আছে। যেমন পুনঃব্যবহার ভেরিয়েবল (সংজ্ঞা সংরক্ষণ), onesএছাড়াও হতে পারে int। হয়তো macroing int(pow(i))মধ্যে P(i)। আমি আপনাকে এখানে

— জেরেজেস

2

হাস্কেল, 132 131 বাইট

import Data.List
g 0=[]
g n=mod n 2:g(div n 2)
q=[1]:[0]:q
f=foldl((+).(2*))0.concat.zipWith(<*)q.sortOn((-)0.length).group.g.max 1

ব্যবহারের উদাহরণ:

> map f [0..20]
[1,1,2,3,6,5,6,7,14,13,10,13,12,13,14,15,30,29,26,25,26]

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

                 max 1         -- fix n=0: f(0) is the same as f(1)
               g               -- turn into binary, i.e. list of 0s and 1s
            group              -- group sequences of equal elements
         sortOn((-)0.length)   -- sort groups on negative length
      zipWith(<*)q             -- map each element in a group to constant 1 or 0 by turns
   concat                      -- flatten all groups into a single list
foldl((+).(2*))0               -- convert back to decimal

— nimi
সূত্র

2

জে - 30 বাইট

ডানদিকে পূর্ণসংখ্যা গ্রহণ করা ফাংশন। সঠিকভাবে 0 পরিচালনা করে।

(\:~#2|#\)@(#;.1~1,2~:/\])&.#:

#: - বাইনারি উপস্থাপনা নিন।
1,2~:/\]- প্রতিটি অঙ্কের মধ্যে, সত্য যদি তারা আলাদা হয় তবে প্রতিবেদন করুন । একটি সত্য প্রস্তুত করুন যাতে প্রতিটি "রান" শুরুর সাথে তালিকায় সত্য থাকে।
(#;.1~...) - উপরে বুলিয়ান ভেক্টর ব্যবহার করে প্রতিটি রানের দৈর্ঘ্য নিন।
\:~ - এই দৈর্ঘ্যকে দীর্ঘ থেকে সংক্ষিপ্ততম পর্যন্ত সাজান।
2|#\- 1 0 1 0 ...দৈর্ঘ্যের তালিকার যতক্ষণ বিকল্পের একটি তালিকা নিন ।
(...#...) - বামে প্রতিটি সংখ্যার জন্য (সাজানো দৈর্ঘ্য), ডানদিকে সংযুক্ত আইটেমের অনেকগুলি নিয়ে যান (1 এবং 0 এর বিকল্প)
&. - এই নতুন বাইনারি উপস্থাপনাটিকে একটি সংখ্যায় ফিরিয়ে দিন।

উদাহরণ:

   (\:~#2|#\)@(#;.1~1,2~:/\])&.#: 571
909
   i.21   NB. zero to twenty
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
   (\:~#2|#\)@(#;.1~1,2~:/\])&.#: every i.21   NB. apply separately to every number
1 1 2 3 6 5 6 7 14 13 10 13 12 13 14 15 30 29 26 25 26

— algorithmshark
সূত্র

2

পার্ল 5.10, 121 101

say oct"0b".join'',map{$|=1-$|;$_=~s/./$|/gr}sort{length$b<=>length$a}(sprintf"%b",shift)=~/(0*|1*)/g

আমি মনে করি সাজানোর অংশটি ছোট হতে পারে।

সম্পাদনা করুন: -20 বাইট, প্রতীককে ধন্যবাদ!

— ল্যাপোশাú আকসা
সূত্র

আপনি এ থেকে মুক্তি পেতে পারেন \nএবং mনিয়মিত প্রকাশের মিলের জন্য এটি প্রয়োজন হয় না। আপনার বিকল্পে, .চর গ্রুপের পরিবর্তে কেবল ব্যবহার করুন।

— সিমবাচক

grepঅংশও প্রয়োজন নেই । octঝরঝরে যদিও :) হল

— simbabque

আপনাকে ধন্যবাদ, আমি ঘটনাক্রমে মূল অংশগুলি থেকে সেগুলি ছেড়ে দিয়েছি।

— ল্যাপোশাসা আকাশ

1

পাইথন 3, 146 136 বাইট

import re;print(int(''.join(len(j)*'01'[i%2<1]for i,j in enumerate(sorted(re.findall('1+|0+',bin(int(input()))[2:]),key=len)[::-1])),2))

— জ্যাচ গেটস
সূত্র

বরং mapক lambda, এর সাথে কি করা ভাল ''.join(... for ... in ...)?

— Sp3000

1

গণিত, 83 বাইট

Flatten[0#+(d=1-d)&/@SortBy[d=0;Split[#~IntegerDigits~2],-Length@#&]]~FromDigits~2&

এটি একটি নামবিহীন ফাংশন সংজ্ঞায়িত করে।

— মার্টিন ইন্ডার
সূত্র

0

রুবি, 107 104 102 বাইট

( নিমিকে ধন্যবাদ 3 বাইট সংরক্ষণ করা হয়েছে )

সিজেমের পছন্দগুলিকে পরাজিত করতে যাচ্ছি না, তবে বুদ্ধিমান ভাষার জন্য আমি এটি বেশ ছোট পেয়েছি।

p gets.to_i.to_s(2).scan(/((.)\2*)/).map{|e|e[i=0].size}.sort.reverse.map{|e|"#{i=1-i}"*e}.join.to_i 2

— মনিকা iamnotmaynard পুনরায় ইনস্টল করুন
সূত্র

কিছু বাইট সংরক্ষণ করতে হবে: (i+=1)%2হয় i=1-i।

— নিমি

@ নিমি আহ, আপনাকে ধন্যবাদ আমি কীভাবে এটি সংক্ষিপ্ত করব তা বোঝার চেষ্টা করছিলাম।

— মনিকা iamnotmaynard

0

জাভা 8, 179 176 বাইট

(x)->{int g[]=new int[32],h=0,i=highestOneBit(x);g[0]=1;while(i>1)g[((x&i)>0)^((x&(i>>=1))>0)?++h:h]++;sort(g);for(i=32,h=0;g[--i]>0;)while(g[i]-->0)h=h<<1|i%2;return x<1?1:h;}

আমি দুটি স্থিতিশীল আমদানি ব্যবহার করেছি: java.util.Integer.highestOneBitএবং java.util.Arrays.sort।

পঠনযোগ্যতার জন্য, এখানে কোডটি নিরবচ্ছিন্নভাবে দেওয়া হয়েছে:

java.util.function.ToIntFunction<Integer> f = (x) -> {
  int g[] = new int[32], h = 0, i = java.util.Integer.highestOneBit(x);
  g[0] = 1;
  while (i > 1) {
    g[((x & i) > 0) ^ ((x & (i >>= 1)) > 0) ? ++h : h]++;
  }
  java.util.Arrays.sort(g);
  for (i = 32, h = 0; g[--i] > 0;) {
    while (g[i]-- > 0) {
      h = h << 1 | i % 2;
    }
  }
  return x < 1 ? 1 : h; // handle zero
};

— অলিভিয়ার গ্রাগোয়ার
সূত্র

-1

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

def t(n):
  from itertools import groupby;lst=sorted([''.join(g) for n,g in groupby(bin(n)[2:])],key=len)[::-1];s=''
  for i in lst:s+=str(i)
  return int(s,2)

— ত্রিস্তান ব্যাচলার
সূত্র

4

পিপিসিজিতে আপনাকে স্বাগতম! দুর্ভাগ্যক্রমে আমি মনে করি এটি কিছু সংখ্যার জন্য ভুল মান দেয়, যেমন t(0) = 0কখন 1প্রত্যাশিত এবং t(4) = 1কখন প্রত্যাশিত

— Sp3000

মন্দিরের স্কাইলাইন সিকোয়েন্স তৈরি করুন

চ্যালেঞ্জ

পাইথ, 20 19 বাইট

সিজেম, 25 23 22 বাইট

ব্যাখ্যা

পাইথ - 21 20 বাইট

পাইথন 2, 121 125 বাইট

জাভাস্ক্রিপ্ট ES6, 110 বাইট 113 116 119 120

সি ++, 535 527 বাইট

হাস্কেল, 132 131 বাইট

জে - 30 বাইট

পার্ল 5.10, 121 101

পাইথন 3, 146 136 বাইট

গণিত, 83 বাইট

রুবি, 107 104 102 বাইট

জাভা 8, 179 176 বাইট

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