चुनौती

एक आकार एस को देखते हुए, हैश प्रतीकों ( #) और रिक्त स्थान ( ) से बने उस आकार का एक घन जाल प्रिंट करें ।

उदाहरण:

1:
  #
# # #    
  #
  #

2:
    # #
    # #
# # # # # #
# # # # # #
    # #
    # #
    # #
    # #

3:
      # # #
      # # #
      # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
      # # #
      # # #
      # # #
      # # #
      # # #
      # # #

नेट वास्तव में कोई भी मान्य क्यूब नेट हो सकता है जो घन में बदल सकता है, उदाहरण के लिए ये:

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

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

नियम

परिणामी नेट को ज्यामितीय रूप से वैध होना चाहिए (क्यूब में बदलना)
मानक खामियों से मना किया
नियमों को ध्यान से पढ़ें
यह कोड-गोल्फ है , सबसे छोटी उत्तर जीत है, लेकिन इसका चयन नहीं किया जाएगा

— dkudriavtsev
स्रोत

1

वहाँ अग्रणी / अनुगामी रिक्त स्थान / newlines हो सकता है?

— कृति लिथोस

@ कृतिलीथोस यस

— dkudriavtsev

13

संदर्भ के लिए, सभी 11 घन जाल ।

— xnor

3

यदि मैं नियमों को ध्यान से नहीं पढ़ता तो क्या होगा?

— १

1

@steenbergh तब आपका समाधान अमान्य है

— dkudriavtsev

23

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

n=input()
for c in 1,4,1:exec"print'# '*c*n;"*n

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

इस जाल को प्रिंट करता है, जिसे वाम-औचित्य के लिए चुना जाता है:

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

लाइनों की nया 4*nप्रतियां हैं '# '। प्रत्येक के लिए 1,4,1, हम nकई बार मुद्रित करते हैं कि कई प्रतियां, लाइनों के nलिए बार की जाती nहैं। एक execलूप के अंदर एक forलूप होना बेकार लगता है, लेकिन मैं बेहतर नहीं दिख रहा था।

मेरे द्वारा चुने गए विकल्प:

lambda n:('# '*n*3+'\n')*n+('  '*n+'# '*n+'\n')*3*n

lambda n:('# '*n*3+'\n')*n+(' '*4*n+'# '*n*3+'\n')*n

def f(n):
 for c in[3]*n+[1]*3*n:print('# '*c*n).center(6*n)

def f(n):
 for c in[4]*n+[0]*n:print' '*c*n+'# '*n*3

def f(n):
 for c in[1]*n+[4]*n+[1]*n:print'# '*c*n

def f(n):
 c=1;exec("print'# '*c*n;"*n+"c^=5;"*n)*3

def f(n):
 for i in range(3*n):print'# '*[1,4,1][i/n]*n

def f(n):
 for c in 1,4,1:print('# '*c*n+'\n')*n,

def f(n):
 for c in 1,4,1:exec"print'# '*c*n;"*n

( defकार्य सभी एक कार्यक्रम के रूप में छोटे हो सकते हैं।)

— XNOR
स्रोत

8

ऑक्टेव, 58 44 42 32 बाइट्स

@(n)[z=repmat('# ',n);z,z,z,z;z]

आंशिक रूप से @xnor के अजगर जवाब से प्रेरित है।

z=repmat('# ',n);

इनपुट 2 के लिए '#' का एक स्क्वेयर पैटर्न बनाता है, जो निम्न पैटर्न का परिणाम देता है:

# #             
# # 

y=[z,z,z,z];

चार zएस क्षैतिज रूप से सम्‍मिलित हैं:

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

[z;y;z]

zऔर yऔर zखड़ी concatenated रहे हैं

यह ऑनलाइन की कोशिश करो!

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

पिछला उत्तर:

@(n){h(1:n,1:2:n*6)=1;h(1:n*4,n*2+1:2:4*n)=1;' #'(h+1)}{3}

यह ऑनलाइन की कोशिश करो!

एक टी के आकार का बनाता है

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

— rahnema1
स्रोत

6

गणितज्ञ, 77 60 52 बाइट्स

8 बाइट दूर गोल्फिंग के लिए मार्टिन एंडर को धन्यवाद!

{±s_:=s~Table~#;b=±{a=±"# ","
"},±{a,a,a,a,"
"}}<>b&

एक सकारात्मक पूर्णांक तर्क ले रहा है #और newlines (एक अनुगामी न्यूलाइन सहित) के साथ एक स्ट्रिंग लौटा रहा है; प्रत्येक पंक्ति में एक अनुगामी स्थान भी है। पहले हम ±एक फ़ंक्शन को परिभाषित करते हैं जो इसके इनपुट #समय को दोहराता है ; तब aइसे परिभाषित किया जाता है ±"# "(यह #एक वर्ण है, इनपुट नहीं!), और उससे छोटी पंक्तियों bके सेट को परिभाषित किया जाता है #, जबकि लंबी लाइनों ±{a,a,a,a}<>nका सेट है #। (दोनों मामलों में, मेल खाने वाले उद्धरणों के बीच एक शाब्दिक लाइनफीड है।) अंतिम <>bछोटी लाइनों के सेट की दूसरी प्रति के साथ तार की परिणामी सूची को समेटता है। उदाहरण आउटपुट जब #=2( xnor के जवाब ने मुझे सिखाया कि यह अभिविन्यास गोल्फ खिलाड़ी है):

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

इस कार्यान्वयन का पिछला संस्करण:

""<>(±s_:=s&~Array~#;{b=±{a=±"# ",n="\n"},±{a,a,a,a}<>n,b})&

मूल प्रस्तुत:

""<>If[(m=n~Mod~t)==0,"\n",If[n<t#||#<m<=2#,"# ","  "]]~Table~{n,4(t=3#+1)#}&

की एक स्ट्रिंग बाहर बनाता है 4*(3#+1)टुकड़े, जिनमें से प्रत्येक या तो है "# ", " "या "\n"; बस गणना करता है कि सूचकांक के आधार पर किन टुकड़ों का उपयोग करना है n। उदाहरण आउटपुट जब #=2:

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

— ग्रेग मार्टिन
स्रोत

5

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

f=
n=>`141`.replace(/./g,m=>`${`# `.repeat(n*m)}\n`.repeat(n))

<input type=number oninput=o.textContent=f(this.value)><pre id=o>

स्निपेट का विस्तार करें

आउटपुट में प्रत्येक पंक्ति के अंत में एक अनुगामी स्थान और एक अनुगामी न्यूलाइन शामिल है।

— नील
स्रोत

5

रूबी, 36 बाइट्स

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}

उपयोग:

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}
f[3]
# # #
# # #
# # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # #
# # #
# # #

रूबी, 38 बाइट्स

यह आकार रूबी में लंबा है, लेकिन मुझे उम्मीद है कि कुछ भाषाएँ हैं जहाँ यह छोटी है।

->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}

उपयोग:

g=->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}
g[3]
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #

दोनों उत्तर छोटे हो सकते हैं यदि इसे वापस करने की अनुमति है (अधिमानतः) स्ट्रिंग की एक सरणी या (कम अधिमानतः) मुद्रण के बजाय एक स्ट्रिंग।

— स्तर नदी सेंट
स्रोत

स्ट्रिंग लौटना आउटपुट का एक वैध रूप माना जाता है।

— dkudriavtsev

4

स्काला, 56 बाइट्स

(n:Int)=>Seq(1,4,1)map("# "*_*n+"\n")map(_*n)mkString ""

— jaxad0127
स्रोत

4

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

n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

परीक्षा

f=
n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

function update() {
  O.textContent=f(I.value)
}

update()

<input id=I type=number value=3 oninput='update()'><pre id=O></pre>

स्निपेट का विस्तार करें

— edc65
स्रोत

मुझे पूरी तरह से यकीन नहीं है, लेकिन मुझे लगता है कि आपको हैश के साथ रिक्त स्थान को आउटपुट करने की आवश्यकता है। (मैंने अपने उत्तर के पहले संपादन में रिक्त स्थान शामिल न करने की गलती भी की है)

— क्रिति लिथोस

@ कृतिलिथोस उह, को मिला। धन्यवाद

— edc65

4

जावा 8, 99 बाइट्स

l->{for(int i=-1,j;++i<3*l;)for(j=-1,k=(i/l==2)?4*l:l;++j<k;)System.out.print("# "+j>k-2?"\n":"");}

— रोमन ग्रैफ़
स्रोत

4

वी , 24 23 20 18 20 बाइट्स

Ài# ddÀpLyGïp3PGïp

दिखाए गए सभी छिपे हुए पात्रों के साथ

Ài# ^[ddÀp^VLyGïp3PGoïp

^[है 0x1b(एस्केप वर्ण शाब्दिक) और ^Vहै 0x16( C-v)

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

मुझे बायटेकाउंट को बढ़ाना पड़ा क्योंकि Äइस नए वी पुल में कमांड छोटी गाड़ी थी

इस प्रारूप में आउटपुट:

# 
# # # # 
#

एक अग्रणी न्यूलाइन के साथ

Hexdump:

00000000: c069 2320 1b64 64c0 7016 4c79 47ef 7033  .i# .dd.p.LyG.p3
00000010: 5047 ef70                                PG.p

व्याख्या

Ài# ^[              " Argument times insert "# "
ddÀp                " Argument times duplicate line

अब जब नेट का एक चेहरा पूरा हो गया है, तो हमें नेट बनाना होगा

^VLy                " Copy the face
Gïp                 " Paste it at the end of buffer
3P                  " Paste 3 times (these form the line)
Gïp                 " Paste at end of buffer again

वैकल्पिक समाधान यदि हम रिक्त स्थान का उत्पादन नहीं करते हैं:

21 20 18 16 18 बाइट्स

Àé#ddÀpLyGïp3pGïp

(शीर्ष समाधान के समान कारण के लिए, यह TIO लिंक संशोधित है)

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

— क्रिक्टी लिथोस
स्रोत

4

वी , 14 बाइट्स (गैर-प्रतिस्पर्धात्मक)

Ài# 5Ù4JjòÀÄk

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

00000000: c069 2320 1b35 d934 4a6a f2c0 c46b       .i# .5.4Jj...k

जो भी कारण हो, इस चुनौती ने कई बगों को उजागर किया। अब जब वे सभी तय हो गए हैं, तो यह संस्करण दुर्भाग्य से गैर-प्रतिस्पर्धात्मक है, लेकिन यह देखना अच्छा है कि इस चुनौती का एक वी उत्तर कैसा दिखता है, जब इसे मेरे मैला कोडिंग के साथ रखने के लिए टन बाइट्स जोड़ना नहीं पड़ता है।

स्पष्टीकरण:

À                   " Arg 1 times:
 i# <esc>           "   Insert the string "# "
         5Ù         " Make 5 copies of this line, and put the cursor on the second copy
           4J       " Join four of these lines together
             j      " Move down to the last line
              ò     " Recursively:
               ÀÄ   "   Make Arg 1 copies of this line
                 k  "   And move up a line

— DJMcMayhem
स्रोत

निष्पक्ष होने के लिए, Jमुद्दा मैला कोडिंग AFAIK नहीं था, मुझे लगता है कि यह सिर्फ nvim डिफ़ॉल्ट था?

— nmjcman101

हाँ यह सच है। लेकिन डुप्लीकेट ऑपरेटर निश्चित रूप से सुस्त था। शुक्र है कि यह नया संस्करण बहुत सरल है।

— DJMcMayhem

4

जेली , 20 19 बाइट्स

”#xẋ³Wẋ³K€Y
141DÇ€Y

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

-1 44874 (steenbergh) के लिए धन्यवाद।

^{मैं मदद नहीं कर सकता MUDDYFISH मदद!}

क्या यह गोल्फ है ??? लिंक 19 देखकर 20 19 बाइट्स बहुत ज्यादा लगती हैं ।

स्पष्टीकरण:

”#xẋ³Wẋ³K€Y Helper link. Arguments: z
”#          Character #.
            y (implicit)
  x         Repeat each element of y x times.
    ³       1st command-line argument.
   ẋ        Repeat x y times.
     W      Wrap z.
       ³    1st command-line argument.
      ẋ     Repeat x y times.
        K   Join z on spaces.
         €  Map this link on x.
          Y Join z on newlines.

141DÇ€Y Main link. Arguments: 0
141     Integer 141.
   D    Convert z to base 10.
    Ç   The above link as a monad.
     €  Map this link on x.
      Y Join z on newlines.

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

यह वी बनाम जेली अब है :)

— क्रिति लिथोस

@KritiiLithos नाह, आपका समाधान पहले था।

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

V अब 18 बाइट्स पर है :)

— Kritii Lithos

आप एक बाइट का उपयोग नहीं कर सकते हैं, @लेकिन xअपने आप को ऑपरेंड स्वैप करके ”#xẋ³Wẋ³K€Y:।

— स्टेनबर्घ

3

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

ＮλＧ↑λ←×⁶λ↓λ# ＤＭ×⁴λ←

कोड एक स्थान के साथ समाप्त होता है। इसे ऑनलाइन आज़माएं!

व्याख्या

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

Ｎλमें एक नंबर इनपुट करता है λ।
Ｇबहुभुज कमांड है, जिसका उपयोग हम यहां आयत बनाने के लिए करेंगे। ↑λ←×⁶λ↓λबहुभुज की सीमा को निर्दिष्ट करता है: ऊपर की ओर के λकदम, बाएं के 6 बार λकदम, और नीचे के λकदम। (वह तीन तरफ λसे λब्लॉक है।) आयत के नीचे का किनारा छोटा है। बहुभुज तब स्ट्रिंग से भरा होता है # ।
Ｄ स्टडआउट के लिए मौजूदा कैनवास को डंप करता है, जिसके परिणामस्वरूप कुछ इस तरह होता है:

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

Ｇकमांड के बाद , कर्सर कैनवास के निचले बाएं कोने पर है। Ｍ×⁴λ←इसे 4 गुना λचरणों द्वारा छोड़ दिया जाता है ( ब्लॉक λद्वारा दो के बराबर λ)।
एक जगह को आउटपुट देता है, जो कैनवास को सही मात्रा में छोड़ देता है।
कार्यक्रम के अंत में, कैनवास को (फिर से) स्टडआउट के लिए भेजा जाता है:

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

उन्हें एक साथ रखें और आपको एक क्यूब नेट मिला है।

— DLosc
स्रोत

वाह, आपको वास्तव में तब संघर्ष करना पड़ा था! (कई हफ्तों बाद तक भी नहीं जोड़ा गया।)

— नील

2

बैश / यूनिक्स उपयोगिताओं, 72 69 68 66 बाइट्स

b()(yes `dc<<<2o4d$n^$1^3/p`|tr 01 ' #'|head -$n);n=$1;b 1;b 4;b 1

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

यह इस तथ्य का उपयोग करके काम करता है कि [4 ^ k / 3], जब आधार 2 में लिखा गया है, 1011010 है ... 01, k 1 के साथ। (यहाँ वर्ग कोष्ठक फर्श फ़ंक्शन को दर्शाते हैं।)

— मिशेल स्पेक्टर
स्रोत

2

पाइके, 16 बाइट्स

uAD,sXF**"#

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

के बराबर

1 4 1]3AD,sXF**"#

अपरिचय के कारण

यह बाइट-काउंट कम करने के लिए कुछ ट्रिक्स का उपयोग करता है:

यह सूची का प्रतिनिधित्व करने के लिए कुछ unprintables का उपयोग करता है [1, 4, 1]
XF स्वचालित रूप से स्टैक के लिए आउटपुट डंप करता है
"#अंत में स्ट्रिंग अंतिम के साथ स्वैप हो जाती है *, जिसका अर्थ है कि समापन "की आवश्यकता नहीं है। यह तब होता है जब अंतिम टोकन एक स्ट्रिंग होता है।

u                -      [1, 4, 1]
     AD          -     apply(*, ^, input)
       ,         -    zip(^)
        s        -   sum(^)
          F**"#  -  for i in ^:
           *     -    ^ * input
            *    -   ^ * v
             "#  -    "# "
         X       - splat(^)

— नीला
स्रोत

2

पायथन 2 , 68 71 65 बाइट्स

-6 धन्यवाद @sagiksp के साथ

def f(i,c=1):
 print(' '*i*4,'')[c>i]+'# '*i*3
 if i*2>c:f(i,c+1)

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

@Xnor को हराने के तरीके की अनुपस्थिति में मैं अपने पुनरावर्ती कार्य को एक वैकल्पिक दृष्टिकोण के रूप में पोस्ट करूंगा। F (5) प्रिंट के लिए

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

इस पैटर्न को केवल इसलिए चुना गया क्योंकि इसे अन्य सभी के विपरीत दो भागों में विभाजित किया जा सकता है।

— ElPedro
स्रोत

2

रिक्त स्थान कहां हैं?

— dkudriavtsev

1

आउटपुट में रिक्त स्थान के बिना, यह मान्य नहीं है।

— Mego

रिक्त स्थान जोड़ने के लिए मेरी गलती +3। अपडेट किया गया।

— एलपीड्रो

1

वास्तव में आपको j की भी आवश्यकता क्यों है? आप i के संदर्भ में पूरी चीज़ को फिर से परिभाषित कर सकते हैं और ~ 6 बाइट बचा सकते हैं!

— sagiksp

@sagiksp - धन्यवाद आपके सुझाव का उपयोग करके अपडेट किया गया।

— ElPedro

2

PHP, 64 62 बाइट्स

सहेजे गए 2 बाइट्स क्रिस्टोफ के लिए धन्यवाद ।

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("
",$a,"# ");

इस तरह एक नेट प्रिंट करता है:

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

(एक प्रमुख न्यूलाइन के साथ)

— user63956
स्रोत

1

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("\n",$a,"# ");2 बाइट्स बचाता है।

— क्रिस्टोफ

1

बैच, 111 बाइट्स

@set s=
@set i=@for /l %%i in (1,1,%1)do @
%i%call set s=%%s%% #
%i%echo%s%
%i%echo%s%%s%%s%%s%
%i%echo%s%

— नील
स्रोत

1

पुष्य , 32 29 28 बाइट्स

क्यूब नेट को बायीं ओर प्रिंट करता है। यह गोल्फ के लिए कठिन था ...

&V:`# `;{:";N^:4:";T'.;TD^:"

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

— FlipTack
स्रोत

1

रेटिना , 39 37 बाइट्स

यह मेरा पहली बार रेटिना का उपयोग कर रहा है, मैं अभी भी समझने की कोशिश कर रहा हूं कि चीजों को कैसे करना है।

.+
$*#
#
# 
\`# 
$_¶
G`.
)*%`^
$_$_$_

(4 और 5 वीं लाइनों के बाद दो अनुगामी स्थानों के साथ)

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

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

— सिंह
स्रोत

@MartinEnder धन्यवाद, मैंने उस आवश्यकता पर ध्यान नहीं दिया था, अब यह सही होना चाहिए। क्या आपके पास कोई सुझाव है कि मुझे इसे कैसे आज़माना चाहिए?

— सिंह

बहुत सारे शानदार विचार नहीं हैं लेकिन tio.run/nexus/… दो बाइट्स बचाता है। आप एक समूह में सब कुछ लपेटकर ट्रेसिंग लाइनफीड्स से बच सकते हैं, जिसमें इसका आउटपुट फ्लैग है (और चूंकि ग्रुप प्रोग्राम की आखिरी चीज है, आउटपुट फ्लैग नॉन-साइलेंट होने का बचाव करता है)। दूसरी बाइट $_खाली लाइन को हटाने के बाद चारों ओर कुछ चीजों को स्विच करके नीचे चौथे स्थान पर जाने से बचती है । tio.run/nexus/… एक ही बाइट काउंट है लेकिन थोड़ा बदसूरत है।

— मार्टिन एंडर

@MartinEnder सुझावों के लिए धन्यवाद, और इस भाषा के लिए भी धन्यवाद, यह वास्तव में अच्छा है!

— लियो

आपके दयालु शब्द के लिए धन्यवाद। :) यदि आप कोई प्रश्न पूछना चाहते हैं या चीजों पर चर्चा करना चाहते हैं तो इसके लिए एक चैटरूम है । यह वर्तमान में बल्कि शांत है, लेकिन मैं इसे लोगों के सवालों के जवाब में रखने की कोशिश करता हूं (और आपको किसी भी समय में मुझे पिंग करने में सक्षम होना चाहिए)।

— मार्टिन एंडर

1

QBIC , 52 67 40 बाइट्स

पूर्ण री-राइट:

:[a*3|G=G+@#`][a*2|G=G+@ `][a|?G][a|?_fG

अब यह इस पैटर्न का उपयोग करता है:

###--
--###

जहां -रिक्त स्थान भरे हैं।

:        Read 'a' from the command line        > Assume 3
[a*3|    Create 3 segments times 'a' filling   > 3*3 = 9
G=G+@#`] Define A$ to be '#' and add this to G > G = "#########" 
[a*2|    Create 2 segments times 'a' spacer
G=G+@ `] Define B$ to be ' ' and add this to G > G = "#########       " 
[a|      FOR d == 1; d <= a; d++
?G]      Display G$:
            "#########       " 
            "#########       " 
            "#########       " 
[a|      FOR e == 1; e <= a; e++
?_fG     Display G$ in reverse (_f...|):
            "      #########" 
            "      #########" 
            "      #########" 
         (For loop and function call to Flip impicitly closed by QBIC)

— steenbergh
स्रोत

यह उत्तर अमान्य है, ओपी की इस टिप्पणी के अनुसार।

— आउटगोल्फर

@EriktheOutgolfer अपडेट किया गया।

— स्टीनबर्ग

2

चुनौती के लिए उपयुक्त भाषा का नाम!

— पलटें

1

पिप , 28 17 16 बाइट्स

-nझंडे के लिए कोड के 15 बाइट्स, +1 ।

"# "Xa*_RLaM141

कमांड-लाइन तर्क के रूप में आकार लेता है। इसे ऑनलाइन आज़माएं!

व्याख्या

                 a is 1st cmdline arg
       _         Build a lambda function
     a*          (a) times argument
"# "X            Repeat string "# " that many times
        RLa      Wrap in a list and repeat list (a) times
           M141  Map that function to the characters of 141
                 Autoprint (-n flag separating list items with newlines)

निम्न बिल्कुल नहीं है कि डेटा कैसे संशोधित होता है, लेकिन यह मूल विचार देता है (के लिए a=2):

141

[1;4;1]

[2;8;2]

["# # ";"# # # # # # # # ";"# # "]

[["# # ";"# # "];["# # # # # # # # ";"# # # # # # # # "];["# # ";"# # "]]

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

— DLosc
स्रोत

0

05AB1E , 13 बाइट्स

D141S×S*„# ×»

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

व्याख्या

उदाहरण इनपुट n=2

D              # duplicate input
               # STACK: 2, 2
 141S          # push the list [1,4,1]
               # STACK: 2, 2, [1,4,1]
     ×         # repeat each item in the list input_no times
               # STACK: 2, [11, 44, 11]
      S        # split into list of digits
               # STACK: 2, [1, 1, 4, 4, 1, 1]
       *       # multiply each digit with input
               # STACK: [2, 2, 8, 8, 2, 2]
        „# ×   # repeat the string "# " for each item in the list
               # STACK: ['# # ','# # ','# # # # # # # # ','# # # # # # # # ','# # ','# # ']
            »  # join by newlines
               # OUTPUT: # # 
                         # # 
                         # # # # # # # # 
                         # # # # # # # # 
                         # # 
                         # #

— Emigna
स्रोत

0

सी #, 152 बाइट्स

n=>{var m="";foreach(int c in new[]{1,4,1})for(int i=0,j;i++<n;){for(j=0;j++<c;)m+=new System.Text.StringBuilder().Insert(0,"# ",n);m+="\n";}return m;};

— TheLethalCoder
स्रोत

0

स्माइलबासिक, 57 50 बाइट्स

INPUT S
E$=("#"*S*3+CHR$(10))*S?E$SCROLL-S*2,-1?E$

व्याख्या की:

INPUT SIZE
PART$=("#"*SIZE*3+CHR$(10))*S 'generate half of the pattern
PRINT PART$ 'print half the pattern
SCROLL SIZE*-2,-1 'scroll the text 2 squares right (and 1 character down)
PRINT PART$ 'print half the pattern again

पहले प्रिंट के बाद (आकार = 2, @ कर्सर स्थिति है):

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

@

SCROLL के बाद:

    ######
    ######
@

दूसरे प्रिंट के बाद:

    ######
    ######
######
######
@

— 12Me21
स्रोत

इस स्थिति में आप रिक्त स्थान छोड़ सकते हैं

— dkudriavtsev

0

आम लिस्प, 83 81 79 बाइट्स

(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))

उपयोग:

(funcall #'(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))2)

आउटपुट:

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

यह कैसे काम करता है?

in format there is control string (inside "") and arguments after it
certain commands in string can use arguments (for example ~a displays argument)
~v{~} - takes argument and does commends inside {~} number of times 
                                      (number is given by argument)
       we can write text in loop body - it'll get displayed. Even if
       in loop body there are none commends to use arguments loop itself                 
       will consume one argument (it doesn't matter what it'll be -
       it doesn't seem to affect output)
~% - newline
~n* - jump n arguments forward (relative)
~n:* - jump n arguments backwards (relative)
~n@* - jump to argument n (global, counting from 0)

~v@{~v{# ~}~%~1@*~} <--- we make x rowns, 3x columns of string "# ". 
                         ~1@* is used during looping, it also means we end on argument 1. 
                         (second argument: (* x 3))
~v@{~vt~0@*~v{# ~}~%~} <--- we now make 3x rows, x columns of "(spaces)# "
                         ~vt - is used to move to accurate column. 
                         Here it takes argument (* x 2) - this is 
                         minimal number of columns to display. It uses
                         space as default character for missing characters
                         (when string inside <~> is shorter than min 
                         number of columns). I use it to make (* x 2) spaces, 
                         by giving it no text.
      ~0@* <--- after making spaces we have no new arguments, we go back to
                argument number zero - it is used to determine number of columns in our block

सुधार के विचारों का स्वागत किया जाता है।

निर्दिष्ट आकार का घन जाल प्रिंट करें

चुनौती

नियम

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

ऑक्टेव, 58 44 42 32 बाइट्स

गणितज्ञ, 77 60 52 बाइट्स

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

रूबी, 36 बाइट्स

रूबी, 38 बाइट्स

स्काला, 56 बाइट्स

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

जावा 8, 99 बाइट्स

वी , 24 23 20 18 20 बाइट्स

व्याख्या

21 20 18 16 18 बाइट्स

वी , 14 बाइट्स (गैर-प्रतिस्पर्धात्मक)

जेली , 20 19 बाइट्स

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

व्याख्या

बैश / यूनिक्स उपयोगिताओं, 72 69 68 66 बाइट्स

पाइके, 16 बाइट्स

पायथन 2 , 68 71 65 बाइट्स

PHP, 64 62 बाइट्स

बैच, 111 बाइट्स

पुष्य , 32 29 28 बाइट्स

रेटिना , 39 37 बाइट्स

QBIC , 52 67 40 बाइट्स

पिप , 28 17 16 बाइट्स

व्याख्या

05AB1E , 13 बाइट्स

सी #, 152 बाइट्स

स्माइलबासिक, 57 50 बाइट्स

आम लिस्प, 83 81 79 बाइट्स

यह कैसे काम करता है?