पुनरावर्ती बाइनरी विवरण

हाल ही में, मैंने A049064 के अनुक्रम के लिए B- फ़ाइल को बढ़ाकर और जोड़कर OEIS में अपना पहला योगदान दिया । अनुक्रम के साथ शुरू होता है 0, और फिर अगले मान अंतिम आइटम के "बाइनरी विवरण" देने से प्राप्त होते हैं।

उदाहरण के लिए, दूसरा शब्द होगा 10, क्योंकि 0पहले तत्व में एक था । तीसरा पद होगा 1110, क्योंकि एक 1और एक था 0। चौथा होगा 11110। क्योंकि तीन ( 11बाइनरी में!) 1 और एक हैं 0। नीचे इस प्रक्रिया को स्पष्ट करने के लिए पाँचवें कार्यकाल का टूटना है:

> 11110
> 1111 0    (split into groups of each number)
> 4*1 1*0   (get count of each number in each group)
> 100*1 1*0 (convert counts to binary)
> 100110    (join each group back together)

और यहां 6 वें से 7 वें कार्यकाल तक जाने के लिए एक उदाहरण है:

> 1110010110
> 111 00 1 0 11 0
> 3*1 2*0 1*1 1*0 2*1 1*0
> 11*1 10*0 1*1 1*0 10*1 1*0
> 111100111010110

आप एक संदर्भ कार्यक्रम की जांच कर सकते ^φ मैं शब्दों की गणना करने के लिए किया।

आपका काम

आपको एक प्रोग्राम या फ़ंक्शन बनाने की ज़रूरत है जो मानक इनपुट या फ़ंक्शन तर्कों केn माध्यम से एक संख्या में लेता है , और एक नई रेखा द्वारा अलग किए गए शब्द से अनुक्रम तक शब्द प्रिंट करता है । यदि आप निम्न संख्याओं पर एक नज़र डालना चाहते हैं, तो आप OEIS पृष्ठ से b- फ़ाइल का संदर्भ ले सकते हैं। हालाँकि, आपके प्रोग्राम / फंक्शन को 31 वें कार्यकाल तक समर्थन करना चाहिए । यह कोई छोटी उपलब्धि नहीं है, के रूप में 140,000 से अधिक अंक लंबा है ^δ । यदि आप यह देखना चाहते हैं कि 31 वां कार्यकाल क्या होना चाहिए, तो मैंने इसे पास्टबिन में डाल दिया है ।1st(n+1)th0 <= n <= 30A049064(30)

उदाहरण I / O

func(10)
0
10
1110
11110
100110
1110010110
111100111010110
100110011110111010110
1110010110010011011110111010110
1111001110101100111001011010011011110111010110
1001100111101110101100111100111010110111001011010011011110111010110

func(0)
0

func(3)
0
10
1110
11110

केवल एक नियम है: कोई मानक कमियां नहीं!

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट गिनती जीतती है।

^{can - गिस्ट यहां पाया जा सकता है , और एक आइडोन डेमो यहां है ।}

^{case - जिस स्थिति में आप सोच रहे थे, 100 वें कार्यकाल की लंबाई के बारे में मेरे अनुमानों ने इसे लगभग 3.28x10 ²⁵⁰ वर्णों तक लंबा कर दिया, जो किसी के लिए भी गणना के लिए काफी होगा।}

code-golf

— Kade
स्रोत

सूची के अनुसार आउटपुट की अनुमति है? जैसे[0]\n[1, 0]\n[1, 1, 1, 0]\n...

— जकुबे

@Jakube नहीं, आपको इस पर एक स्ट्रिंग जॉइन करने की आवश्यकता होगी।

— काडे

5

OEIS में योगदान देने के लिए बधाई!

— एलेक्स ए।

8

CJam, 18 17 बाइट्स

