35

एक Octothorpe, (भी बुलाया संख्या चिह्न, हैश या हैशटैग, या पाउंड चिह्न) निम्नलिखित ASCII वर्ण है:

यह एक मजेदार आकार नहीं है? चलो इसके बड़े संस्करण बनाते हैं! तो यहाँ आपकी चुनौती है:

एक सकारात्मक पूर्णांक एन को देखते हुए , आकार N का एक ASCII हैशटैग का उत्पादन करता है ।

उदाहरण के लिए, 1 का ASCII हैशटैग इस तरह दिखता है:

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

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

इनपुट हमेशा एक वैध पॉजिटिव पूर्णांक होगा, इसलिए आपको नॉन-नंबर्स, नेगेटिव, या 0. को हैंडल करने की आवश्यकता नहीं है। आपका आउटपुट किसी भी उचित फॉर्मेट में हो सकता है, इसलिए STDOUT में आउटपुट करना, स्ट्रिंग्स की सूची वापस करना, या स्ट्रिंग के साथ। newlines, वर्णों का 2D मैट्रिक्स, फ़ाइल में लिखना आदि सभी ठीक हैं।

परीक्षण के मामलों

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

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

4:
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    
####################
####################
####################
####################
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    
####################
####################
####################
####################
    ####    ####    
    ####    ####    
    ####    ####    
    ####    ####    

5:
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
#########################
#########################
#########################
#########################
#########################
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
#########################
#########################
#########################
#########################
#########################
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####     
     #####     #####

चूंकि यह एक कोड-गोल्फ है, जो आप कर सकते हैं सबसे छोटा संभव समाधान लिखने की कोशिश करें, और सबसे ऊपर, मज़े करें!

code-golf string ascii-art

— DJMcMayhem
स्रोत

1

MATL , 20 16 12 11 बाइट्स

DJMcMayhem के लिए 3 बाइट्स धन्यवाद।

लुइस मेंडो के लिए 1 बाइट धन्यवाद।

21BwY"&*~Zc

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

व्याख्या

    % stack starts with input e.g. 2
21  % push 21 to stack             2 21
B   % convert to binary            2 [1 0 1 0 1]
w   % swap                         [1 0 1 0 1] 2
Y"  % repeat                       [1 1 0 0 1 1 0 0 1 1]
&*  % one-input multiplication    [[1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [0 0 0 0 0 0 0 0 0 0]
                                   [1 1 0 0 1 1 0 0 1 1]
                                   [1 1 0 0 1 1 0 0 1 1]]
~   % complement                  [[0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [1 1 1 1 1 1 1 1 1 1]
                                   [0 0 1 1 0 0 1 1 0 0]
                                   [0 0 1 1 0 0 1 1 0 0]]
Zc  % convert 0 to spaces            ##  ##  
      1 to octothorpes               ##  ##  
      and join by newline          ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
                                   ##########
                                   ##########
                                     ##  ##  
                                     ##  ##

— लीक नन
स्रोत

1

आप उपयोग कर सकते हैं Zcके बजाय 35*cऔर ~(तार्किक नहीं) के बजाय0=

— DJMcMayhem

1

@DJMcMayhem @ _ @ ऐसा क्यों है कि एक अंतर्निहित

— लीक नून

1

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

— DJMcMayhem

इसके अलावा, चूंकि प्रत्येक कोशिका को केवल गैर-शून्य होना चाहिए, आप Qइसके बजाय कर सकते हैं2<

— डीजेएमकेम

1

@LeakyNun आप बदल सकते हैं !t*करने के लिए &*। उत्तरार्द्ध का अर्थ है "एक-इनपुट गुणन", जो इसके पारगमन द्वारा इनपुट को (तत्व-वार) गुणा करता है

— लुइस मेंडो

14

ब्रेन-फ्लैक , 420 बाइट्स

(()()()){({}<(({})){({}<<>(<>({})<>){({}<((((()()()()){}){}()){}())>[(
)])}{}(<>({})<>){({}<((((()()()()){}){}){})>[()])}{}(<>({})<>){({}<(((
(()()()()){}){}()){}())>[()])}{}(<>({})<>){({}<((((()()()()){}){}){})>
[()])}{}((()()()()()){})<>>[()])}{}((({}))<(({})(({}){}){})>){({}<<>(<
>({})<>){({}<((((()()()()){}){}()){}())>[()])}{}((()()()()()){})<>>[()
])}{}{}>[()])}{}({}<>)(({})((({({})({}[()])}{})){}){}{}){({}<{}>[()])}

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

नहीं, 420 का स्कोर जानबूझकर नहीं था। मे वादा करता हु। पठनीय संस्करण:

# 3 Times...
(()()())
{
({}<

    #Duplicate the input
    (({}))

    #Input times...
    {
        ({}<

        #Switch to the main stack
        <>

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            # Push a hash
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}){})

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            # Push a hash
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Grab the duplicate of the input
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}){})

        >[()])}{}

        #Push a newline
        ((()()()()()){})

        #Toggle back to the alternate stack
        <>

        #Decrement the (second) loop counter
        >[()])

    #Endwhile
    }

    #Pop the now zeroed loop counter
    {}

    #Turn [a] into [a, a*5, a]
    ((({}))<(({})(({}){}){})>)

    #A times....
    {
        ({}<

        #Toggle back over
        <>

        #Grab a*5
        (<>({})<>)

        #That many times...
        {({}<

            #Push a space
            ((((()()()()){}){}()){}())

        >[()])}{}

        #Push a newline
        ((()()()()()){})

        #Toggle back
        <>

        #Decrement the (second) loop counter
        >[()])

    }

    #Pop the loop counter and the a*5
    {}{}

