22

एक सकारात्मक पूर्णांक को देखते हुए n >= 1, nनिम्न संरचना की पहली पंक्तियों को आउटपुट करें :

   #
  # #
  ###
 #   #
 # # #
 ## ##
 #####
#     #
#  #  #
# # # #
# ### #
##   ##
## # ##
### ###
#######

nमई 1-अनुक्रमित पंक्ति के द्विआधारी प्रतिनिधित्व है n, के साथ पिछले चरित्र को कॉपी किए बिना नजर आता, #1 के स्थान पर और <space>0. सभी पंक्तियों के स्थान पर केंद्रित कर रहे हैं।

आपको ASCII- कला के रूप में आउटपुट करना चाहिए, लेकिन आप #उदाहरण के लिए मेरे द्वारा उपयोग किए जाने वाले किसी भी गैर-व्हाट्सएप चरित्र का उपयोग कर सकते हैं । अनुगामी व्हाट्सएप की अनुमति है, और एक अनुगामी न्यूलाइन की अनुमति है। आउटपुट को उदाहरण की तरह देखना चाहिए, और कोई अतिरिक्त प्रमुख व्हाट्सएप या अग्रणी नई सूची नहीं।

आप भग्न गिरजाघर की पहली 1023 पंक्तियों को यहाँ देख सकते हैं ।

बड़े परीक्षण मामलों को उत्पन्न करने के लिए, यहां पायथन में एक अनियंत्रित संदर्भ कार्यान्वयन है

— HyperNeutrino
स्रोत

अछा सुझाव। मैंने द्विआधारी संख्या का अनुमान नहीं लगाया होगा कि इस तरह की सुंदर कला का उत्पादन किया गया है।

— जोनाह

@ जोना धन्यवाद :) खुशी है कि आप इसे पसंद करते हैं

— हाइपरनेट्रिनो

7

दोनों लिंक उत्पन्न कैथेड्रल की ओर इशारा कर रहे हैं।

— ओट्टोवियो

@ ओटवियो: मैं ठीक करूँगा, धन्यवाद

— हाइपरनेट्रो

6

MATL , 10 बाइट्स

:B2&Zv35*c

इसे ऑनलाइन आज़माएं!

व्याख्या

:      % Implicitly input n. Push range [1 2 ... n]
B      % Convert to binary. Gives a matrix where each row corresponds to
       % a number. Rows have left-padding zeros if needed
2      % Push 2
&Zv    % Symmetrize along sepecified dimension (2nd means horizontally),
       % without repeating the last element
35*    % Multiply by 35 (ASCII code for '#')
c      % Convert to char. Char 0 is shown as space. Implicitly display

— लुइस मेंडो
स्रोत

1

मुझे आश्चर्य है कि अगर यह किसी प्रकार के बिलिन को जोड़ने में सहायक होगा जो 35 से गुणा करने के लिए मेल खाता है तो चार में परिवर्तित होता है। यह अक्सर इस्तेमाल किया जाता है

— कॉनर ओ'ब्रायन

@ ConorO'Brien इसका उपयोग अक्सर किया जाता है, हाँ। लेकिन यह एक दो-चार बिल्ट-इन होगा, इसलिए कोई लाभ नहीं होगा

— लुइस मेंडो

कोई लाभ नहीं? 35*c4 वर्ण है

— कॉनर ओ'ब्रायन

@ ConorO'Brien आह, आप 35तय के साथ मतलब है? यह थोड़ा विशिष्ट लगता है। दूसरी ओर, कुछ चुनौतियां किसी भी चार को अनुमति देती हैं, इसलिए यह एक अच्छा विचार हो सकता है। क्या आपको लगता #है कि सबसे आम है?

— लुइस मेंडो

2

संदर्भ के लिए, यह सुविधा लागू की गई है (फ़ंक्शन Zc, चरित्र के साथ 35, यानी #)। धन्यवाद, @ ConorO'Brien!

— लुइस मेंडो

5

05AB1E , 9 बाइट्स

कोड:

Lb€û.c0ð:

05AB1E एन्कोडिंग का उपयोग करता है ।इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

L              # List [1, .., input]
 b             # Convert each to binary
  €û           # Palindromize each binary number
    .c         # Join the array by newlines and centralize
      0ð:      # Replace zeroes by spaces

— अदनान
स्रोत

4

जेली , 12 बाइट्स

RBUz0ZUŒBo⁶Y

इसे ऑनलाइन आज़माएं!

— लीक नन
स्रोत

1

मुझे भी जाना है, इसलिए जब मैं वापस आऊंगा तो टिप्पणियां पढ़ूंगा। मुझे बाहर गोल्फ के लिए स्वतंत्र महसूस करो।

— लीकी नून

+1 के लिए "मुझे आउटगोल्फ करने के लिए स्वतंत्र महसूस करें" और अच्छे उत्तर के लिए।

— मैजिक ऑक्टोपस Urn

3

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

n=input()
for x in range(n):s=bin(2**len(bin(n))/4+x+1)[3:].replace(*'0 ');print s+s[-2::-1]

इसे ऑनलाइन आज़माएं!

पायथन 3 में, s=f'{x+1:0{len(bin(n))-2}b}'.replace(*'0 ')छोटा होता है, लेकिन तर्क के int(input())आसपास के पार्न्स printइसे 95 बाइट तक धकेल देते हैं।

— लिन
स्रोत

वह मेरी एक प्रति है :) (लेकिन 2**len(bin(n))/4वैसे भी चतुर प्रयोग )

