सरल जटिलता

Question

उत्पादन

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

ट्रेलिंग रिक्त स्थान की अनुमति दी। सबसे छोटा समाधान जीतता है।

hint0

hint1:

---

hint1 को सही करने के लिए धन्यवाद @Tahg

Comments

@ngn उत्पादन एक ही रास्ता डेटा का गठन किया गया आम तौर पर (देखें पर सिकोड़ी रहे हैं के लिए किसी भी विवरण के बिना चुनौती codegolf.stackexchange.com/q/126037 ,) क्योंकि पहले जवाब "रहस्यमय" हिस्सा उड़ाने की आदत है

— ऊरीएल

व्यक्तिगत रूप से मुझे इस तरह की चुनौतियाँ पसंद नहीं हैं जहाँ नियम / नुस्खा का पता लगाना कार्य का हिस्सा है। इसके अलावा, एक बार जब कोई व्यक्ति इसे पा लेता है, तो अन्य सभी इसका अनुसरण कर सकते हैं, इसलिए पहले स्थान पर क्यों नहीं?

— लुइस मेंडू

@LuisMendo यह एक दिलचस्प तर्क है। अपने शुद्ध रूप में कोड गोल्फ "एक ज्ञात समाधान को सफलतापूर्वक लागू करने के बारे में है।" उनके शुद्धतम रूप में पहेलियाँ एक समाधान खोजने के बारे में हैं - कार्यान्वयन या तो प्रासंगिक नहीं है या व्यस्त काम माना जाता है। एक विकल्प स्पॉइलर में "ट्रिक" पोस्ट करना होगा। इस तरह से एक गोल्फ चुनौती के रूप में समस्या पर हमला करने के लिए शुद्ध कोड गोल्फर, और जो लोग दोनों गोल्फ और पहेली चुनौतियों को पसंद करते हैं वे दोनों को देखने और हल करने से बच सकते हैं।

— जोनाह

मुझे लगता है कि "रहस्यमय" भाग कुछ ऐसा है जिसे मैं निश्चित रूप से अधिक देख सकता हूं। यद्यपि एक उत्तर में यह चाल मिल सकती है, बाकी यह अभी भी एक नियमित कोड-गोल्फ चुनौती है ... और यह उन लोगों के लिए एक अच्छी चुनौती प्रदान करता है, जो शुरुआत में वैसे भी पैटर्न खोजने का लक्ष्य रखते हैं।

— पूरी तरह से

@ H.PWiz, मुझे यकीन नहीं है कि + 26 / -7 वास्तव में "अच्छी तरह से प्राप्त" है। ऐसा लगता है कि "खराब तरीके से प्राप्त किया गया था, लेकिन HNQ को तेजी से हिट करने में कामयाब रहा और एक तिरछा स्कोर प्राप्त किया"।

— पीटर टेलर

Answer 1

SOGL V0.12 , 17 16 14 बाइट्स

 #6{³IIč▓┼;I+§

यह कोशिश करो!

बाद के अपडेट में č▓12 बाइट्स के लिए हटाया जा सकता है - जो कि ToS को वर्णों के सारणियों के एक बहुस्तरीय तार से एक तार के एक सरणी में परिवर्तित करता है - [["#","#"],[" ","#"]] -> ["##"," #"]-, क्योंकि, ┼- क्षैतिज परिशिष्ट - वर्णों के सरणियों के सरणियों के साथ अच्छी तरह से व्यवहार नहीं करता है - जो Iबनाता है, क्योंकि यह सरणी रोटेशन के लिए भी उपयोग किया जाता है। SOGL में वर्णों की सारणियों का एक सरणी = तारों का सरणी होना चाहिए, लेकिन कई चीजें अभी तक समर्थन नहीं करती हैं ..