#Decrement the outer loop counter
>[()])
}

#Pop the zeroed loop counter
{}

#Pop a over
({}<>)

#Pushes (a**2) * 5 + a
(({})((({({})({}[()])}{})){}){}{})

#That many times...
{({}<

    #Pop a character off the output stack
    {}

>[()])}

— DJMcMayhem
स्रोत

13

6502 मशीन कोड (C64), 59 56 बाइट्स

00 C0 20 9B B7 A9 06 85 FC 86 FE A6 FE 86 FD A9 03 4D 1F C0 8D 1F C0 C6 FC D0
01 60 A9 23 A0 05 49 00 20 D2 FF CA D0 FA A6 FE 88 D0 F3 A9 0D 20 D2 FF C6 FD
D0 E6 F0 D3

ऑनलाइन डेमो

उपयोग: SYS49152,Nजहां N 1 और 255 के बीच की संख्या है।

_{(4 से अधिक मान पहले से ही C64 स्क्रीन के लिए बहुत बड़ा होगा, 8 से शुरू, आउटपुट बहुत व्यापक है)}

स्पष्टीकरण :

         00 C0       .WORD $C000    ; load address

.C:c000  20 9B B7    JSR $B79B      ; read N into X
.C:c003  A9 06       LDA #$06       ; number of "logical" lines plus 1 for hash
.C:c005  85 FC       STA $FC        ; store in counter variable for lines
.C:c007  86 FE       STX $FE        ; store N in counter variable for char repetitions
.C:c009  A6 FE       LDX $FE        ; load repetition counter
.C:c00b  86 FD       STX $FD        ; store in counter variable for line repetitions
.C:c00d  A9 03       LDA #$03       ; value to toggle the character toggle
.C:c00f  4D 1F C0    EOR $C01F      ; xor character bit toggle
.C:c012  8D 1F C0    STA $C01F      ; store character bit toggle
.C:c015  C6 FC       DEC $FC        ; decrement "logical" lines
.C:c017  D0 01       BNE $C01A      ; not 0 -> continue
.C:c019  60          RTS            ; program done
.C:c01a  A9 23       LDA #$23       ; load hash character
.C:c01c  A0 05       LDY #$05       ; load "logical" columns for hash
.C:c01e  49 00       EOR #$00       ; in each odd "logical" line, toggle character
.C:c020  20 D2 FF    JSR $FFD2      ; output one character
.C:c023  CA          DEX            ; decrement character repetition
.C:c024  D0 FA       BNE $C020      ; not 0 -> back to output
.C:c026  A6 FE       LDX $FE        ; reload character repetition
.C:c028  88          DEY            ; decrement "logical" columns
.C:c029  D0 F3       BNE $C01E      ; not 0 -> back to character toggle
.C:c02b  A9 0D       LDA #$0D       ; line done, load newline character
.C:c02d  20 D2 FF    JSR $FFD2      ; and output
.C:c030  C6 FD       DEC $FD        ; decrement line repetitions
.C:c032  D0 E6       BNE $C01A      ; not 0 -> back to character init
.C:c034  F0 D3       BEQ $C009      ; else back to main loop (toggle char toggling)

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

5

उदासीनता के लिए +1 (c64 पर 6502 असेंबली मेरा पहला प्रोग्रामिंग अनुभव था ...)

— ओलिवियर दुलक

10

हास्केल , 43 बाइट्स

l%n=l!!1:l++l<*[1..n]
f n=["##"%n,"# "%n]%n

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

स्ट्रिंग्स की एक सूची को आउटपुट करता है।

— XNOR
स्रोत

8

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

def f(n):p=[(" "*n+"#"*n)*2]*n;print(p+["#"*n*5]*n)*2+p

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

यह वर्णों की 2 डी सूची देता है।

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

def f(n):p=((" "*n+"#"*n)*2+"\n")*n;print(p+("#"*n*5+"\n")*n)*2+p

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

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

def f(n):p=[(" "*n+"#"*n)*2]*n;print'\n'.join((p+["#"*n*5]*n)*2+p)

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

— मिस्टर एक्सकोडर
स्रोत

Wat witchkraft yer footer है

— Nun

@LeakyNun A लूप के लिए :)

— श्री एक्सकोडर

नहीं, मैं f(i);एक अस्थायी में परिणाम को संग्रहीत करने और printइसे एक्सेस करने के बारे में बात कर रहा हूं ।

— लीक नून

1

@LeakyNun Ya गलत समझा: f(i)प्रिंट और printअजगर 2 में एक नई

— पंक्ति

ओह, कितना बेवकूफ है।

— लीक नून

6

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

ＮθＵＯ×²θ#ＵＯθ Ｆ²⟲ＯＯ²⁴⁶θ

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

Ｆ⁵Ｆ⁵Ｆ＆｜ικ¹«Ｊ×ιＩθ×κＩθＵＯθ#

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: #5 × 5 वर्गों की एक सरणी के रूप में विचार करके काम करता है । जो पंक्तियाँ विषम पंक्तियों या स्तंभों में होती हैं उन्हें भरने की आवश्यकता होती है।

— नील
स्रोत

क्या लकड़ी का कोयला वास्तव में एक हैशटैग आकार में निर्मित नहीं होता है?