— एरिक आउटगोल्फ

3

जावास्क्रिप्ट (ईएस 6), 106 बाइट्स

1गैर-व्हाट्सएप चरित्र के रूप में उपयोग करता है ।

f=(n,k=0)=>k++<n?[...Array(32-Math.clz32(n))].reduce((s,_,i)=>(c=k>>i&1||' ')+s+(i?c:''),'')+`
`+f(n,k):''

डेमो

कोड स्निपेट दिखाएं

f=(n,k=0)=>k++<n?[...Array(32-Math.clz32(n))].reduce((s,_,i)=>(c=k>>i&1||' ')+s+(i?c:''),'')+`
`+f(n,k):''

O.innerText = f(15)

<pre id=O>

Expand snippet

वैकल्पिक संस्करण (एक ही आकार)

इसके बिना Math.clz32():

f=(n,a=[k=i=0])=>n>>i+1?f(n,a,a[++i]=i):k++<n?a.reduce((s,i)=>(c=k>>i&1||' ')+s+(i?c:''),'')+`
`+f(n,a):''

— Arnauld
स्रोत

1

बहुत अच्छा! पहली बार मैंने देखा है Math.clz32- मुझे यह भी नहीं पता था कि यह अस्तित्व में है!

— बिरजोलक्सेव

@Birjolaxew Yup, यह एक ES6 जोड़ है। यह हर एक समय में एक बार काम आता है।

— अरनौलड

3

भूसी , 21 20 18 बाइट्स

2 बाइट्स बंद करने के लिए @Zgarb धन्यवाद!

