निम्नलिखित प्रक्रिया पर विचार करें:

कुछ गैर-नकारात्मक पूर्णांक एन लें।

उदा एन = 571
इसे बिना किसी अग्रणी शून्य के बाइनरी में व्यक्त करें। (शून्य ही एकमात्र अपवाद है, बनना 0।)

जैसे 571= 1000111011बाइनरी में
इस बाइनरी प्रतिनिधित्व में लोगों के लगातार रन और शून्य को तोड़ें।

जैसे 1000111011→ 1, 000, 111, 0,11
सबसे लंबे से सबसे छोटे तक के क्रम को क्रमबद्ध करें।

जैसे 1, 000, 111, 0, 11→ 000, 111, 11, 1,0
बारी के साथ एक समय में सभी अंकों को अधिलेखित 1की और 0की, हमेशा के साथ शुरू 1की।

जैसे 000, 111, 11, 1, 0→ 111, 000, 11, 0,1
एक नया बाइनरी नंबर प्राप्त करने के लिए परिणाम को संक्षिप्त करें।

जैसे 111, 000, 11, 0, 1→ 1110001101= 909दशमलव में

जब आप इस प्रक्रिया द्वारा निर्मित मूल्यों की साजिश करते हैं तो आपको एक बहुत साफ ग्राफ मिलता है:

और यह स्पष्ट रूप से स्पष्ट है कि मैं मंदिर स्काईलाइन अनुक्रम के परिणामस्वरूप अनुक्रम क्यों कह रहा हूं :

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो एक गैर-नकारात्मक पूर्णांक N और प्रिंट में लेता है या संबंधित मंदिर स्काईलाइन अनुक्रम संख्या देता है। आपका इनपुट और आउटपुट दोनों दशमलव में होना चाहिए।

उदाहरण यदि इनपुट 571आउटपुट है तो होना चाहिए 909।

बाइट्स में सबसे छोटा कोड जीतता है।

संदर्भ के लिए, यहां N = 0 से 20 तक के अनुक्रम दिए गए हैं:

यहां 0 से 1023 तक की शर्तें दी गई हैं।

code-golf sequence binary

— केल्विन के शौक
स्रोत

4

पायथ, 20 19 बाइट्स

ACr.BQ8|is*V_SGH2 1

1 बाइट जकूबे द्वारा बचाई गई

परीक्षण सूट

इस तथ्य का उपयोग करता है कि रन-लंबाई-एन्कोडिंग के बाद, रन आउटपुट में वांछित रन हैं।

खो 3 बाइट्स विशेष आवरण 0।

— isaacg
स्रोत

14

CJam, 25 23 22 बाइट्स

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

बस रन-लंबाई एन्कोडिंग का एक सा। -1 @ मार्टिनबटनर को धन्यवाद।

इसे ऑनलाइन / टेस्ट सूट में आज़माएं ।

व्याख्या

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 बाइट्स

मुझे एक बाइट बचाने के लिए @sok का धन्यवाद!

is.em%hk2hb_Sr.BQ8 2

इसे यहाँ ऑनलाइन प्रयास करें ।

— Maltysen
स्रोत

आप .BQइसके बजाय उपयोग कर सकते हैं jQ2, जिसका अर्थ है कि आप 8और पूर्ववर्ती के बीच के स्थान को खो सकते हैं 2।

— सोक

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

संपादन के लिए धन्यवाद! मुझे जल्दी से भागना था, लेकिन जमा करना चाहता था क्योंकि मुझे लगा कि यह एक सुंदर चुनौती थी और पहली बार प्रस्तुत करने के लिए एक अच्छा। मैं शीघ्र ही आपकी अधीनता की जाँच करूंगा!

— एनपेनैक्स