स्पष्टीकरण:

 #            push "#"
  6{          6 times do
    ³           create 3 total copies of ToS
     II         rotate clockwise twice
       č▓       normalize as explained above
         ┼      append horizontally
          ;     get the 3rd copy ontop
           I    rotate clockwise
            +   append vertically
             §  reverse horizontally

Comments

प्रतीक्षा करें कि यह कैसे काम करता है

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

@ ConorO'Brien ने केवल एक स्पष्टीकरण जोड़ा: p

— dzaima

ओह अच्छा `` `` ``

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

Answer 2

जावास्क्रिप्ट (ईएस 6), 233 217 213 198 182 170 163 122 बाइट्स

f=_=>[...Array(64)].map((_,x,a)=>a.map(g=(i=(n=64,x),j)=>(n>>=1)?i&n?j&n?g(j,i):` `:j&n?g(i,~j):g(~i,j):`#`).join``).join`
`
document.write(`<pre>${f()}</pre>`)

संपादित करें: सहेजे गए 14 18 बाइट्स @ थैगी के लिए धन्यवाद। @Ngn के लिए धन्यवाद 3 बाइट्स सहेजे गए। एक साथ काम कर रहे दोनों को धन्यवाद के साथ एक और 12 बाइट्स बचाता है। @20202729 के अवलोकन चोरी करके 41 बाइट्स सहेजे गए हैं, जो क्वार्टर घुमावों के बजाय प्रतिबिंबों का उपयोग करते हैं। Ungolfed:

function f() {
    var s = '';
    for (var i = 0; i < 64; i++) {
        for (var j = 0; j < 64; j++) {
            var x = i, y = j, c = '#'; // Default to #
            // Each non-blank quadrant maps to to the original
            // image by doubling and a reflection. Repeat
            // this six times unless we hit the blank quadrant.
            for (var n = 0; n < 6; n++) {
                if (x >= 32) {
                    if (y >= 32) {
                        // Bottom right quarter is a diagonal reflection
                        var t = x - 32;
                        x = y - 32;
                        y = t;
                    } else {
                        // Bottom left quarter is blank
                        c = ' ';
                        break;
                    }
                } else {
                    if (y >= 32) {
                       // Top right corner is a horizontal reflection
                       y = 63 - y;
                    } else {
                       // Top left corner is a vertical reflection
                       x = 31 - x;
                    }
                }
                x *= 2;
                y *= 2;
            }
            s += c;
        }
        s += '\n';
    }
    return s;
}

Comments

क्या आपको f=यहां गिनने की जरूरत है? अच्छी तरह से किया जाता है, वैसे।

— झबरा

217 बाइट्स

— झबरा

आपको f=बाइट काउंट की आवश्यकता नहीं है , लेकिन कोड स्निपेट इसके बिना काम नहीं करता है।

@ कोई मौका आप एक स्पष्टीकरण या एक ungolfed संस्करण जोड़ सकते हैं?

— जोनाह

@ जोना मुझे आशा है कि आपको वह मददगार लगेगी।

— नील

Answer 3

लोगो, 375 341 297 295 278 + 3 बाइट्स

-pध्वज के कारण 3 बाइट्स जोड़ें , जो डिफ़ॉल्ट रूप से परिप्रेक्ष्य मोड को सक्षम करता है, इस प्रकार perspectiveकमांड चलाने की आवश्यकता नहीं होती है , कुल मिलाकर 9 बाइट्स बचाता है।

यूनिक्स के साथ विंडोज पर FMSLogo का उपयोग करें (LF) नई प्रारूप (FMSLogo को सीआरपीएसलाइन को पार्स करने में समस्या है)

to R
rt 90
end
to g :w :l
R fd 2*:l R bk :l up 180
run :w
R run :w
fd 2*:l R bk :l run :w
fd 2*:l up 180
end
to h
pu
ask -1[setxyz 0 0 870]g[g[g[g[g[g[rt 45 fd .7 pd fd 0 pu bk .7 lt 45]1]2]4]8]16]32
repeat 64[sety 64-# repeat 64[setx #-1 type if pixel=[0 0 0]""#["\ ]](pr)]
end

दुर्भाग्य से, नहीं "यह ऑनलाइन कोशिश करो!" लिंक क्योंकि मुझे कोई भी ऑनलाइन दुभाषिया समर्थन परिप्रेक्ष्य मोड नहीं मिल रहा है।

विचार: छवि का एक चित्र बनाएं, फिर चित्र से पिक्सेल को पुनः प्राप्त करें और आउटपुट के रूप में प्रिंट करें।

सरल दोहराया भागों के लिए तस्वीर टूटने:

।

ऊपर दिए गए संकेत का उपयोग करें। हालांकि, चूंकि लोगो प्रतिबिंब का समर्थन नहीं करता है, हम केवल 3 डी ( perspective) मोड में प्रवेश करके और कछुए 180 डिग्री को कंप्यूटर स्क्रीन के समानांतर अक्ष के चारों ओर मोड़ सकते हैं।

यह एक सहायक फ़ंक्शन को परिभाषित करता है g, जिसने 2 मापदंडों l(छवि पक्ष की लंबाई) और w(छवि को आकर्षित करने के लिए उपयोग की जाने वाली प्रक्रिया) को दिया, इसकी परिलक्षित छवि की 3 प्रतियां खींचे। (प्रश्न में संकेत देखें) प्रक्रिया hमुख्य प्रक्रिया करती है।

Comments

आप शायद कुछ स्थानों को छोड़ सकते हैं जैसे 90 fd-> 90fdऔर कुछ बाइट्स को बचा सकते हैं।

— जोनाथन फ्रीच

@JonathanFrech दुर्भाग्य से, FMSLogo इसका समर्थन नहीं करता है।

— user202729

पैपर्ट इसका समर्थन क्यों करता है ?

— जोनाथन फ्रेच

क्या यह एकमात्र उत्तर है जो वास्तव में बिट पैकिंग के बजाय पैटर्न का शोषण करता है?

— जोनाह

@ जोना जेएस समाधान पहले पैटर्न का दोहन करने के लिए था, हालांकि यह एक दिलचस्प तरीके से करता है - मेट्रिसेस को समेटने के बजाय मॉड्यूलर अंकगणितीय और बिट संचालन के साथ। यह लोगो समाधान पिक्सेल-रीडिंग दृष्टिकोण के साथ भी दिलचस्प और अद्वितीय है। मैं कोड को समझने के लिए पर्याप्त लोगो को नहीं जानता, लेकिन विवरण के आधार पर यह तय करता है कि फ्रैक्टल की संरचना (जो मैंने पहले ही संकेत 1 में दे दी थी) नीचे जाने के बिना कुछ पैटर्न को दोहराता है।

— ngn

Answer 4

05AB1E , 30 26 बाइट्स

'#)6F©R®í®'#ð:®ζ)2ä€ø€J˜}»

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

Answer 5

सीजेएम , 30 बाइट्स

"#"]{_W%_32ff&+\_Wf%\z+.+}6*N*

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

Answer 6

पायथन 2 , 205 195 ... 145 144 142 144 बाइट्स

g=lambda n,i,j,*_:g(n/2,*[~i,j,i,~j][2*(j&n>0)-(i&n>0):])if n*(i&n<=j&n)else'# '[i&n>0]
r=range(64)
for j in r:print''.join(g(32,j,i)for i in r)

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

नील के जेएस जवाब से प्रेरित ।

Comments

n>>1है n/=2।

— जोनाथन फ्रेच

aपरिभाषित किया गया है और फिर एक बार उपयोग किया जाता है। इसके मूल्य के साथ इसके संदर्भ को बदलने से चार बाइट्स बचाए जा सकते हैं।

— जोनाथन फ्रेच

मैंने एक उपयोगी सरलीकरण को अनदेखा कर दिया - रोटेशन का उपयोग करके सब कुछ करने के बजाय, मुझे इसके बजाय प्रतिबिंबों का उपयोग करना चाहिए था। यह मेरे जवाब पर मुझे 41 बाइट्स बचा लिया!

— नील

मुझे लगता है कि आप अपने [...[x],...[x]][z]चयन को सरल बनाकर दो बाइट्स बचा सकते हैं ।

— जोनाथन फ्रेच

@ टोटलीअनुमान मेला पर्याप्त

— TFeld

Answer 7

हास्केल, 126 125 113 106 103 बाइट्स

e=[]:e
z=zipWith
r=reverse
m s=z(++)(r s++map(' '<$)s)$map r s++foldr(z(:))e s
unlines$m$m$m$m$m$m["#"]

बिगाड़ने में hint1 का प्रत्यक्ष कार्यान्वयन।

फ़ंक्शन mअगली पुनरावृत्ति उत्पन्न करता है। मुख्य कार्य m6 बार लागू होते हैं । का विवरण m:

m s=                          -- s is the current pattern
     zipWith(++)              -- concatenate pairwise the lines of
                (r s)++       --    the lines of s in reverse order, followed by
                map(' '<$)s   --    each char in s replaced by a space
                              -- and
                map r s++     --    each line of s reversed, followed by
                foldr ... s   --    the transposition of s


e=[]:e;foldr(zipWith(:))e     -- this right fold transposes a matrix

संपादित करें: @ngn ने एक बाइट और @Laikoni को बचाया 3. धन्यवाद!

Comments

n$n$n$n$n$n["#"]की तुलना में कम है iterate n["#"]!!6:)

