Bir Octothorpe (ayrıca sayı işareti, karma veya karma etiketi veya pound işareti olarak da bilinir) aşağıdaki ASCII karakteridir:

#

Bu eğlenceli bir şekil değil mi? Daha büyük versiyonlar yapalım! Yani burada senin zorluğun:

Pozitif bir tamsayı N verildiğinde , N büyüklüğünde bir ASCII hashtag çıktılar .

Örneğin, 1 boyutunda bir ASCII hashtag şuna benzer:

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

Her satırdaki iz boşluğuna izin verilir, ancak bu gerekli değildir.

Girdi her zaman geçerli bir pozitif tamsayı olacaktır, bu sayede sayılar, negatif ya da 0 ile uğraşmanıza gerek kalmaz. yeni satırlar, 2B karakter matrisi, bir dosyaya yazma vb.

Test durumları

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

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

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

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

Bu bir kod golfü olduğundan, mümkün olan en kısa çözümü yazmaya çalışın ve hepsinden önemlisi eğlenin!

MATL , 20 16 12 11 bayt

DJMcMayhem sayesinde 3 bayt.

Luis Mendo sayesinde 1 bayt.

21BwY"&*~Zc

Çevrimiçi deneyin!

açıklama

    % 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          ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
                                   ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  

Brain-Flak , 420 bayt

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

Çevrimiçi deneyin!

Hayır, 420 puan kasıtlı değildi. Söz veriyorum. Okunabilir sürüm:

# 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
    {}

>[()])}

6502 makine kodu (C64), 59 56 bayt

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

Çevrimiçi demo

Kullanım: SYS49152,Nburada N, 1 ile 255 arasında bir sayıdır.

_{(4'ten büyük değerler C64 ekranı için zaten 8'den başlayarak çok büyük olacaktır, çıktı çok geniş)}

Açıklama :

         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)

Haskell , 43 bayt

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

Çevrimiçi deneyin!

Dizelerin bir listesini çıkarır.

Python 2,55 bayt

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

Çevrimiçi deneyin!

Bu, 2B karakter listesini döndürür.

Python 2 , 65 bayt

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

Çevrimiçi deneyin!

Python 2 , 66 bayt

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

Çevrimiçi deneyin!

Kömür , 21 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Aslında şirin bir bitmap yaklaşımı denedim:

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama: #5 × 5 kareler dizisi olarak değerlendirilerek çalışır . Tek satır veya sütunlarda olan karelerin doldurulması gerekir.

J, 22 bayt

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

Çevrimiçi deneyin!

Diğer J cevabına pek çok benzerlik olsa da, çok sayıda isim içeren trenleri anlamam, ama cevabımın kesilmesi gereken üç potansiyel baytı var (iki parens ve bir dönüşlü- ~).

açıklama

Octothorpe oluşturma

Octothorpe parantez içindeki her şey tarafından üretilir, kolaylık sağlamak için aşağıda yeniden üretilir.

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

Octothorpe yapma yöntemimin çoğu, J'nin yeterince uzun olmadığı zaman dizilerini doldurma şeklini kötüye kullanmaktır.

21,0sadece diziyi yaratır 21 0.

5$5-atomu diziye bu diziyi yeniden şekillendirir: 21 0 21 0 21.

#:Her atomu ikili sayıya dönüştürür. İtibaren #:her atomu üzerinde çalışır, çıkış bir matrisidir. Her 21biri 1 0 1 0 1beklendiği gibi değiştirildi , ancak her 0biri tarafından değiştirildi 0 0 0 0 0! Bunun nedeni, J pedlerinin 5 5, 1 0 1 0 1sıralar nedeniyle olmaya zorlanan sonuçta oluşan 2D dizisinin şekline uyması için yeterince uzun olmayan diziler olmasıdır . Neyse ki, doldurduğu sayılar 0için sonuç matrisini alıyoruz

1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1