मुझे लगता है कि आप उपयोग sorted(...,key=len)करने के बजाय उपयोग करके कुछ बाइट्स बचा सकते हैं, map(len,...लेकिन मैं अभी आपके कार्यक्रम को पूरी तरह से समझ नहीं पाया हूं, इसलिए मैं सकारात्मक नहीं हूं जो आपको लाभान्वित करेगा।

— कोल

अरे @Cole मैं मैपिंग कर रहा हूं lenक्योंकि यह एकमात्र जानकारी है जिसे मुझे 1 और 0. की मात्रा को दोहराने की आवश्यकता है। मैंने आपके सुझाव की कोशिश की और इसमें 2 बाइट्स शामिल हैं, क्योंकि मुझे lenदो बार उपयोग करना होगा , लेकिन सुझाव के लिए धन्यवाद!

— enpenax

5

जावास्क्रिप्ट ईएस 6, 110 बाइट्स 113 116 119 120

सहेजे गए 3 बाइट @intrepidcoder के लिए धन्यवाद

3 बाइट्स @NinjaBearMonkey के लिए धन्यवाद बचा लिया

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।

— intrepidcoder

@intrepidcoder धन्यवाद, जिसने 3 बाइट्स बचाए!

— डाउनगेट

मैं इसका परीक्षण नहीं कर सकता, लेकिन split(/(0+)/g)इसे बदलने में सक्षम होना चाहिए match(/(.)\1*/g)।

— निंजाबियरनॉकिज

@NinjaBearMonkey धन्यवाद, जिसने 3 बाइट्स बचाए!

— डाउनगेट

एक बाइट की बचत: +(s=0, ... .map(l=>l.replace(/./g,s^=1))...)

— आशा है कि मैं

5

सी ++, 535 527 बाइट्स

(कुछ बाइट्स शेविंग के लिए धन्यवाद zereges।)

अब जब हमने उन बाइट्स से छुटकारा पा लिया, तो कार्यक्रम अब प्रतिस्पर्धात्मक है;)

#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;}

मैं गोल्फ के लिए नया हूं, इसलिए कृपया मुझे टिप्पणियों में कुछ सुझाव दें ।

"आपको उन कोष्ठक की आवश्यकता नहीं है" या "प्रिंट का उपयोग करें" जैसी चीजें सभी सहायक हैं, लेकिन मैं तर्क पर सलाह की भी सराहना करता हूं। अग्रिम में धन्यवाद!

पढ़ने में आसानी के लिए, मैं ungolfed संस्करण प्रस्तुत करता हूं:

#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;

— Zereges

कुछ बाइट्स को बचाया धन्यवाद

— लियाम

forद्वारा अपने पहले लूप को शिफ्ट करें 1, यानी लूप के अंदर for(int i=D;i;i--)उपयोग करें pow(2,i-1)।

— ०६:३६ पर

@LiamNoronha आपने वास्तव में जो कुछ भी सुझाया था उसे बचा नहीं था :)

— ज़ेरेगेस

1

@LiamNoronha इसे देखें । अभी भी सुधार के लिए बहुत जगह है। उदाहरण के पुन: उपयोग चर (परिभाषा बचाता है), onesभी हो सकता है int। शायद मैक्रोइंग 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 बाइट्स

पूर्णांक को दाईं ओर ले जाने का कार्य। सही ढंग से संभालता है ०।

(\:~#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नियमित अभिव्यक्ति मिलान के लिए आवश्यक नहीं है। अपने प्रतिस्थापन में, .चार समूह के बजाय बस का उपयोग करें ।

— simbabque

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))

— Zach गेट्स
स्रोत

के बजाय 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 बाइट्स

( NIM के लिए 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

PPCG में आपका स्वागत है! दुर्भाग्य से मुझे लगता है कि यह कुछ संख्याओं के लिए गलत मान देता है, जैसे कि t(0) = 0कब 1अपेक्षित है और t(4) = 1कब 6 अपेक्षित है

— Sp3000

मंदिर स्काईलाइन अनुक्रम उत्पन्न करें

चुनौती

पायथ, 20 19 बाइट्स

CJam, 25 23 22 बाइट्स

व्याख्या

पायथ - 21 20 बाइट्स

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

जावास्क्रिप्ट ईएस 6, 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 बाइट्स