— ngn

@ngn: well spotted. Thanks a lot!

— nimi

You can use e=[]:e;foldr(zipWith(:))e instead of import Data.List;transpose and then shorten zipWith.

— Laikoni

Answer 8

Java 7, 259 238 237 200 bytes

void f(){char[][]o={{35}},n;for(int s=1,x,y;s<64;s*=2,o=n)for(n=new char[64][64],x=s;x-->0;)for(y=0;y<s;n[s+y++][x]=32)n[s+~y][x]=n[y][2*s+~x]=n[s+x][s+y]=o[y][x];for(char[]b:o)System.out.println(b);}

एक्स लूप पर {} को हटाकर 2 बाइट्स बचाए, धन्यवाद ngn
ने विभिन्न असाइनमेंट परिवर्तनों से 19 बाइट्स को बचाया, धन्यवाद जोनाथन
ने प्रिंट बनाम रिटर्न के लिए 24 बाइट्स सहेजे (यह नहीं पता था), और
लूप में हुए बदलाव के लिए 13 बाइट्स सहेजे गए धन्यवाद नेवले

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

मेरी पहली चुनौती है, और मुझे लगता है कि जावा के लिए सम्मानजनक है। 1 संकेत का उपयोग करता है, (जो गलत btw है, लेकिन मैं टिप्पणी नहीं लिख सकता)। यह शायद आगे गोल्फ हो सकता है, यह पास मूल रूप से था, बिना सुंदर छपाई के।

Comments

I am not sure if it might be because of a version difference, but I tested your code on TIO using Java 8, and it prints null characters instead of spaces.

— Jonathan Frech

It sure did, thanks for noticing. Apparently, Java is quite happy with displaying nulls as spaces in its Strings.

— Tahg

You can save a byte by removing s=1 from your for loop and replacing int s,t,x,y; with int s=1,t,x,y;.

— Jonathan Frech

n[s-1-y][x]=o[y][x];n[y][t-1-x]=o[y][x]; -> n[s-1-y][x]=n[y][t-1-x]=o[y][x];.

— Jonathan Frech

the proper transformation matrix is [[V,H],[_,T]] (Either that or there's some subtle difference in your algorithm, but that's what I needed)

— Tahg

Answer 9

J, 30 27 bytes

|:@(|:@|.,|.@|:,.])^:6,.'#'

Try it online!

Original version.