0{sN1$e`2af.b}ri*

एक बाइट को बंद करने के लिए @ मार्टिनबटनर को धन्यवाद!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

0                 e# Push 0.
 {           }ri* e# Repeat int(input)) times:
  s               e#   Stringify the element on top of the stack.
                       EXAMPLE: [[[1 1] '1] [[1] '0]] -> "11110"
   N              e#   Push a linefeed.
    1$            e#   Copy the last stack.
      e`          e#   Perform run-length encoding.
                  e#   EXAMPLE: "100110" -> [[1 '1] [2 '0] [2 '1] [1 '0]]
        2a        e#   Push [2].
          f.b     e#   For each pair [x 'y], execute: [x 'y][2].b
                  e#   This pushes [x2b 'y], where b is base conversion.

— डेनिस
स्रोत

4

पायथ, 18 17 बाइट्स

J]0VQjk~JsjR2srJ8

इसे ऑनलाइन आज़माएँ: प्रदर्शन

एक बाइट बचाने के लिए @isaacg को धन्यवाद।

स्पष्टीकरण:

                     implicit: Q = input number
 ]0                  create an initial list [0]
J                    and store in J
   VQ                for loop, repeat Q times:
              rJ8       run-length-encoding of J
             s          sum, unfolds lists
          jR2           convert each value to base 2
         s              sum, unfolds lists
       ~J               store the result in J

                        but return the old list,
     jk                 join it and print it

यह इस तथ्य का उपयोग करता है, कि बाइनरी में 0 और 1 भी 0 और 1 हैं।

— Jakube
स्रोत

यह 1 बाइट के Vबजाय का उपयोग करके छोटा है .u:J]0VQjk~JsjR2srJ8

— isaacg

2

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

from itertools import*
v='0'
exec"print v;v=''.join(bin(len(list(g)))[2:]+k for k,g in groupby(v));"*-~input()

एक अनावश्यक intकॉल को हटाकर @ Sp3000 और 5 बाइट्स के लिए 1 बाइट धन्यवाद ।

पुराना संस्करण:

import itertools as t
v='0'
exec"print v;v=''.join(bin(int(len(list(g))))[2:]+k for k,g in t.groupby(v));"*-~input()

कई को बचाया, कई बाइट्स @ Vioz- को धन्यवाद!

मूल संस्करण:

import itertools as t
v='0'
for n in range(input()+1):print v;v=''.join(bin(int(len(list(g))))[2:]+k for k,g in t.groupby(v))

— kirbyfan64sos
स्रोत

1

रूबी, 80 72 69 बाइट्स

एक समारोह के रूप में:

f=->m{l=?0;0.upto(m){puts l;l.gsub!(/1+|0+/){$&.size.to_s(2)+$&[0]}}}

उदाहरण के लिए इसे कॉल करें: f[6]

— daniero
स्रोत

यदि आप फ़ंक्शन तर्क के रूप में इनपुट लेते हैं तो आप कुछ बाइट्स बचा सकते हैं:->m{l=?0;0.upto(m){puts l;l.gsub!(/1+|0+/){$&.size.to_s(2)+$&[0]}}}

— blutorange

@blutorange अच्छा लगा! के बारे में पूरी तरह से भूल गया uptoऔर ! - धन्यवाद :)

— daniero

1

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

import re
o='0'
exec"print o;o=''.join(bin(len(x))[2:]+x[0]for x in re.findall('0+|1+',o));"*-~input()

किसी भी तरह से itertoolsलंबे समय तक होने reऔर वस्तुओं को groupbyवापस करने के संयोजन का grouperमतलब है कि रेगेक्स का उपयोग करना थोड़ा कम है ...

— Sp3000
स्रोत

0

कोबरा - 128

do(i)=if(i-=1,(r=RegularExpressions).Regex.replace(f(i),'1+|0+',do(m=r.Match())=Convert.toString('[m]'.length,2)+'[m]'[:1]),'0')

— Οurous
स्रोत

0

हास्केल, 136 130 बाइट्स

import Text.Printf
import Data.List
f n=putStr.unlines.take(n+1).iterate(concatMap(\n->(printf"%b"$length n)++[head n]).group)$"0"

— आंख-morpork
स्रोत