Знак числа, (також званий знак номера, хеш або хештегом, або знак фунта) є наступний ASCII символ:

#

Хіба це не забавна форма? Давайте робити більші версії! Тож ось ваше завдання:

З огляду на позитивне ціле число N , виводити ASCII - хештегом розміру N .

Наприклад, хештег ASCII розміром 1 виглядає так:

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

Пробіл пробілів у кожному рядку дозволений, але не обов’язковий.

Вхід завжди буде дійсним позитивним цілим числом, тому вам не доведеться обробляти не числа, мінус або 0. Ваш вихід може бути в будь-якому розумному форматі, тому виводимо в STDOUT, повертаючи список рядків або рядка з нові рядки, 2D матриця символів, запис у файл тощо.

Тестові справи

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

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

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

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

Оскільки це кодовий гольф, спробуйте написати найкоротше можливе рішення, і, перш за все, розважитися!

MATL , 20 16 12 11 байт

3 байти завдяки DJMcMayhem.

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

Мозок-Флак , 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
    {}

>[()])}

Машинний код 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)

Haskell , 43 байти

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

Спробуйте в Інтернеті!

Виводить список рядків.

Python 2 , 55 байт

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

Спробуйте в Інтернеті!

Це повертає двовимірний список символів.

Python 2 , 65 байт

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

Спробуйте в Інтернеті!

Python 2 , 66 байт

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

Спробуйте в Інтернеті!

Вугілля деревне , 21 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Я спочатку спробував милий підхід:

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення: Працює, розглядаючи #масив площею 5 × 5. Потрібно заповнити квадрати, що мають непарні рядки або стовпці.

J, 22 байти

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

Спробуйте в Інтернеті!

Дуже багато подібності до іншої відповіді J, хоча я не розумію добре поїздів з великою кількістю іменників, тому моя відповідь має три потенційні байти, які потрібно відрізати (два парени та рефлексивно- ~).

Пояснення

Породження октоторпа

Октоторп виготовляється всіма дужками, відтвореними нижче для зручності.

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

Багато з того, як я роблю октоторп, - це зловживання способом, який J прошиває своїми масивами, коли вони недостатньо довгі.

21,0просто створює масив 21 0.

5$перебудовує цей масив в масив 5-атом: 21 0 21 0 21.

#:перетворює кожен атом у двійкове число. Оскільки #:працює на кожному атомі, вихід є матрицею. Кожен 21замінюється, 1 0 1 0 1як очікувалося, але кожен 0замінюється 0 0 0 0 0! Це відбувається тому, що масиви J колодки недостатньо довгі, щоб відповідати формі отриманого 2D масиву, який змушений бути 5 5через 1 0 1 0 1рядки. На щастя, для чисел, з якими він прокладається 0, ми отримуємо отриману матрицю

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

'# '{~перетворює кожного 1в простір і 0в #. {означає "взяти" і ~означає "переключити діадичні аргументи, тому J дивиться на кожен елемент в матриці як на індекси для рядка, що '# 'означає, що кожен 0стає нульовим елементом, #а кожен 1стає першим елементом, пробілом. Це дає розмір один октоторп.

Зміна розмірів октоторпа

Це просто питання часу копіювання nвздовж кожної осі, зробленого за допомогою

перший #(який є частиною гачка) і #~"1]. #копії вздовж горизонтальної осі та #"1копії вздовж вертикальної осі.

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

Лушпиння , 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.

J , 23 19 байт

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

Збережено 4 байти завдяки @LeakyNun.

Спробуйте в Інтернеті!

Пояснення

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

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

Мова виробника ігор, 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).

Остерігайтесь, звичайно, що #графічні матеріали Game Maker використовуються як альтернативний символ нового рядка, тому ви можете скористатися префіксом, \якщо ви хочете вивести його на екран;)

Також зауважте, що тут я використовую версію GML Game Maker 8.0; сучасні версії GML можуть мати функції, які можуть економити додаткові байти.

Деякі ідеї люб'язно надано друзям складя та акорд.

Perl 5 , 49 + 1 (-p) = 50 байт

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

Спробуйте в Інтернеті!

Як?

Неодмінно зберігайте вхід у $ _ через -pпрапор. Почніть з найпростішого можливого верхнього рядка " # # "з його нижньої лінії . Повторіть кожен із цих символів на вхідний номер. Потім повторіть це на вхідний номер, щоб утворити верхню частину октоторпа, зберігаючи все це назад у $ . Потім додайте рядок із усіма символами, заміненими на "#" кратним числом введення. Потім додайте верхній розділ. Виконайте ці останні два речення загалом два рази. Виведення $ невідоме в -pпрапорі.

05AB1E , 25 22 21 байт

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

Спробуйте в Інтернеті!

-1 тому, що Еміньна ненавидить транслітерат і, на щастя, нагадує мені, що я повинен також: P.

Повинен бути кращий спосіб, ніж його растрове зображення ... Все ще працюю.

JavaScript (ES6), 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>

Порт растрового підходу, який я використав для моєї оригінальної спроби деревного вугілля.

Пітон 2 , 124 , 116 , 113 , 112 , 98 , 96 66 байт

Нове (кредит: HyperNeutrino):

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

Спробуйте в Інтернеті!

Очевидно, це не найкоротше рішення, але я думаю, що це гідне. Будь-який відгук буде вдячний!

Мозг-Флак , 338 332 байт

6 байт завдяки Райлі.

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

Спробуйте в Інтернеті!

Більш "читабельна" версія

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

Спробуйте в Інтернеті!

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 входи для окремих X та Y довжини!

мозковий ебать , 224 байти

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

Спробуйте в Інтернеті!

Виготовлення

Я спробував скласти цей код вручну і витратив досить багато годин, тому вирішив зробити транспілятор в Python.

Ось код, який я ввів, щоб зробити цей код:

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)

Спробуйте в Інтернеті!

C (gcc) , 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);}

Спробуйте в Інтернеті!

Гая , 9 байт

 # ”ṫ&:Ṁ‡

Досить велика відповідь порту Згарба

Спробуйте в Інтернеті! (нижній колонтитул призначений для симпатичного друку, програма сама повертає двовимірний список символів)

Пояснення

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

Befunge , 105 103 байт

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

Спробуйте в Інтернеті!

Пітон, 88 84 77 байт

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

Спробуйте в Інтернеті!

Повертає двовимірний список символів.

PowerShell , 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

Ви можете зняти частини пояснення, починаючи знизу, щоб побачити, як будується результат, тому, сподіваюся, моє пояснення має сенс.

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

Математика, 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, ##]}

Python 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:

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

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

Як масив булів

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 байти

Лямбда приймає 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 на n осередків октоторпи з’являються там, де число рядків чи стовпців (на основі 0) є непарним. Я впевнений, що це найдешевший загальний підхід, але здається, що це ще більше пограбує.

Подяка

• -1 байт завдяки Kevin Cruijssen

Pyth , 28 22 байт

-6 байт завдяки @LeakyNun

JsC*]S5Qjmsm@"# "*kdJJ

Тестовий сюїт.

R , 87 85 62 байт

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

2 байти збережено, представляючи c (F, T) як! 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