((|.,.|."1),' '"0,.|:)^:6,.'#'

Try it online!

Answer 10

Python 2, 586 bytes

import zlib,base64 as b
print zlib.decompress(b.b64decode('eJyVVlsOwzAI++8pJuX+d1zXDGLAUKi0pUp52ATcfj7+Wni3dF2/677ZO1dw+z/Zd3+rJU4SdkVHMcYQS9OuJVGio4N61p31+TGoQkco6eqoU6gSWdBJRrQhjhIdvLQ6YhNrqrEtUsu8yEbjmRqUWXlgYbl5EHfLC7cDQl4sxxAhO4wUv7fFPTx22sUWqOeEJ544Z3vn9FPU+ZmdHtCak6Fk3hfCx0FkOC8DF4YvmgoFMnCEwW2cDBkzftoiGy4GZaNhM8VYSl3YMEV7ctxsjLQKRCHZ3IB6+ATZpKSKmEyGrqZvEHY8lEQBWf8zbuAg0eypWG6nRqTLIzM+NPQa2faN89FlxhMY2vcTKDP7579fl0rmIpJ+grTvSyis798ghb4vM0CuVgbM1SFdvukjnFnfR1Gt3vAEngd6lGrIDdfkDU/ARwl+ecMHf5SzIzct8KhsqHANZ0FqFbpXdad5qH2DzOHJIHGM2pz26oug9i2+EBpX+cXQCpBA7/tne01lLb4wviHjtJE='))

Try it online.

---

Python 2, 1032 1025 bytes

I like this one more. But it is much longer. It could be golfed down but there is no need for that. officialaimm's approach is much shorter.

-7 thanks to Jonathan Frech

print''.join(' '*int(x)if'/'<x<'@'else("#"*(ord(x)-64),"\n")[x<"#"]for x in'99A9A2A4A2A1E2B4A9!99B8D4G2A3A4B8!88D8B6B4A2C1G8!88A2A9A7A4E1C1A2A8!88A2A1C1E3E4A9A2A8!88G1C2A2C2A4B8D8!88B4A3A2C2A2G8B55!98A4B2E3E1A2A9A55!88B4A559A9A2A1E2!98A4B99B8G2A2!98G88D8B4A2C!88C1A2A88A2A9A4E1!992A2A88A2A1C1E4A5!992D88G1C2A4B4!992B99B4A3A2G4!777A559A4B2E1A2A4!4A2A1E2B4A559A777!4G2A3A4B99B992!4B4A2C1G88D992!5A4E1C1A2A88A2A569!1E4A9A2A88A2A1C88!C2A4B8D88G98!2A2G8B99B4A89!2E1A2A9A559A4B88!55A9A2A1E3E2B4A98!55B8G2A2C2A3A4B88!8D8B4A2C2A2C1G88!8A2A9A4E3E1C1A2A88!8A2A1C1E4A7A9A2A88!8G1C2A4B6B8D88!8B4A3A2G4D8B99!9A4B2E1A2A4A2A9A99!99996A777!99996B992!99994D299!99994A2A992!99994A2A1C88!99994G98!99994B4A98!99995A4B88!9996E2B4A89!9995C2A3A4B88!9997A2C1G88!9997E1C1A2A88!9997A9A2A88!9997B8D88!9995D8B99!9995A2A9A99!9997A9A2A4A2A1E2!9997B8D4G2A2!9995D8B6B4A2C!9995A2A9A7A4E1!9995A2A1C1E3E4A5!9995G1C2A2C2A4B4!9995B4A3A2C2A2G4!9996A4B2E3E1A2A4!9995B4A559A5!9996A4B99B4!9996G88D4!9995C1A2A88A2A4!9999A2A88A2A1C!9999D88G1!9999B99B4A1!99991A559A4B')

Try it online.

Comments

प्रश्न अनुमति देता है [t]railing spaces, हालांकि आपका समाधान कुछ रिक्त स्थान छोड़ देता है।

— जोनाथन फ्रेच

अनुगामी रिक्त स्थान की अनुमति देने का अर्थ है, कि मुझे उनका उत्पादन नहीं करना है। क्या वो सही है? यह मेरे दूसरे दृष्टिकोण पर बाइट्स को बचाएगा। पहले एक पर यह पहले से ही किया गया है क्योंकि मैंने अपनी फ़ाइल को सहेजते समय ट्रेलिंग रिक्त स्थान को हटा दिया ...

— साइमन

मैं निश्चित रूप से नहीं जानता, लेकिन मैंने इसे अतिरिक्त रिक्त स्थान की अनुमति के रूप में व्याख्या की, लापता स्थानों की अनुमति नहीं दी।

— जोनाथन फ्रेच

x=='!'->x<'#'

— जोनाथन फ्रीच

if x.isdigit()->if"/"<x<"@"

— जोनाथन फ्रीच

Answer 11

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

2 बाइट बचाने में मदद के लिए जोनाथन फ्रीच को धन्यवाद!

""<>Nest[{{(r=Reverse)@#,r/@#},{" "+0#,#}}~Flatten~{{1,3},{2,4}}&,{{"#"}},6]~Riffle~"
"

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

कुछ कारणों से, मैथिलिक्स मल्टीलाइन स्ट्रिंग प्रिंट करते समय पहले वाले को छोड़कर सभी लाइनों में प्रमुख स्थान प्रिंट करता है। इसके अलावा मैथिक्स ऑपरेटर का समर्थन नहीं करता है ।

स्पष्टीकरण:

• {{Reverse@#,Reverse/@#},{" "+0#,#}}: रिवर्स-हॉरिज़ॉन्टली, रिवर्स-वर्टिकली, रिप्लेस-ऑल-बाय- " "और ट्रांसपोज़ का प्रतिनिधित्व करें ( मैथेमेटिका में ट्रांज़ोज़ ऑपरेटर है) का जो छवि को प्रतिबिंबित करने या घुमाने के लिए अलग-अलग तरीकों से संबंधित है।
• ~Flatten~{{1,3},{2,4}} : विशेष आयामों में समतल।
• Nest[ ... ,{{"#"}},6]: {{"#"}}6 बार के अंदर फ़ंक्शन लागू करें ।
• ~Riffle~"<literal newline character>" : प्रत्येक पंक्ति के बीच एक नई रेखा का वर्ण बदल दें।
• ""<> : सभी तार एक साथ शामिल हों।

Comments

आप दो बाइट्स को बचाने के लिए के Reverseसाथ प्रतिस्थापित Rऔर परिभाषित कर सकते हैं R=Reverse;।

— जोनाथन फ्रेच

Answer 12

सी # (.NET कोर) , 1016 1002 980 955 बाइट्स

_{केविन क्रूज़सेन के लिए धन्यवाद 14 बाइट्स सहेजे गए!
जोनाथन फ्रेच के लिए 47 बाइट्स का धन्यवाद!}

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,325982355457<<21,1092065689603<<20,835235872783<<20,291765223433<<20,0x7c20090000970000,-15289957744513<<17,21955973480545<<17,68788263321667<<16,68799053409<<17,206425089091<<16,0xf00c27277f0000,618546478825<<16,650622541833<<16,0xfee430300f0000,208473439235<<18,72203117569<<18,1<<21,3<<20,15<<20,9<<20,9895936,127<<17,97<<17,67<<16,15969<<17,3829596160,662634496,16105<<16,8201<<16,806289408,4027318272,9217L<<18,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64,'0').Replace('0',' ').Replace('1','#'));}

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

---

व्याख्या

आउटपुट का प्रारूप हस्ताक्षरित 64-बिट संख्याओं के एक सरणी के अंदर संग्रहीत किया जाता है, जो प्रत्येक पंक्ति 64 वर्णों के लंबे होने के बाद पूरी तरह से फिट बैठता है। खाली स्थानों का प्रतिनिधित्व किया जाता है 0और #उनके द्वारा प्रतिनिधित्व किया जाता है 1।

संख्या तो उनके बाइनरी स्ट्रिंग में बदल रही हैं, शून्य गद्देदार बाईं हैं जब तक स्ट्रिंग 64 वर्णों चौड़ा है और फिर 0और 1पात्रों के साथ बदल दिया जाता है  और #।

कोड एक लांबा फ़ंक्शन के अंदर संग्रहीत किया जाता है, अधिक विशेष रूप से ए System.Func<string>।

कुछ स्थिरांक long[]को छोटा करके कुछ स्थिरांक बनाए जाते हैं।

Comments

क्या इसमें अनावश्यक स्थान नहीं है long[] n=new[]?

— जोनाथन फ्रेच

@JonathanFrech आह तुम ठीक कह रहे हो, जाहिर है कि यह किसी भी तरह वहाँ घुस गया।

— इयान एच।

आप गद्दी वर्ण निर्दिष्ट करने के लिए नहीं होने से 4 बाइट बचाएंगे।

— नील

ठीक है, यदि अनुगामी lकी आवश्यकता नहीं है, तो आप शायद और भी बाइट्स बचा सकते हैं ।

— जोनाथन फ्रेच

ऐसा लगता है कि इस तल के नीचे का हिस्सा खराब हो गया है।

— झबरा

Answer 13

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

#↓##ＦＥ⁵Ｘ²ι«‖↑Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴ײι⟲ＣＪ⁰±φＴ×⁴ι×⁴ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। अगर यह काम करता है तो 25 बाइट्स होंगे:

#ＦＥ⁷Ｘ²ι«‖↑⟲Ｃ→⁴⟲ＣＪ⁰±φＴιι

स्पष्टीकरण:

#↓##

मैन्युअल रूप से पहली पुनरावर्तन उत्पन्न करें, क्योंकि यह (1, 0.5) के चारों ओर घूमना संभव नहीं है। (ऐसा घुमाव केवल तभी समझ में आता है जब यह 180 ° था।)

ＦＥ⁵Ｘ²ι«

2 (1, 2, 4, 8, 16) की पहली पाँच शक्तियों पर लूप करें।

‖↑

कैनवास को लंबवत रूप से प्रतिबिंबित करें। यह परिणाम के शीर्ष बाएं तिमाही को पूरा करता है।

Ｊ⁻×³ι¹±⁰ψ⟲ＯＯ⁴ײι

दाएँ हाथ की तरफ एक बिंदु के चारों ओर कैनवास को 180 ° घुमाएँ। परिणाम के शीर्ष दाएं तिमाही के लिए प्रतिलिपि सही स्थिति में समाप्त होती है।

⟲Ｃ

नीचे दाएं कोने के चारों ओर 90 ° कैनवास घुमाएं। शीर्ष दाएं कोने की प्रतिलिपि परिणाम के निचले दाएं कोने के लिए सही स्थिति में समाप्त होती है। ऊपरी बाएँ कोने की प्रतिलिपि बहिर्मुखी है।

Ｊ⁰±φＴ×⁴ι×⁴ι

कैनवास को उस आकार में ट्रिम करें जिसे हम चाहते हैं। ट्रिम कर्सर या कैनवास के ऊपर बाईं ओर शुरू होता है, जो भी सबसे नीचे है। कर्सर को इसलिए (0, -1000) भेजा जाता है ताकि यह सुनिश्चित हो सके कि यह ट्रिम के साथ हस्तक्षेप नहीं करता है।

Answer 14

दिल्लोग एपीएल , 29 बाइट्स

⎕←(((⊖,⌽)⍪⊢∘' '¨,⍉)⍣6)1 1⍴'#'

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

Comments

((⊖,⌽)⍪∊,⍉)⍣6⍪⍕#के साथ ⎕ML←0।

— अदम

Answer 15

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

• -4 बाइट्स थैंक्स टू @ जोनाथन फ्रेच

for k in range(64):print"".join(ord(i)*" #"[j%2]for j,i in enumerate('												<?<<<89:11222	202	4	$" 	!%$%$&%$($%&'))[k<<6:][:64]

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

Comments

711 बाइट्स।

— जोनाथन फ्रेच

@JonathanFrech धन्यवाद, मुझे नहीं लगता था कि कोई नई लाइनें नहीं थीं। : डी

— आधिकारिक

Answer 16

पर्ल ५ , 452 बाइट्स

451 बाइट्स कोड + 1 के लिए -p ।

@ नील के सही उत्तर को चुराने के बजाय सभी डेटा को स्ट्रिंग में पैक करता है ।

$_=unpack"B*","\x00\x00\x20\x09\x09\x7c\xc2\x33\x00\x30\x0f\x0f\xe4\x43\x33\x00\xf0\x0c\x0c\x27\x7f\x33\x00\x90\x04\x04\x3e\xe9\x33\x00\x97\x7c\x7c\x20\x09\x33\x00\xfe\xe4\xe4\x30\x0f\x33\x00\xc2\x27\x27\xf0\x0c\x33\x00\x43\x3e\x3e\x90\x04\x33\x00\xc2\x00\x00\x20\x09\x7c\x00\x00\x43\x00\x00\x30\x0f\xe4\x00\x00\x7f\x00\x00\xf0\x0c\x27\x00\x00\xe9\x00\x00\x90\x04\x3e\x00\x00\x09\x00\x00\x97\x7c\x20\x00\x00\x0f\x00\x00\xfe\xe4\x30\x00\x00\x0c\x00\x00\xc2\x27\xf0\x00\x00\x04\x00\x00\x43\x3e\x90\x09\x7c\xc2\x00\x00\x20\x00\x00\x0f\xe4\x43\x00\x00\x30\x00\x00\x0c\x27\x7f\x00\x00\xf0\x00\x00\x04\x3e\xe9\x00\x00\x90\x00\x00\x7c\x20\x09\x00\x00\x97\x00\x00\xe4\x30\x0f\x00\x00\xfe\x00\x00\x27\xf0\x0c\x00\x00\xc2\x00\x00\x3e\x90\x04\x00\x00\x43\x33\x00\x20\x09\x7c\x7c\xc2\x33\x00\x30\x0f\xe4\xe4\x43\x33\x00\xf0\x0c\x27\x27\x7f\x33\x00\x90\x04\x3e\x3e\xe9\x33\x00\x97\x7c\x20\x20\x09\x33\x00\xfe\xe4\x30\x30\x0f\x33\x00\xc2\x27\xf0\xf0\x0c\x33\x00\x43\x3e\x90\x90\x04\x37\x00\x20\x37\x00\x30\x37\x00\xf0\x37\x00\x90\x37\x00\x97\x37\x00\xfe\x37\x00\xc2\x37\x00\x43\x36\x00\x7c\xc2\x36\x00\xe4\x43\x36\x00\x27\x7f\x36\x00\x3e\xe9\x36\x00\x20\x09\x36\x00\x30\x0f\x36\x00\xf0\x0c\x36\x00\x90\x04\x36\x00\x20\x09\x09\x7c\x34\x00\x30\x0f\x0f\xe4\x34\x00\xf0\x0c\x0c\x27\x34\x00\x90\x04\x04\x3e\x34\x00\x97\x7c\x7c\x20\x34\x00\xfe\xe4\xe4\x30\x34\x00\xc2\x27\x27\xf0\x34\x00\x43\x3e\x3e\x90\x34\x00\xc2\x00\x00\x20\x34\x00\x43\x00\x00\x30\x34\x00\x7f\x00\x00\xf0\x34\x00\xe9\x00\x00\x90\x34\x00\x09\x00\x00\x97\x34\x00\x0f\x00\x00\xfe\x34\x00\x0c\x00\x00\xc2\x34\x00\x04\x00\x00\x43"=~s/[3-9](.)/$1x$&/ger;y/01/ #/;s/.{64}/$&
/g

xxd451 बाइट फ़ाइल के लिए प्रतिवर्ती आउटपुट :

00000000: 245f 3d75 6e70 6163 6b22 422a 222c 2200  $_=unpack"B*",".
00000010: 0020 0909 7cc2 3300 300f 0fe4 4333 00f0  . ..|.3.0...C3..
00000020: 0c0c 277f 3300 9004 043e e933 0097 7c7c  ..'.3....>.3..||
00000030: 2009 3300 fee4 e430 0f33 00c2 2727 f00c   .3....0.3..''..
00000040: 3300 433e 3e90 0433 00c2 0000 2009 7c00  3.C>>..3.... .|.
00000050: 0043 0000 300f e400 007f 0000 f00c 2700  .C..0.........'.
00000060: 00e9 0000 9004 3e00 0009 0000 977c 2000  ......>......| .
00000070: 000f 0000 fee4 3000 000c 0000 c227 f000  ......0......'..
00000080: 0004 0000 433e 9009 7cc2 0000 2000 000f  ....C>..|... ...
00000090: e443 0000 3000 000c 277f 0000 f000 0004  .C..0...'.......
000000a0: 3ee9 0000 9000 007c 2009 0000 9700 00e4  >......| .......
000000b0: 300f 0000 fe00 0027 f00c 0000 c200 003e  0......'.......>
000000c0: 9004 0000 4333 0020 097c 7cc2 3300 300f  ....C3. .||.3.0.
000000d0: e4e4 4333 00f0 0c27 277f 3300 9004 3e3e  ..C3...''.3...>>
000000e0: e933 0097 7c20 2009 3300 fee4 3030 0f33  .3..|  .3...00.3
000000f0: 00c2 27f0 f00c 3300 433e 9090 0437 0020  ..'...3.C>...7. 
00000100: 3700 3037 00f0 3700 9037 0097 3700 fe37  7.07..7..7..7..7
00000110: 00c2 3700 4336 007c c236 00e4 4336 0027  ..7.C6.|.6..C6.'
00000120: 7f36 003e e936 0020 0936 0030 0f36 00f0  .6.>.6. .6.0.6..
00000130: 0c36 0090 0436 0020 0909 7c34 0030 0f0f  .6...6. ..|4.0..
00000140: e434 00f0 0c0c 2734 0090 0404 3e34 0097  .4....'4....>4..
00000150: 7c7c 2034 00fe e4e4 3034 00c2 2727 f034  || 4....04..''.4
00000160: 0043 3e3e 9034 00c2 0000 2034 0043 0000  .C>>.4.... 4.C..
00000170: 3034 007f 0000 f034 00e9 0000 9034 0009  04.....4.....4..
00000180: 0000 9734 000f 0000 fe34 000c 0000 c234  ...4.....4.....4
00000190: 0004 0000 4322 3d7e 732f 5b33 2d39 5d28  ....C"=~s/[3-9](
000001a0: 2e29 2f24 3178 2426 2f67 6572 3b79 2f30  .)/$1x$&/ger;y/0
000001b0: 312f 2023 2f3b 732f 2e7b 3634 7d2f 2426  1/ #/;s/.{64}/$&
000001c0: 0a2f 67                                  ./g

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

Answer 17

Jq 1.5 , 538 535 488 476 बाइट्स

यह एक सीधा प्रतिनिधित्व है। मैंने अभी तक किसी भी फैंसी एन्कोडिंग का प्रयास नहीं किया है। Z फ़ंक्शन के साथ 0,0 जोड़े जोड़े गए।

3 बाइट्स को खत्म करने में मदद करने के लिए फिर से जोनाथन फ्रेच को धन्यवाद !

def B:recurse(if.>0then./2|floor else empty end)|.%2;def S:256+.|[B]|reverse[2:]|map(if.>0then"#"else" "end)|join("");def Z:0,0;[[Z,3,1,1,4,5,2],[1,4,5,2,2,3,Z],[Z,Z,2,3,Z],[Z,Z,3,1,1,4]]as$m|[[],[9,15,12,4,124,228,39,62],[Z,Z,Z,Z,124,228,39,62,32,48,240,144],[32,48,240,144,151,254,194,67,194,67,127,233,9,15,12,4],[124,228,39,62,32,48,240,144,32,48,240,144,151,254,194,67],[194,67,127,233,9,15,12,4,9,15,12,4,124,228,39,62]]as$c|$m[]|range(16)as$l|map($c[.][$l]|S)|join("")

अक्षर गणना

$ wc -c picture.jq
 476 picture.jq

नमूना चला

$ jq -Mnr -f picture.jq
                  #         #  #    #  # #####  ##    #         
                  ##        ####    #######  #   #    ##        
                ####        ##      ##    #  ### #######        
                #  #         #       #    ##### ### #  #        
                #  # ### #####   #####    #         #  #        
                ####### ###  #  ###  #    ##        ####        
                ##    #   #  ###  #  #######        ##          
                 #    ##  #####   ##### #  #         #          
                ##    #                   #         #  # #####  
                 #    ##                  ##        #######  #  
                 #######                ####        ##    #  ###
                ### #  #                #  #         #    ##### 
                    #  #                #  # ### #####    #     
                    ####                ####### ###  #    ##    
                    ##                  ##    #   #  #######    
                     #                   #    ##  ##### #  #    
    #  # #####  ##    #                   #                     
    #######  #   #    ##                  ##                    
    ##    #  ### #######                ####                    
     #    ##### ### #  #                #  #                    
 #####    #         #  #                #  # ###                
###  #    ##        ####                #######                 
  #  #######        ##                  ##    #                 
  ##### #  #         #                   #    ##                
          #         #  # #####   #####  ##    #                 
          ##        #######  #  ###  #   #    ##                
        ####        ##    #  ###  #  ### #######                
        #  #         #    #####   ##### ### #  #                
        #  # ### #####    #       #         #  #                
        ####### ###  #    ##      ##        ####                
        ##    #   #  #######    ####        ##                  
         #    ##  ##### #  #    #  #         #                  
                                          #                     
                                          ##                    
                                        ####                    
                                        #  #                    
                                        #  # ###                
                                        #######                 
                                        ##    #                 
                                         #    ##                
                                 #####  ##    #                 
                                ###  #   #    ##                
                                  #  ### #######                
                                  ##### ### #  #                
                                  #         #  #                
                                  ##        ####                
                                ####        ##                  
                                #  #         #                  
                                  #         #  #    #  # #####  
                                  ##        ####    #######  #  
                                ####        ##      ##    #  ###
                                #  #         #       #    ##### 
                                #  # ### #####   #####    #     
                                ####### ###  #  ###  #    ##    
                                ##    #   #  ###  #  #######    
                                 #    ##  #####   ##### #  #    
                                ##    #                   #     
                                 #    ##                  ##    
                                 #######                ####    
                                ### #  #                #  #    
                                    #  #                #  # ###
                                    ####                ####### 
                                    ##                  ##    # 
                                     #                   #    ##

Comments

तीन अचूक रिक्त स्थान B: recऔर में 16) as $l|।

— जोनाथन फ्रेच

if.==0then" "else"#"end-> if.>0then"#"else" "end।

— जोनाथन फ्रेच

Answer 18

पायथन 2 , 174 164 154 बाइट्स (मैट्रिक्स ऑपरेशन पर आधारित)

• -10 बाइट्स ngn के लिए धन्यवाद।
• -10 बाइट्स के लिए धन्यवाद जोनाथन फ्रेच।

from numpy import*
s=[['#']]
exec'b=fliplr(s);s=vstack((hstack((flipud(s),b)),hstack((eye(len(s)),rot90(b)))));'*6
s[s>'#']=' '
for l in s:print''.join(l)

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

Comments

import *-> import*; in s.tolist()->in s

— ngn

154 बाइट्स ।

— जोनाथन फ्रेच

Answer 19

कैनवस , 10 बाइट्स

#６［↔ω⤢∔ω↶×

यहाँ यह कोशिश करो!

Answer 20

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

_=>` 18# 9# 2# 4# 2# #5 2#2 4#
 18#2 8#4 4#7 2# 3# 4#2
 16#4 8#2 6#2 4# 2#3 #7
 16# 2# 9# 7# 4#5 #3 # 2#
 16# 2# #3 #5 3#5 4# 9# 2#
 16#7 #3 2# 2#3 2# 4#2 8#4
 16#2 4# 3# 2#3 2# 2#7 8#2
 17# 4#2 2#5 3#5 # 2# 9#
 16#2 4# 19# 9# 2# #5
 17# 4#2 18#2 8#7 2#
 17#7 16#4 8#2 4# 2#3
 16#3 # 2# 16# 2# 9# 4#5
 20# 2# 16# 2# #3 #5 4#
 20#4 16#7 #3 2# 4#2
 20#2 18#2 4# 3# 2#7
 21# 19# 4#2 2#5 # 2#
 4# 2# #5 2#2 4# 19#
 4#7 2# 3# 4#2 18#2
 4#2 4# 2#3 #7 16#4
 5# 4#5 #3 # 2# 16# 2#
 #5 4# 9# 2# 16# 2# #3
#3 2# 4#2 8#4 16#7
 2# 2#7 8#2 18#2 4#
 2#5 # 2# 9# 19# 4#2
 10# 9# 2# #5 3#5 2#2 4#
 10#2 8#7 2# 2#3 2# 3# 4#2
 8#4 8#2 4# 2#3 2# 2#3 #7
 8# 2# 9# 4#5 3#5 #3 # 2#
 8# 2# #3 #5 4# 7# 9# 2#
 8#7 #3 2# 4#2 6#2 8#4
 8#2 4# 3# 2#7 4#4 8#2
 9# 4#2 2#5 # 2# 4# 2# 9#
 42#
 42#2
 40#4
 40# 2#
 40# 2# #3
 40#7
 40#2 4#
 41# 4#2
 33#5 2#2 4#
 32#3 2# 3# 4#2
 34# 2#3 #7
 34#5 #3 # 2#
 34# 9# 2#
 34#2 8#4
 32#4 8#2
 32# 2# 9#
 34# 9# 2# 4# 2# #5
 34#2 8#4 4#7 2#
 32#4 8#2 6#2 4# 2#3
 32# 2# 9# 7# 4#5
 32# 2# #3 #5 3#5 4#
 32#7 #3 2# 2#3 2# 4#2
 32#2 4# 3# 2#3 2# 2#7
 33# 4#2 2#5 3#5 # 2#
 32#2 4# 19#
 33# 4#2 18#2
 33#7 16#4
 32#3 # 2# 16# 2#
 36# 2# 16# 2# #3
 36#4 16#7
 36#2 18#2 4#
 37# 19# 4#2`.replace(/(.)(\d+)/g,(_,c,n)=>c.repeat(n))

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

Comments

ऊह, अब क्या समस्या है? एर्म ... क्या मुझे कुछ याद आ रहा है?

— पूरी तरह से

मैंने इसे कम नहीं किया, लेकिन, फी, इसका उपयोग करके इसे बहुत अधिक संकुचित किया जा सकता है ।

मैं या तो नहीं था, लेकिन यह सवाल की भावना में नहीं है। पैटर्न, कुछ सरल पुनरावर्ती प्रक्रिया द्वारा, संभवतः उत्पन्न किया गया था। चुनौती नियम निर्धारित करती है, जिस बिंदु पर आपका समाधान बेहद कम होगा।

— जोनाह

~ 50 बाइट को बचाने के लिए बेस 36 में बदलें।

— झबरा

मैं पूरी तरह से जानता हूं कि यह इष्टतम समाधान या सबसे छोटा समाधान या चतुर नहीं है। मैंने बस एक एल्गोरिथ्म का उपयोग करने की कोशिश की और यह समाप्त हो गया। यह, हालांकि, एक पूरी तरह से वैध समाधान है और इसलिए डाउनवोट के लायक नहीं है। बोरिंग सॉल्यूशन को अपवोट नहीं किया जाना चाहिए, लेकिन उन्हें डाउनवोट भी नहीं किया जाना चाहिए।

— पूरी तरह से

Answer 21

सी # (.NET कोर) , 976 969 बाइट्स

o=>{foreach(var l in new[]{35223185965568,52841249260288,0xf00c0c277f00,0x9004043ee900,0x977c7c200900,0xfee4e4300f00,0xc22727f00c00,73934616658944,0xc2000020097c,73667282210788,0x7f0000f00c27,0xe9000090043e,9895614577696,0xf0000fee430,0xc0000c227f0,4398050918032,0x97cc20000200000,0xfe44300003<<20,0xc277f0000f<<20,0x43ee900009<<20,0x7c20090000970000,-0x1bcff0ffff020000,0x27f00c0000c20000,0x3e90040000430000,9017629528424448,0x300fe4e4430000,0xf00c27277f0000,0x90043e3ee90000,0x977c2020090000,0xfee430300f0000,0xc227f0f00c0000,0x433e9090040000,2097152,3145728,15728640,9437184,9895936,16646144,12713984,4390912,2093088768,3829596160,662634496,1055457280,537460736,806289408,4027318272,2416181248,537463164,806293476,4027321383,2416182334,2541517856,4276413488,3257346032,1128152720,3254779936,1124073520,2130706672,3909091472,150995095,251658494,201326786,67108931})System.Console.WriteLine(System.Convert.ToString(l,2).PadLeft(64).Replace('0',' ').Replace('1','#'));}

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

Comments

नमस्ते, PPCG में आपका स्वागत है! यह लगभग बिल्कुल वैसा ही दिखता है जैसे @IanH का C # .NET उत्तर .. इसलिए यदि आपके पास उसके लिए कोई सुधार है, तो एक नया उत्तर बनाने के बजाय एक टिप्पणी करें जो लगभग समान है। अपने प्रश्न के लिए, आप <s>969</s>पिछले बाइट्स को पार करने के लिए उपयोग कर सकते हैं ।

— केविन क्रूज़सेन

मुझे टिप्पणी करने के लिए आवश्यक प्रतिष्ठा नहीं है।

— मेरा सर्वनाम

कृपया रेप आवश्यकताओं को दरकिनार करने की कोशिश न करें।

— झबरा

क्या इसका मतलब यह है कि अगर मेरी प्रतिष्ठा बहुत कम है, तो पीपीसीजी में मैं दूसरों की मदद करने की कोशिश नहीं कर सकता?

— मेरा सर्वनाम

@ अच्छा होना, स्टेक्सएक्सचेंज नए लोगों पर थोड़ा कठोर है, चलो जल्दी से दुर्भावना मानकर उनके लिए इसे कठिन न बनाएं

— 8

Answer 22

सी # (.NET कोर) , 739 बाइट्स

_=>{var r="";for(int i=0,j,k=0;i<626;i++)for(j=0;j++<@"4#+#$#&#$##'$$&#=$*&&)$#%#&$:&*$($&#$%#):#$#+#)#&'#%##$#:#$##%#'%'&#+#$#:)#%$#$%$#&$*&:$&#%#$%$#$)*$=#&$$'%'##$#+#<$&#5#+#$##'5#&$4$*)$#5)2&*$&#$%2%##$#2#$#+#&'7#$#2#$##%#'&#;&2)#%$#&$:$4$&#%#$);#5#&$$'##$#*#$##'$$&#5#;)$#%#&$4$:$&#$%#)2&;#&'#%##$#2#$#7'&#+#$#2#$##%2%$#&$*&2)5#$)*$4$&#5'##$#+#5#&$<#+#$##'%'$$&#=$*)$#$%$#%#&$:&*$&#$%$#$%#):#$#+#&'%'#%##$#:#$##%#'&#)#+#$#:)#%$#&$($*&:$&#%#$)&&*$=#&$$'##$#&#$#+#^#a$^&^#$#^#$##%Z)[$&#\#&$S'$$&#S%$#%#&$T#$%#)T'#%##$#T#+#$#T$*&R&*$T#$#+#V#+#$#&#$##'F$*&&)$#D&*$($&#$%B#$#+#)#&'C#$##%#'%'&#G)#%$#$%$#&$F$&#%#$%$#$)G#&$$'%'##$#F$&#5#H#&$4$G)2&F%##$#2#$#J#$#2#$##%F&2)G$4$&#H#5#&$"[i]-34;){r+=i%2<1?' ':'#';if(++k%64<1)r+='\n';}return r;}

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

उसी दृष्टिकोण का उपयोग करता है यह अन्य उत्तर है ।

Answer 23

K (ngn / k) , 32 31 27 बाइट्स

6{,[|x;""x],'(+|+x),+x}/"#"

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

6{ }/ 6 बार करते हैं

+x पक्षांतरित

|x उल्टा सीधा

+|+x क्षैतिज रूप से उल्टा

, समतल रूप से लंबवत

,' क्षैतिज रूप से समतल करें

,[A;B]के रूप में ही है A,B। यह चारों ओर कोष्ठक से बचने में मदद करता हैA संपूर्ण अभिव्यक्ति के और आसपास

""xxरिक्त स्ट्रिंग में सूचकांकों के तत्वों का उपयोग करें । आउट-ऑफ-बाउंड इंडेक्सिंग रिक्त स्थान पैदा करता है, इसलिए यह अभिव्यक्ति एक सभी-स्पेस मैट्रिक्स को वापस कर देगी, जैसा कि आकारx