Знак числа, (также называемый знак номера, хэш или хэштегом, или знак фунта) является следующий ASCII символ:

#

Разве это не забавная форма? Давайте сделаем большие версии этого! Итак, вот ваш вызов:

Учитывая положительное целое число N , выводить ASCII - хэштегом размера N .

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

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

Конечный пробел в каждой строке разрешен, но не обязателен.

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

Контрольные примеры

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

Brain-Flak , 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

Попробуйте онлайн!

Это возвращает 2D список символов.

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-ответом, хотя я не очень хорошо понимаю поезда с большим количеством существительных, поэтому в моем ответе есть три потенциальных байта, которые нужно обрезать (два символа parens и reflexive- ~).

объяснение

Генерация октоторпа

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

'# '{~#: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-площадок недостаточно длинные, чтобы соответствовать форме результирующего двумерного массива, который должен быть 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.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]

Game Maker Language, 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

Предназначен как скрипт (название Game Maker для пользовательских функций), поэтому 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>

Порт растрового подхода, который я использовал для своей первоначальной попытки использования угля.

Python 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

Попробуйте онлайн!

Очевидно, не самое короткое решение, но я думаю, что оно достойное. Любая обратная связь будет оценена!

Brain-Flak , 338 332 байта

6 байтов благодаря Райли.

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

Попробуйте онлайн!

Более «читаемая» версия

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

Попробуйте онлайн!

SOGL (SOGLOnline commit 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);}

Попробуйте онлайн!

Gaia , 9 байт

 # ”ṫ&:Ṁ‡

В значительной степени порт Zgarb великий ответ

Попробуйте онлайн! (нижний колонтитул просто хорошенький, программа сама возвращает двумерный список символов)

объяснение

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

Попробуйте онлайн!

Python, 88 84 77 байт

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

Попробуйте онлайн!

Возвращает 2D список символов.

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

Mathematica, 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 байт благодаря Кевину Круйссену

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