— दिजिमा

क्या मैंने लकड़ी का कोयला O_O टाई किया था?

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

yay (हम्म लगता है कि मुझे थोड़ा ठीक करने की आवश्यकता है)

— ASCII-only

@ ASCII- केवल फिक्सिंग की क्या आवश्यकता है?

— नील

बहुवचन आंतरिक रूप से lol का उपयोग करने वाले बहुभुज के लिए चरणों को मुद्रित नहीं करना चाहिए

— केवल

6

जे, 22 बाइट्स

#('# '{~#:5$21,0)#~"1]

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

अन्य J उत्तर के साथ बहुत अधिक समानता है, हालांकि मैं बहुत सारी संज्ञाओं वाली गाड़ियों को अच्छी तरह से नहीं समझता, इसलिए मेरे जवाब में तीन संभावित बाइट्स (दो परेंस और एक रिफ्लेक्सिव- ~) हैं।

व्याख्या

अष्टकोण उत्पन्न करना

ऑक्टोथोरेप को पैरेंटिकल में सब कुछ द्वारा बनाया गया है, सुविधा के लिए नीचे पुन: प्रस्तुत किया गया है।

'# '{~#:5$21,0

जिस तरह से मैं ऑक्टोथोरपे बनाता हूं, उसका बहुत अधिक दुरुपयोग उस तरह से होता है, जब जे लंबे समय तक पर्याप्त नहीं होते हैं।

21,0बस सरणी बनाता है 21 0।

5$उस सरणी को 5-परमाणु सरणी में पुन: आकार देता है 21 0 21 0 21:।

#:प्रत्येक परमाणु को एक बाइनरी नंबर में परिवर्तित करता है। चूंकि #:प्रत्येक परमाणु पर काम करता है, आउटपुट एक मैट्रिक्स है। प्रत्येक 21की 1 0 1 0 1अपेक्षा के अनुसार प्रतिस्थापित किया जाता है, लेकिन प्रत्येक 0द्वारा प्रतिस्थापित किया जाता है 0 0 0 0 0! इसका कारण यह है कि जे पैड लंबे समय से पर्याप्त नहीं है जिसके परिणामस्वरूप 2D सरणी के आकार से मेल खाता है जो पंक्तियों के 5 5कारण मजबूर है 1 0 1 0 1। सौभाग्य से, संख्याओं के लिए यह पैड के साथ है 0, इसलिए हमें परिणामी मैट्रिक्स मिलता है

'# '{~1एक स्थान पर और 0करने के लिए प्रत्येक धर्मान्तरित #। {का अर्थ है "लेना" और ~इसका अर्थ है "डाइएडिक तर्कों को स्विच करना, इसलिए J मैट्रिक्स में प्रत्येक तत्व को देखता है क्योंकि स्ट्रिंग के लिए सूचक '# 'अर्थ है कि प्रत्येक 0शून्य तत्व बन जाता है, #और प्रत्येक 1पहला तत्व बन जाता है, एक स्थान। यह आकार को एक ऑक्टोकोर बनाता है।

अष्टकोणीय आकार का

यह बस nप्रत्येक धुरी के साथ समय की नकल करने का मामला है , उपयोग किया जाता है

पहला #(जो एक हुक का हिस्सा है) और #~"1]। #क्षैतिज अक्ष के #"1साथ प्रतियां और ऊर्ध्वाधर अक्ष के साथ प्रतियां।

— गोभी
स्रोत

1

##"1&('# '{~#:5$21,0)एक बाइट बचाता है।

— जर्बगर्बर 18'17

6

सीजेएम, 27 26 25 बाइट्स

{_[{S3*'#*'#5*}3*;]fe*e*}

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

मजेदार तथ्य: यह मूल रूप से 29 बाइट्स पर शुरू हुआ था, और बाइट्स को एक-एक करके हटा दिया गया है, ब्लॉक और फुल-प्रोग्राम मोड के बीच बारी-बारी से।

स्पष्टीकरण:

{                          e# Stack:               | 2
 _                         e# Duplicate:           | 2 2
  [                        e# Begin array:         | 2 2 [
   {                       e# Do the following 3 times:
    S                      e#   Push a space       | 2 2 [" "
     3*                    e#   Repeat it 3 times: | 2 2 ["   "
       '#*                 e#   Join with '#':     | 2 2 [" # # "
          '#               e#   Push '#':          | 2 2 [" # # " '#
            5*             e#   Repeat it 5 times: | 2 2 [" # # " "#####"
              }3*          e# End:                 | 2 2 [" # # " "#####" " # # " "#####" " # # " "#####"
                 ;         e# Delete top of stack: | 2 2 [" # # " "#####" " # # " "#####" " # # "
                  ]        e# End array:           | 2 2 [" # # " "#####" " # # " "#####" " # # "]
                   fe*     e# Repeat characters:   | 2 ["  ##  ##  " "##########" "  ##  ##  " "##########" "  ##  ##  "]
                      e*   e# Repeat strings:      | ["  ##  ##  " "  ##  ##  " "##########" "##########" "  ##  ##  " "  ##  ##  " "##########" "##########" "  ##  ##  " "  ##  ##  "]
                        }  e# End
e# Result:
e# ["  ##  ##  "
e#  "  ##  ##  "
e#  "##########"
e#  "##########"
e#  "  ##  ##  "
e#  "  ##  ##  "
e#  "##########"
e#  "##########"
e#  "  ##  ##  "
e#  "  ##  ##  "]

— फल तोड़ना
स्रोत

कोई इस चुनौती के लिए तैयार था: P

— ETHproductions

@ETHproductions यह एक CMC था और मुख्य रूप से स्थानांतरित हो गया ...

— फल

@ETHproductions वास्तव में उसे इसके लिए दोषी नहीं ठहरा सकते ...

— लीक

6

भूसी , 12 10 बाइट्स

´Ṫ▲Ṙ" # #

इसे ऑनलाइन आज़माएं! ट्रेलिंग स्थान पर ध्यान दें।

व्याख्या

´Ṫ▲Ṙ" # #   Implicit input, e.g. n=2.
   Ṙ" # #   Repeat each character of the string n times: "  ##  ##  "
´Ṫ          Outer product with itself by
  ▲         maximum: ["  ##  ##  ","  ##  ##  ","##########","##########","  ##  ##  ","  ##  ##  ","##########","##########","  ##  ##  ","  ##  ##  "]
            Print implicitly, separated by newlines.

— Zgarb
स्रोत

6

जे , 23 19 बाइट्स

' #'{~1=]+./~@#i:@2

@LeakyNun की बदौलत 4 बाइट्स बचाए।

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

व्याख्या

' #'{~1=]+./~@#i:@2  Input: integer n
                  2  The constant 2
               i:@   Range [-2, -1, 0, 1, 2]
        ]            Get n
              #      Copy each n times
         +./~@       GCD table
      1=             Equals 1, forms the hashtag for input 1
' #'{~               Index and select the char

— मील की दूरी पर
स्रोत

सत्यानाश! मेरे बारे में (4 बाइट लंबा) समाधान पोस्ट करने के बारे में था। मैं वास्तव में इस बात से प्रभावित हूँ कि आप बिना कैप और कुछ संयोजनों के इन कार्यों को कैसे कर सकते हैं।

— कोल

@cole धन्यवाद। कभी-कभी संज्ञा और डायड का उपयोग करके कैप से बचा जा सकता है। उदाहरण के लिए, [:|:fहो सकता है0|:f

— मील की दूरी पर

' # '{~]#"1]#+./~@i:@2एक बाइट बचाता है

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

गुणा करने से पहले दोहराएं आपको 19 बाइट्स देता है:f=:' #'{~1=]+./~@#i:@2

— लीक नून

1

@hoosierEE यह J 8.06 में आने वाला एक नया फीचर है। आप बीटा jsoftware.com/download/j806/install

— मील

5

जेली , 14 13 11 बाइट्स

2 बाइट्स @JonathanAllen की बदौलत सहेजे गए

5ẋ€Ẏ&þ`ị⁾ #

लाइनों की एक सूची लौटाने वाला एक विचित्र लिंक। ट्रेलिंग स्थान पर ध्यान दें।

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

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

5ẋ€Ẏ&þ`ị⁾ #    Main link. Arguments: n (integer)            1
5              Yield 5.
 ẋ€            Create a range and repeat each item n times. [[1], [2], [3], [4], [5]]
   Ẏ           Tighten; dump all sublists into the main list.
                                                            [1, 2, 3, 4, 5]
     þ         Create a table of                            [[1, 0, 1, 0, 1],
    &          bitwise ANDs,                                 [0, 2, 2, 0, 0],
      `        reusing this list.                            [1, 2, 3, 0, 1],
                                                             [0, 0, 0, 4, 4],
                                                             [1, 0, 1, 4, 5]]
       ị⁾ #    Index into the string " #".                   [" # # ",
               0 -> "#", 1 -> " ", 2 -> "#", etc.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]

— ETHproductions
स्रोत

बिटवाइज़ के बारे में अच्छा अवलोकन या - से या से स्विच करके और - कम करने की आवश्यकता को हटाकर, एक अंतर्निहित सीमा की अनुमति देने और µ(या ⁸आप के बजाय वहां हो सकता था) की आवश्यकता को दूर करने के लिए दो बाइट्स बचाएं ...5ẋ€Ẏ&þ`ị⁾ #

— जोनाथन एलन

@JonathanAllan दिलचस्प - क्यों की 5Ḷẋ€आवश्यकता µनहीं है, लेकिन 5ẋ€?

— ETHproductions

मुझे लगा कि जरूरत सिर्फ Ẏएक्टिंग को रोकने की है nऔर फिर इसे दाईं ओर ले जाने की है ẋ€, क्योंकि एक निलाद-डायड की प्रमुख श्रृंखला को मोनडली कहा जाता है, यह जरूरी नहीं है। हालाँकि, मैं निश्चित नहीं हूँ, फिर भी `लगता है कि तब 5 (या शायद उस लंबाई की सूची) को जगह क्यों दी गई है, &हालांकि यह सही है ।

— जोनाथन एलन

4

गेम मेकर लैंग्वेज, 138 108 बाइट्स

n=argument0 s=''for(j=0;j<5*n;j+=1){for(l=0;l<5*n;l+=1)if(j div n|l div n)&1s+='#'else s+=' 's+='
'}return s

एक स्क्रिप्ट के रूप में इरादा (उपयोगकर्ता द्वारा परिभाषित कार्यों के लिए गेम मेकर का नाम), इस प्रकार n=argument0और return s। 20 बाइट्स nवर्तमान उदाहरण से सीधे लेने और sपरिणाम के रूप में उपयोग करके मुंडा जा सकता है । (उदाहरण इन चरों को वैसे भी प्राप्त करता है क्योंकि वे घोषित नहीं किए गए थे var)।

पाठ्यक्रम से सावधान रहें जो #गेम मेकर के ग्राफिक्स सामान को एक वैकल्पिक न्यूलाइन वर्ण के रूप में उपयोग करता है, इसलिए \यदि आप स्क्रीन पर आउटपुट करना चाहते हैं, तो आप इसके साथ उपसर्ग करना चाहते हैं;)

यह भी ध्यान दें कि मैं यहाँ GML के गेम मेकर 8.0 के संस्करण का उपयोग कर रहा हूँ; आधुनिक GML संस्करणों में ऐसी विशेषताएं हो सकती हैं जो अतिरिक्त बाइट्स को बचा सकती हैं।

कुछ विचार दोस्तों के वेयरे और कॉर्डबग के सौजन्य से।

— एंड्रिया
स्रोत

मुझे लगता है कि यह पहला जीएमएल उत्तर है जो मैंने कभी देखा है

— टिमोथी ग्रो

@ टिमोथीग्रोट यह शर्म की बात है कि इसका अधिक उपयोग नहीं किया जाता है, इसके वैकल्पिक ब्रैकेट और अर्धविराम गोल्फिंग के लिए बहुत अच्छे हैं :)

— एंड्रिया

4

पर्ल 5 , 49 + 1 (-पी) = 50 बाइट्स

$_=' # # 
'=~s/./$&x$_/gre x$_;$_.=(y/ /#/r.$_)x2

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

कैसे?

-pफ्लैग के माध्यम से $ _ में इंप्लिमेंटली स्टोर करें । इसकी मूल " # # "नई लाइन के साथ सबसे मूल संभव शीर्ष रेखा से शुरू करें । इनपुट संख्या द्वारा उन वर्णों में से प्रत्येक को दोहराएं। फिर उस इनपुट संख्या द्वारा ऑक्टोथोरपे के शीर्ष भाग को बनाने के लिए, $ में उस सभी को वापस संग्रहीत करते हुए दोहराएं । फिर इनपुट नंबर को '#' के स्थान पर सभी वर्णों के साथ पंक्ति में जोड़ें। फिर शीर्ष अनुभाग जोड़ें। उन पिछले दो वाक्यों को कुल दो बार करें। $ का उत्पादन-p ध्वज में निहित है ।

— Xcali
स्रोत

मुझे पसंद है कि आपका जवाब मेरे जैसा ही पठनीय है।

— AdmBorkBork

उन्होंने हमेशा कहा है कि पर्ल एक केवल लिखने वाली भाषा है।

— Xcali

3

05AB1E , 25 22 21 बाइट्स

•LQ•bûε×}5ôεS„# èJ¹F=

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

-1 क्योंकि एमिग्ना अनुवादक से नफरत करती है और, शुक्र है, मुझे याद दिलाता है कि मुझे भी: पी।

यह बिटमैपिंग करने से बेहतर तरीका होगा ... फिर भी काम करना।

— जादू ऑक्टोपस Urn
स्रोत

प्रतिबिंब ... 05AB1E में इसका जवाब नहीं है, हालांकि ऐसा लगता है कि यह हो सकता है ...

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

5ôεS„# èJ¹F=एक बाइट बचाता है।

— एमिगा

@ इम्मिगा क्या इसके लिए अच्छा होगा?

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

संभवतः। मैंने अभी तक कैनवास की कोशिश नहीं की है इसलिए मैं वास्तव में इसकी क्षमताओं के बारे में निश्चित नहीं हूं। ऐसा लगता है कि यह कुछ के लिए बनाया गया है।

— एमिगा

3

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

f=
n=>[...Array(n*5)].map((_,i,a)=>a.map((_,j)=>` #`[(i/n|j/n)&1]).join``).join`
`

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

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

बिटमैप दृष्टिकोण के पोर्ट जो मैंने अपने मूल चारकोल प्रयास के लिए उपयोग किए हैं।

— नील
स्रोत

3

अजगर 2 , 124 , 116 , 113 , 112 , 98 , 96 66 बाइट्स

नया (क्रेडिट: हाइपरनेट्रिनो):

def f(a):i='print(" "*a+"#"*a)*2;'*a;exec(i+'print"#"*a*5;'*a)*2+i

पुराना:

a=input();b,c="# "
for i in"012":
	exec'print c*a+b*a+c*a+b*a;'*a
	if i<"2":exec'print b*a*5;'*a

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

स्पष्ट रूप से सबसे छोटा समाधान नहीं है, लेकिन मुझे लगता है कि यह सभ्य है। किसी भी तरह की प्रतिक्रिया सराहनीय है!

— ब्रेडन स्मिथ
स्रोत

1

a,b,c=input()," #"कुछ बाइट्स बचाना चाहिए।

— DJMcMayhem

@DJMcMayhem जिसने मुझे एक त्रुटि दी है। क्या आपका मतलब था a,b,c=input(),"#"," "? जो कोई छोटा नहीं है ... मैं मदद की सराहना करता हूं!

— ब्रेडन स्मिथ

मुझे माफ करें। मैंने मान लिया कि काम किया है क्योंकि a,b="# "काम करता है।

— DJMcMayhem

a=input();b,c="# "काम करेंगे और बाइट्स को बचाएंगे

— व्हीट विजार्ड

आप अंदर के पार्न्स से छुटकारा भी पा सकते हैं (i==2)और शुरुआत में एक स्थान जोड़ सकते हैं।

— गेहूं जादूगर

3

ब्रेन-फ्लैक , 338 332 बाइट्स

रिले को 6 बाइट्स धन्यवाद।

(({}<>)<(())>)(()()()()()){({}<(<>)<>{({}<<>({}<(((((()()()()())){})){}{}{})<>([({})]()){(<{}({}<((((({}))){}){}{}){({}<<>(({}))<>>[()])}{}>)>)}{}(({})<{{}(<(()()()()()){({}<<>(<([{}](((((()()){}){}){}){}()){}())>)<>{({}<<>({}<(({}))>())<>>[()])}<>({}<>{})>[()])}{}>)}>{})<>((()()()()()){})>())<>>[()])}<>({}<>{}<([{}]())>)>[()])}<>

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

अधिक "पठनीय" संस्करण

(({}<>)<(())>)(()()()()())
{({}<(<>)<>{({}<<>({}<(((((()()()()())){})){}{}{})<>
  ([({})]()){(<{}({}<
    ((((({}))){}){}{}){({}<<>(({}))<>>[()])}{}
  >)>)}{}(({})<{{}(<
    (()()()()()){({}<<>(<([{}](((((()()){}){}){}){}()){}())>)<>{({}<<>({}<(({}))>())<>>[()])}<>({}<>{})>[()])}{}
  >)}>{})
<>((()()()()()){})>())<>>[()])}<>({}<>{}<([{}]())>)>[()])}<>

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

— लीक नन
स्रोत

(({})<>)(())<>({}<>)शुरुआत में प्रतिस्थापित किया जा सकता है(({}<>)<(())>)

— रिले

2

SOGL (SOGLOnline प्रतिबद्ध 2940dbe) , 15 बाइट्स

ø─Ζ┘Χ⁴‘5n{.∙.*T

इसे चलाने के लिए, इसे डाउनलोड करें और index.htmlफ़ाइल में कोड चलाएं ।

उस पर उस का उपयोग करता है (और इससे पहले) *प्रत्येक चरित्र दोहराया, पूरे स्ट्रिंग नहीं।

स्पष्टीकरण:

ø─Ζ┘Χ⁴‘          push " # # ##### # # ##### # # "
       5n        split into lines of length 5
         {       for each line do
          .∙       multiply vertically input times
            .*     multiply horizontally input times
              T    output in a new line

बोनस: अलग एक्स और वाई लंबाई के लिए 2 इनपुट जोड़ें!

— dzaima
स्रोत

"कमिट 2940 डब्बे" - मुझे वह विचार पसंद है। क्या आप समझा सकते हैं ø─Ζ┘Χ⁴‘कि हालांकि धक्का क्यों ?

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

1

@MagicOctopusUrn यह SOGLs कम्प्रेशन है, जो यहाँ "" का शब्दकोश #और उस स्ट्रिंग के लिए आवश्यक आधार -2 डेटा संग्रहीत करता है।

— दिजिमा

नीट , क्या यह मेरे लिए पर्याप्त है का उपयोग शुरू करने के लिए :)?

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

1

@MagicOctopusUrn वैसे यह बहुत स्थिर है क्योंकि SOGLOnline के बाद से कोई उत्तर-विराम परिवर्तन नहीं हुआ है, लेकिन क्या आप इसका उपयोग कर सकते हैं (जैसा कि इसे समझें) एक और सवाल है। हालांकि आप कोशिश कर सकते हैं और TNB में प्रश्न पूछ सकते हैं

— dzima

Haha ... बीमार तो प्रलेखन के लिए प्रतीक्षा करें। मैं एक छोटे कोडित की जरूरत है।

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

2

ब्रेनफक , 224 बाइट्स

,[->+>>>>+<<<<<]>>>+>+++++[-<<<[->+>>>>>+>+++++[-<<<[->+<<<[->>>>>>+<<[->>>+>---<<<<]<<<<]>>>>>>[-<<<<<<+>>>>>>]>[-<<<+>>>]+++++[->+++++++<]>.[-]<<<<<<]>[-<+>]>[-<->]<+[->+<]>>]<<++++++++++.[-]<<<<<]>[-<+>]>[-<->]<+[->+<]>>]

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

के निर्माण

मैंने इस कोड को हाथ से बनाने की कोशिश की और कुछ घंटे बिताए, इसलिए मैंने पायथन में एक ट्रांसपिलर बनाने का फैसला किया।

यह कोड मैंने इस कोड को बनाने के लिए दर्ज किया है:

read(0)
copy(0,(1,1),(5,1))
add(3,1)
add(4,5)
loop(4)
loop(1)
add(2,1)

add(7,1)
add(8,5)
loop(8)
loop(5)
add(6,1)

loop(3)
add(9,1)
loop(7)
add(10,1)
add(11,-3)
end(7)
end(3)
copy(9,(3,1))
copy(10,(7,1))
add(10,5)
copy(10,(11,7))
write(11)
clear(11)

end(5)
copy(6,(5,1))
copy(7,(6,-1))
add(6,1)
copy(6,(7,1))
end(8)
add(6,10)
write(6)
clear(6)

end(1)
copy(2,(1,1))
copy(3,(2,-1))
add(2,1)
copy(2,(3,1))
end(4)

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

— लीक नन
स्रोत

2

सी (जीसीसी) , 98 93 बाइट्स

फेलिक्स पालमेन के लिए 5 बाइट्स धन्यवाद।

i,j;main(a){for(scanf("%d",&a);j<a*5||(j=!puts(""),++i<a*5);)putchar(i/a+1&j++/a+1&1?32:35);}

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

— लीक नन
स्रोत

2

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

 # ”ṫ&:Ṁ‡

ज़गरब के महान उत्तर का बहुत अधिक हिस्सा

इसे ऑनलाइन आज़माएं! (पाद लेख केवल सुंदर प्रिंट के लिए है, कार्यक्रम स्वयं वर्णों की 2 डी सूची लौटाता है)

व्याख्या

 # ”       Push the string " # "
    ṫ      Bounce, giving " # # "
     &     Repeat each character by input
      :    Copy
       Ṁ‡  Tabled maximum with itself

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

2

Befunge , 105 103 बाइट्स

p9p&5*08p>08g-   v
>,g1+:00p^v0:/5g8_p9g1+:09p08g-#v_@
gvg90\/\g0< # # ##### 0:/5g8,+55<
^>\/2%5*+92++2

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

— डेमूर ने अफवाह उड़ाई
स्रोत

आप एक ऑनलाइन दुभाषिया के लिए एक कड़ी जोड़ सकते हैं? tio.run/#befunge एक अच्छा AFAIK है।

— DJMcMayhem

1

पायथन, 88 84 77 बाइट्स

lambda x:[[(' #'[i//x%2]+'#')[j//x%2]for j in range(5*x)]for i in range(5*x)]

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

पात्रों की 2 डी सूची लौटाता है।

— Uriel
स्रोत

1

पॉवरशेल , 72 68 63 60 बाइट्स

param($a)(,($x=,((' '*$a+"#"*$a)*2)*$a)+,("#"*5*$a)*$a)*2;$x

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

इनपुट लेता है $a। फिर, हम ~~मैजिक~~ स्ट्रिंग और एरे हेरफेर का एक गुच्छा बनाते हैं।

(,($x=,((' '*$a+"#"*$a)*2)*$a)+,("#"*5*$a)*$a)*2;$x
         ' '*$a+"#"*$a                              # Construct a string of spaces and #
        (             )*2                           # Repeat it twice
      ,(                 )*$a                       # Repeat that $a times to get the top as an array
  ($x=                       )                      # Store that into $x and immediately output it
 ,                            +                     # Array concatenate that with ...
                               ,("#"*5*$a)          # another string, the middle bar ...
                                          *$a       # repeated $a times.
(                                            )*2;   # Do that twice
                                                 $x # Output $x again

आप विवरण के कुछ हिस्सों को नीचे से शुरू कर सकते हैं, यह देखने के लिए कि आउटपुट का निर्माण कैसे किया जाता है, इसलिए उम्मीद है कि मेरा स्पष्टीकरण समझ में आता है।

— AdmBorkBork
स्रोत

1

हास्केल, 72 बाइट्स

a#b=a++b++a++b++a
c%l=((c<$l)#('#'<$l))<$l
f n=(' '%[1..n])#('#'%[1..n])

तार की सूची लौटाता है। इसे ऑनलाइन आज़माएं!

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

a#b=a++b++a++b++a          -- concatenate the strings a and b in the given pattern
c%l=                       -- take a char c and a list l (we only use the length
                           -- of l, the actual content doesn't matter)
    c<$l                   -- make length l copies of c
         '#'<$l            -- make length l copies of '#'
        #                  -- combine them via function #
               <$l         -- and make length l copies of that string
f n=                       -- main function
              #            -- make the "a b a b a" pattern with the strings
                           -- returned by the calls to function %                                
    ' '%[1..n]             --   one time with a space 
               '#'%[1..n]  --   one time with a '#'

— nimi
स्रोत

1

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

ArrayFlatten@Array[x=#;Table[If[OddQ@-##," ","#"],x,x]&,{5,5}]&

व्याख्या

ArrayFlatten@Array[x=#;Table[If[OddQ@-##," ","#"],x,x]&,{5,5}]&  (* input N *)

                   x=#                                           (* Set x to N *)
                                                      &          (* A function that takes two inputs: *)
                             If[OddQ@-##," ","#"]                (* if both inputs are odd (1), " ". "#" otherwise *)
                       Table[                    ,x,x]           (* Make N x N array of that string *)
             Array[                                     ,{5,5}]  (* Make a 5 x 5 array, applying that function to each index *)
ArrayFlatten@                                                    (* Flatten into 2D array *)

_{(1) -##पर्स मेंTimes[-1, ##]}

— जंगहवान मिन
स्रोत

ArrayFlattenबहुत अच्छा है।

— मार्क एस।

1

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

तार की एक सरणी के रूप में:

r=[1-1*(i%(2*n)<n)for i in range(5*n)]
print[''.join(' #'[r[k]+r[j]>0]for k in range(len(r)))for j in range(n*5)]

ASCII कला के रूप में:

पायथन 3, 115 बाइट्स

r=[1-1*(i%(2*n)<n)for i in range(5*n)]
for j in range(n*5):print(*(' #'[r[k]+r[j]>0]for k in range(len(r))),sep='')

पायथन 3, 117 बाइट्स

p=range(5*n)
for i,e in enumerate([j%(2*n)>=n for j in p]for k in p):print(*[' #'[i%(2*n)>=n or k]for k in e],sep='')

~~बूलियन की एक सरणी के रूप में~~

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

p=range(5*n) f=lambda o:o%(2*n)>=n print[[f(j)or f(i)for j in p]for i in p]

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

1

लंबे समय तक, कोई देख नहीं :-)

— ETHproductions

हाँ यह है! @ETHproductions

— Zach गेट्स

1

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

लैम्ब्डा Integerऑक्टोथोरपे को मानक रूप से स्वीकार और प्रिंट करता है। कास्ट किया Consumer<Integer>।

n->{for(int s=5*n,x=0,y;x<s;x++)for(y=0;y<s;)System.out.print((x/n%2+y++/n%2>0?'#':32)+(y<s?"":"\n"));}

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

अघोषित लंबोदर

n -> {
    for (
        int
            s = 5 * n,
            x = 0,
            y
        ;
        x < s;
        x++
    )
        for (y = 0; y < s; )
            System.out.print(
                (x / n % 2 + y++ / n % 2 > 0 ? '#' : 32)
                + (y < s ? "" : "\n")
            );
}

कुंजी अवलोकन है कि यहाँ है, का एक ग्रिड 5 से 5 पर एन से n कोशिकाओं, octothorpes जहाँ भी पंक्ति या स्तंभ संख्या (0-आधारित) दिखाई अजीब है। मुझे पूरा यकीन है कि यह सबसे सस्ता सामान्य तरीका है, लेकिन ऐसा लगता है कि यह और अधिक गोल्फ है।

स्वीकृतियाँ

केविन क्रूज़सेन के लिए धन्यवाद

— जेकब
स्रोत

1

आप int s=5*n,x=0,yअर्धविराम पर बाइट को बचाने के लिए फॉर-लूप रख सकते हैं ।

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

1

पायथ , 28 22 बाइट्स

-6 बाइट्स @LeakyNun को धन्यवाद

JsC*]S5Qjmsm@"# "*kdJJ

परीक्षण सूट।

— मिस्टर एक्सकोडर
स्रोत

22 बाइट्स

— लीकी नून

@LeakyNun धन्यवाद, मैं वास्तव में अब तक इस जवाब को गोल्फ नहीं था।

— श्री एक्सकोडर

1

आर , 87 85 62 बाइट्स

m=matrix(" ",x<-scan()*5,x);m[s,]=m[,s<-rep(!1:0,e=x/5)]="#";m

सी (एफ, टी) के रूप में प्रतिनिधित्व करके 2 बाइट्स बचाए! 1: 0, LeakyNun के लिए धन्यवाद

23 बाइट्स ने ज्यूसेप को धन्यवाद दिया

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

स्पष्टीकरण (अपुष्ट):

x=scan()*5              # Multiply input by 5 to get the required width/height of the matrix
m=matrix(" ",x,x)       # Create a matrix of the required dimensions
s=rep(!1:0,each=x/5)    # The sequence s consists of F repeated n times, followed by T repeated n times
m[s,]="#"               # Use s as logical indices to set those rows as "#" characters.
                        # R recycles the sequence to the height of the matrix.
m[,s]="#"               # Same, with columns
write(m,"",x,,"")       # Print out across the required number of columns

— user2390246
स्रोत

यह TIO पर काम नहीं करता है क्योंकि यह अगली पंक्ति को स्कैन करता है, जो एक कोड है।

— लीक

समस्या को हल करने के लिए अर्धविराम के साथ नई कहानियों को बदलें

— लीक

1

85 बाइट्स

— लीकी नून

78 बाइट्स

— Giuseppe

एक समारोह के साथ 67 बाइट्स

— Giuseppe

#OctothorpeAsciiArt

परीक्षण के मामलों

MATL , 20 16 12 11 बाइट्स

व्याख्या

ब्रेन-फ्लैक , 420 बाइट्स

6502 मशीन कोड (C64), 59 56 बाइट्स

ऑनलाइन डेमो

हास्केल , 43 बाइट्स

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

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

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

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

जे, 22 बाइट्स

व्याख्या

अष्टकोण उत्पन्न करना

अष्टकोणीय आकार का

सीजेएम, 27 26 25 बाइट्स

स्पष्टीकरण:

भूसी , 12 10 बाइट्स

व्याख्या

जे , 23 19 बाइट्स

व्याख्या

जेली , 14 13 11 बाइट्स

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

गेम मेकर लैंग्वेज, 138 108 बाइट्स

पर्ल 5 , 49 + 1 (-पी) = 50 बाइट्स

05AB1E , 25 22 21 बाइट्स

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

अजगर 2 , 124 , 116 , 113 , 112 , 98 , 96 66 बाइट्स

ब्रेन-फ्लैक , 338 332 बाइट्स

अधिक "पठनीय" संस्करण

SOGL (SOGLOnline प्रतिबद्ध 2940dbe) , 15 बाइट्स

ब्रेनफक , 224 बाइट्स

के निर्माण

सी (जीसीसी) , 98 93 बाइट्स

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

व्याख्या

Befunge , 105 103 बाइट्स

पायथन, 88 84 77 बाइट्स

पॉवरशेल , 72 68 63 60 बाइट्स

हास्केल, 72 बाइट्स

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

व्याख्या

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

पायथन 3, 115 बाइट्स

पायथन 3, 117 बाइट्स

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

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

अघोषित लंबोदर

स्वीकृतियाँ

पायथ , 28 22 बाइट्स

आर , 87 85 62 बाइट्स