S↑(tfS=↔ΠR" #"←DLḋ

इसे ऑनलाइन आज़माएं!

Ungolfed / स्पष्टीकरण

लंबी गद्दी से बचने के लिए, यह उस भग्न की चौड़ाई को निर्धारित करता है जो कि दी गई है 2*len(bin(N))-1और प्रतीकों के साथ उस लंबाई के सभी अनुक्रम उत्पन्न करता है #,_('_' एक स्थान को दर्शाता है)।

चूंकि कार्टेशियन शक्ति क्रम में उत्पन्न होती है और द्विआधारी संख्या भी होती है, यह ठीक है। इस बिंदु पर फ्रैक्टल प्राप्त करने के लिए हमें बस इतना करना है, सभी पैलिंड्रोमों को छानना है और मूल रूप से यह है:

                    -- implicit input N
S↑(                 -- take N from the following list
        ΠR" #"      --   Cartesian power of [" #"] to
                Lḋ  --     number of bits in bin(N)
               D    --     2*
              ←     --     -1
    fS=↔            --   filter out palindromes
   t                --   drop the first line (all spaces)

— ბიმო
स्रोत

1

Ṙ;बस हो सकता है R, और ȯअनावश्यक है। अच्छा जवाब विचार!

— ज़गर्ब

2

गणितज्ञ, 94 बाइट्स

Column[Row/@Table[s=IntegerDigits[i,2];Join[s,Reverse@Most@s]/.{0->" ",1->"#"},{i,#}],Center]&

— J42161217
स्रोत

2

मुझे सचमुच जाना है, ...

— J42161217

2

गणितज्ञ, 98 बाइट्स

Riffle[Nest[ArrayFlatten@{{0,#,0},{1,0,1},{1,#,1}}&,{1},⌊Log2@#⌋]~Take~#"#"/. 0->" ","
"]<>""&

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं ! ⌊और⌋ कर रहे हैं तीन प्रत्येक बाइट्स।

यह पैटर्न के भग्न प्रकृति का उपयोग करते हुए अब तक के अन्य उत्तरों से अलग दृष्टिकोण है। मुख्य चरण है ArrayFlatten@{{0,#,0},{1,0,1},{1,#,1}}&, जो फ्रैक्टली सामान करता है, सबसे अच्छा चित्र रूप में समझाया गया है:

                 [    ]
                 [grid]
[    ]           [    ]
[grid]   --->   #      #
[    ]          #[    ]#
                #[grid]#
                #[    ]#

कोड इस चरण को कम से कम n पंक्तियों को प्राप्त करने के लिए पर्याप्त बार दोहराता है , फिर अतिरिक्त पंक्तियों को बंद कर देता है और इसे अच्छी तरह से प्रदर्शित करता है।

— पेड़ नहीं
स्रोत

2

गैया , 11 बाइट्स

 #”B¦ₔṫ¦€|ṣ

इसे ऑनलाइन आज़माएं!

व्याख्या

    ¦ₔ       For each number 1..input:
 #”B          Convert it to base 2 and use space as 0 and # as 1
      ṫ¦     Palindromize each
        €|   Centre the lines
          ṣ  Join with newlines

— बिजनेस कैट
स्रोत

2

पायथन 2 , 120 118 107 बाइट्स

थैंक्स @ ल्लीसएंडो, @officialaimm, @ हैलवार्ड-ह्यूम

def f(l):
 for a in range(1,l+1):print(bin(a)[2:]+bin(a)[-2:1:-1]).replace(*'0 ').center(len(bin(l+1))*2-4)

इसे ऑनलाइन आज़माएं!

— wrymug
स्रोत

2

replace(*'0 ')2 बाइट्स के लिए

— आधिकारिक

2

107 बाइट्स

— हल्वार्ड् यम

2

सी # (.NET कोर) , 192 178 बाइट्स 168 + 23

मदद के लिए धन्यवाद TheLethalCoder।

x=>new int[x].Select((_,z)=>Convert.ToString(z+1,2).PadLeft((int)Math.Log(x,2)+2).Replace('0',' ')).Aggregate((y,z)=>y+"\n"+z+new string(z.Reverse().Skip(1).ToArray()))

इसे ऑनलाइन आज़माएं!

बहुत यकीन है कि यह बहुत कम किया जा सकता है, सबसे अधिक संभावना पैडिंग और स्ट्रिंग के पीछे हटने में है।

— Dennis.Verweij
स्रोत

PPCG में आपका स्वागत है! फिलहाल यह जवाब सिर्फ एक कोड स्निपेट है। इसे x=>बाइट काउंट में जोड़कर तय किया जा सकता है और ध्यान दें कि आपको अनुगामी अर्ध-उपनिवेश को शामिल करने की आवश्यकता नहीं है। Enumerable.Range(1,x).Select(zके रूप में छोटा है new int[x].Select((_,z)(मुझे लगता है कि यह सही है)। जैसा कि आप Linq का उपयोग कर रहे हैं, आपको using System.Linq;अपनी बाइट गिनती में शामिल करना चाहिए । आप इसका उपयोग भी कर रहे हैं Mathइसलिए आपको इसे शामिल करना चाहिए using System;या इसे पूरी तरह से योग्य बनाना चाहिए। ध्यान दें कि यह तब छोटा हैnamespace System.Linq{}

— TheLethalCoder

आपको कॉल ,' 'में शामिल होने की आवश्यकता नहीं है PadLeftक्योंकि एक स्थान डिफ़ॉल्ट है।

— द लीथेलकोडर

168 बाइट्स + 23 के लिएnamespace System.Linq{}

— TheLethalCoder

@ TheLethalCoder को असुविधा के लिए खेद है, यह अब ठीक हो गया है।

— डेनिस.वीरविज

कोई चिंता नहीं +1 मुझसे यह एक अच्छा जवाब है :)

— TheLethalCoder 15'17

1

चारकोल , 28 बाइट्स

Ａ…·¹ＮθＷ⌈θ«Ｅθ§ #κ↓⸿ＡＥθ÷κ²θ»‖Ｏ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ａ…·¹Ｎθ

पहले nप्राकृतिक नंबरों की सूची बनाएं ।

Ｗ⌈θ«

तब तक दोहराएं जब तक सभी तत्व शून्य न हों।

Ｅθ§ #κ

सूची के प्रत्येक तत्व के अंतिम बाइनरी अंक को एक के रूप में प्रिंट करें या #।

↓⸿

पिछले कॉलम पर जाएं।

ＡＥθ÷κ²θ

सूची के सभी तत्वों को दो से विभाजित करें।

»‖Ｏ

एक बार जब बायां आधा खींचा जाता है, तो इसे प्रतिबिंबित करें।

— नील
स्रोत

चारकोल के वर्तमान संस्करणों में MapAssignRight(IntDivide, 2, q);3 बाइट्स हैं।

— नील

1

जे, 29 बाइट्स

' #'{~(],}.@|.)"1@(#.^:_1)@i.

इसे ऑनलाइन आज़माएं!

व्याख्या

i. एन, इनपुट तक पूर्णांक
(#.^:_1) बेस 2 में परिवर्तित
(],}.@|.)पंक्ति द्वारा पंक्ति ( "1उस हिस्से को करता है), बाइनरी नंबर ( ]पहचान fn है) ले लो , और इसे ,अपने रिवर्स ( |.) के साथ बिल्ली ( ), जहां रिवर्स को माथे ( }.)।
' #'{~1एस और 0एस को हैश और रिक्त स्थान में परिवर्तित करता है ।

— जोनाह
स्रोत

आप उपयोग कर सकते हैं #.invके बजाय #.^:_1।

— कोनोर ओ ब्रायन

@ ConorO'Brien, धन्यवाद, उस के बारे में पता नहीं था।

— जोनाह

क्या यह एक बंद नहीं है? के लिए n = 1, आप कुछ भी नहीं प्रिंट करते हैं। वैसे भी, आप कुछ बदलावों के साथ कुछ बाइट्स को शेव कर सकते हैं जैसे ' #'{~(,|.@}:)"1@#:@:>:@i.(यदि आपको एक के बाद एक बंद करने की अनुमति है तो आप 4 और बाइट्स निकाल सकते हैं)। मूल रूप से, एक हुक का उपयोग करें क्योंकि यह एक कांटा की तरह ही प्रदर्शन करता है जब बाईं ओर का टीइन होता है ]और इसमें अंतर्निहित एएफ़आईके का उपयोग #:होता है #.inv। संपादित करें: मुझे लगता है कि मेरा उत्तर एक टिप्पणी के रूप में वारंट के समान है, मुझे बताएं कि क्या आपको लगता है कि यह स्वयं का उत्तर होना चाहिए।

— कोल

@cole, धन्यवाद! मैं इसे थोड़ी देर बाद अपडेट करूंगा। मैंने सोचा था कि मैंने कोशिश की #:और यह काम नहीं किया, लेकिन मुझे गलत याद रखना चाहिए क्योंकि आप सही हैं कि यह करता है।

— जोनाह

@ जोनाह आपने कोशिश की 2 #:होगी जो केवल सही-सही अंक प्राप्त करेगी। मोनाडिक #:कार्य जैसे #.inv(या #.&:_1)। यह डाइएडिक से अलग है #:, जो केवल उतने ही अंक देता है, जितना इसके बाएं तर्क में परमाणु होते हैं।

— कोल

1

प्रोटॉन , 95 बाइट्स

r=>{for i:range(1,r)print(((bin(i)[2to]).rjust(len(bin(r))-2)[to-1,to by-1]).replace('0',' '))}

इसे ऑनलाइन आज़माएं!

बहुत सारे कीड़े हैं बहुत सारे कोष्ठक नहीं हैं ... मुझे पार्सर को ठीक करने की आवश्यकता है ...

— हाइपरन्यूट्रिनो
स्रोत

1

SOGL V0.12 , 11 बाइट्स

∫2─0@ŗ}¹╬⁴╚

यह कोशिश करो!

— dzaima
स्रोत

1

PHP, 98 97 95 94 + 1 बाइट्स

while($r++<$argn)echo$s=strtr(sprintf("%".-~log($argn,2).b,$r),0," "),substr(strrev("
$s"),1);

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं । 1गैर-व्हाट्सएप के रूप में उपयोग करता है ।

— टाइटस
स्रोत

इसे खराब करने के लिए खेद है, लेकिन यहां कुछ गलत है। के लिए उत्पादन $argn=1और $argn=3सही नहीं है, और $argn0-आधारित (निर्दिष्ट 1-आधारित था) है

— फेलिक्स Palmen

1

@FelixPalmen तय किया। गलत आधार गलत होने के कारण हुआ था। ध्यान देने के लिए धन्यवाद।

— टाइटस

1

के (ngn / k) , 19 बाइट्स

{" #"@+a,1_|a:!x#2}

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत

0

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

n=input()
for i in range(n):s=bin(2**n.bit_length()+i+1)[3:].replace(*'0 ');print s+s[-2::-1]

इसे ऑनलाइन आज़माएं!

— आउटगोल्फर को एरिक करें
स्रोत

0

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

n=input()+1
w=' #'
while len(w)<n:w=[s+l+s for s in' #'for l in w]
print'\n'.join(w[1:n])

इसे ऑनलाइन आज़माएं!

— छड़ी
स्रोत

0

सी (जीसीसी) , 146 108 105 बाइट्स

#define o putchar(33-!(c&(1<<n)))
b;c;p(n){--n?o,p(n),o:o;}f(n){while(n>>++b);while(c++<n)p(b),puts("");}

इसे ऑनलाइन आज़माएं!

यह एक फ़ंक्शन है f(n)जिसे पंक्तियों की संख्या के साथ कहा जाता है n, एक विस्मयादिबोधक चिह्न ( !) का उपयोग गैर-व्हाट्सएप चरित्र के रूप में किया जाता है।

स्पष्टीकरण :

#define o putchar(33-!(c&(1<<n)))
b;c;
p(n)
{
    // least significant bit not yet reached?
    --n?
            // print bit twice with recursive step between
            o,
            p(n),
            o
        // for least significant, just print this bit
        :o;
}

// the main "cathedral function":
f(r)
{
    // determine max number of bits to shift
    while(r>>++b);

    // iterate over rows
    while(c++<r)

        // print row recursively
        p(b),

        // newline
        puts("");
}

/**
 * footer, just calling the function
 */
main(int argc, char **argv)
{
    f(atoi(argv[1]));
}

— फेलिक्स पालमेन
स्रोत

सुझाएँ --n&&o+p(n);o;बजाय --n?o,p(n),o:o;और for(;c++<n;puts(""))p(b);के बजायwhile(c++<n)p(b),puts("");

— ceilingcat

0

जावास्क्रिप्ट (Node.js) , 156 149 बाइट्स

-7 बाइट्स by @ ConorO'Brien

f=(n,w=n.toString(2).length,b=n.toString(2).replace(/0/g," "),s=" ".repeat(w-b.length))=>`${--n?f(n,w)+s+b+[...b].reverse().join``.substr(1):s+"1"}
`

इसे ऑनलाइन आज़माएं!

पुनरावर्ती कार्य। दुर्भाग्य से जेएस एक स्ट्रिंग को उलटने का समर्थन नहीं करता है, इसलिए 19 बाइट्स का उपयोग इसे एक सरणी और पीठ में बदलने पर किया जाता है।

— Birjolaxew
स्रोत

1

आप [...b]इसके बजाय उपयोग कर सकते हैं b.split(""); आप के .join``.substr(1)बजाय का उपयोग भी कर सकते हैं .join("").substr(1); अंत में, मुझे लगता है कि आप उपयोग कर सकते हैं s+1के बजायs+"1"

— कोनोर ओ ब्रायन

0

पर्ल ५ , 77 + 1 (एन) = 78 बाइट्स

$x=1+(log$_)/log 2;map{$_=sprintf"%0${x}b",$_;y/0/ /;say$_.chop.reverse}1..$_

इसे ऑनलाइन आज़माएं!

'#' के बजाय '1' का उपयोग करना क्योंकि यह एक युगल बाइट्स को बचाता है।

— Xcali
स्रोत

0

स्टैक्स , 8 बाइट्स

ç▼┼Ö☺Ç¬É

इसे चलाएं और डीबग करें

अब तक का सबसे छोटा जवाब। के स्थान पर CP437 चारकोड 1 का उपयोग करता है# ।

ASCII समकक्ष:

{:B|pm|Cm

— वीजुन झोउ
स्रोत

फ्रैक्टल कैथेड्रल

MATL , 10 बाइट्स

व्याख्या

05AB1E , 9 बाइट्स

कोड:

स्पष्टीकरण:

जेली , 12 बाइट्स

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

जावास्क्रिप्ट (ईएस 6), 106 बाइट्स

डेमो

वैकल्पिक संस्करण (एक ही आकार)

भूसी , 21 20 18 बाइट्स

Ungolfed / स्पष्टीकरण

गणितज्ञ, 94 बाइट्स

गणितज्ञ, 98 बाइट्स

गैया , 11 बाइट्स

व्याख्या

पायथन 2 , 120 118 107 बाइट्स

सी # (.NET कोर) , 192 178 बाइट्स 168 + 23

चारकोल , 28 बाइट्स

जे, 29 बाइट्स

व्याख्या

प्रोटॉन , 95 बाइट्स

SOGL V0.12 , 11 बाइट्स

PHP, 98 97 95 94 + 1 बाइट्स

के (ngn / k) , 19 बाइट्स

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

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

सी (जीसीसी) , 146 108 105 बाइट्स

जावास्क्रिप्ट (Node.js) , 156 149 बाइट्स

पर्ल ५ , 77 + 1 (एन) = 78 बाइट्स

स्टैक्स , 8 बाइट्स