'# '{~Her dönüştüren 1bir boşluk ve 0etmek #. {aracı "al" ve ~araçlar "dizesini endeksleri olarak matris içinde her bir elemanın J görünüm çok diyadik bağımsız değişkenler geçiş '# 'her anlamına 0sıfırıncı elemanı olur #ve her bir 1birinci eleman, bir boşluk olur. Bu verim boyutu bir octothorpe.

Sekizgen'i yeniden boyutlandırma

Bu basitçe n, her bir eksen boyunca yapılan kopyalama zamanlarıdır,

ilk #(bir kanca parçası) ve #~"1]. #yatay eksen #"1boyunca kopyalar ve dikey eksen boyunca kopyalar.

CJam, 27 26 25 bayt

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

Çevrimiçi deneyin!

Eğlenceli gerçek: Bu başlangıçta 29 baytta başlatıldı ve bayt, o zamandan beri blok ve tam program modu arasında geçiş yaparak birer birer kaldırıldı.

Açıklama:

{                          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#  "  ##  ##  "]

Kabuğu , 12 10 bayt

´Ṫ▲Ṙ" # # 

Çevrimiçi deneyin! Sondaki boşluğa dikkat edin.

açıklama

´Ṫ▲Ṙ" # #   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.

J , 23 19 bayt

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

@LeakyNun sayesinde 4 bayt kaydedildi.

Çevrimiçi deneyin!

açıklama

' #'{~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

Jelly , 14 13 11 bayt

@JonathanAllen sayesinde 2 bayt kaydedildi

5ẋ€Ẏ&þ`ị⁾ #

Satır listesini döndüren bir monadik bağlantı. Sondaki boşluğa dikkat edin.

Çevrimiçi deneyin!

Nasıl çalışır

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.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]

Oyun Yapımcı Dili, 138 108 bayt

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

Bir komut dosyası olarak tasarlandı (Oyun Yapıcının kullanıcı tanımlı işlevler için adı), böylece n=argument0ve return s. 20 bayt, ndoğrudan mevcut durumdan alınarak sve sonuç olarak kullanılarak tıraş edilebilir. (Örnek bu değişkenleri yine de bildirilmediği için alır var).

#Game Maker'ın grafik öğelerinde alternatif bir yeni satır karakteri olarak kullanılan elbette dikkat edin , bu nedenle ekrana yazdırmak istiyorsanız önekini \eklemek isteyebilirsiniz;)

Ayrıca, Game Maker 8.0'ın GML sürümünü burada kullanıyorum. Modern GML sürümleri, ek baytları kurtarabilecek özelliklere sahip olabilir.

Bazı fikirler, arkadaşlar wareya ve akorba izniyle.

Perl 5 , 49 + 1 (-p) = 50 bayt

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

Çevrimiçi deneyin!

Nasıl?

Girdiyi -pbayrak üzerinden $ _ biçiminde saklayın . " # # "Sondaki yeni satırıyla mümkün olan en temel üst çizgi ile başlayın . Bu karakterlerin her birini giriş numarasına göre çoğaltın. Ardından, tüm bunları $ olarak geri saklayarak, octothorpe'un üst kısmını oluşturmak için girdi numarasına göre kopyalayın . Ardından, tüm karakterlerin yerine giriş numarasının '#' işareti ile satırı ekleyin. Sonra üst kısmı ekleyin. Son iki cümleyi toplam iki defa yap. $ Çıktı içkin olduğunu -pbayrak.

05AB1E , 25 22 21 bayt

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

Çevrimiçi deneyin!

-1 çünkü Emigna transliterattan nefret ediyor ve neyse ki bana şunu da hatırlatıyor: P.

Bit eşlemekten daha iyi bir yol olmalı ... Hala çalışıyor.

JavaScript (ES6), 79 bayt

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>

Orijinal Kömür girişimi için kullandığım bitmap yaklaşımının limanı.

Python 2 , 124 , 116 , 113 , 112 , 98 , 96 66 bayt

Yeni (Kredi: HyperNeutrino):

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

Eski:

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

Çevrimiçi deneyin!

Açıkçası en kısa çözüm değil, ama bence bu iyi. Herhangi bir geri bildirim takdir edilecektir!

Brain-Flak , 338 332 bayt

Riley sayesinde 6 bayt.

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

Çevrimiçi deneyin!

Daha "okunabilir" versiyon

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

Çevrimiçi deneyin!

SOGL (SOGLOnline 2940dbe kabul eder) , 15 bayt

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

Bu çalıştırmak için, karşıdan bu ve kod çalıştırmak index.htmldosyası.

Bu işleme bağlı olarak (ve ondan önce) *, karakterin tamamını değil her karakteri tekrarladı.

Açıklama:

ø─Ζ┘Χ⁴‘          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

Bonus: Ayrı X ve Y uzunluğu için 2 giriş ekleyin!

brainfuck , 224 bayt

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

Çevrimiçi deneyin!

Yapma-of

Bu kodu el ile oluşturmaya çalıştım ve birkaç saat harcadım, bu yüzden Python'da bir aktarıcı yapmaya karar verdim.

İşte bu kodu yapmak için girdiğim kod:

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)

Çevrimiçi deneyin!

C (gcc) , 98 93 bayt

Felix Palmen sayesinde 5 bayt.

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);}

Çevrimiçi deneyin!

Gaia , 9 bayt

 # ”ṫ&:Ṁ‡

Zgarb'ın büyük cevabının limanı

Çevrimiçi deneyin! (altbilgi sadece güzel baskı için, programın kendisi 2B bir karakter listesi döndürür)

açıklama

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

Befunge , 105 103 bayt

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

Çevrimiçi deneyin!

Python, 88 84 77 bayt

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

Çevrimiçi deneyin!

2B karakter listesini döndürür.

PowerShell , 72 68 63 60 bayt

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

Çevrimiçi deneyin!

Girdi alır $a. Sonra, bir grup sihirli ip ve dizi manipülasyonu yaparız .

(,($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

Çıktının nasıl yapıldığını görmek için açıklamanın kısımlarını baştan solarak çıkarabilirsiniz, umarım açıklamam anlamlı olur.

Haskell, 72 bayt

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

Dizelerin bir listesini döndürür. Çevrimiçi deneyin!

Nasıl çalışır:

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 '#'

Mathematica, 63 bayt

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

açıklama

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) -##ayrıştırılırTimes[-1, ##]}

Python 2, 113 bayt

Bir dizi dizesi olarak:

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 sanatı olarak:

Python 3, 115 bayt

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='')

Python 3, 117 bayt

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='')

Bir boolean dizisi olarak

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]

Java 8, 103 bayt

Lambda Integer, octothorpe'u kabul eder ve yazdırır. İçin attı 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"));}

Çevrimiçi Deneyin

Ungolfed lambda

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")
            );
}

İçin önemli bir sonuç buradan 5'e 5 bir ızgara üzerinde, yani n ile n- hücreleri, octothorpes satır ve sütun numarası (0 bazlı) her yerde görünür garip. Bunun en ucuz genel yaklaşım olduğundan eminim, ancak daha da golf oynayabilir gibi görünüyor.

Teşekkür

• Kevin Cruijssen sayesinde -1 bayt

Pyth , 28 22 bayt

@LeakyNun sayesinde -6 bayt

JsC*]S5Qjmsm@"# "*kdJJ

Test odası.

R , 87 85 62 bayt

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

LeakyNun sayesinde c (F, T) 'yi 1: 0 olarak temsil ederek kaydedilen 2 bayt

Giuseppe sayesinde 23 byte kurtarıldı

Çevrimiçi deneyin!

Açıklama (asılsız):

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