#OctothorpeAsciiArt

35

Octothorpe, (zwany także liczba znak, hash lub hashtag lub znak funta) jest następujący znaków ASCII:

#

Czy to nie zabawny kształt? Zróbmy większe wersje! Oto twoje wyzwanie:

Biorąc dodatnia N , wydać hashtag ASCII rozmiarze N .

Na przykład hashtag ASCII o rozmiarze 1 wygląda następująco:

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

Końcowe białe znaki w każdej linii są dozwolone, ale nie są wymagane.

Dane wejściowe zawsze będą prawidłową liczbą całkowitą dodatnią, więc nie musisz obsługiwać liczb innych niż, ujemnych lub 0. Dane wyjściowe mogą być w dowolnym rozsądnym formacie, więc wyjście do STDOUT, zwrócenie listy ciągów lub ciągu z znaki nowej linii, matryca 2D znaków, zapis do pliku itp. są w porządku.

Przypadki testowe

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

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

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

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

Ponieważ jest to gra w golfa kodowego, spróbuj napisać możliwie najkrótsze rozwiązanie, a przede wszystkim dobrze się bawić!

DJMcMayhem
źródło
1
Powiązane
pppery

Odpowiedzi:

21

MATL , 20 16 12 11 bajtów

3 bajty dzięki DJMcMayhem.

1 bajt dzięki Luisowi Mendo.

21BwY"&*~Zc

Wypróbuj online!

Wyjaśnienie

    % 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          ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
                                   ##########
                                   ##########
                                     ##  ##  
                                     ##  ##  
Leaky Nun
źródło
1
Możesz użyć Zczamiast 35*ci ~(logiczne NIE) zamiast0=
DJMcMayhem
1
@DJMcMayhem @ _ @ dlaczego to jest wbudowane
Leaky Nun
1
W rzeczywistości powód, dla którego jest to wbudowane, jest naprawdę interesujący. Mogę się mylić, ale myślę, że Conor to zasugerował, a Suever napisał skrypt, który przegląda wszystkie odpowiedzi MATL-a, aby zobaczyć, jakie funkcje są bardziej powszechne w przyszłych ulepszeniach. Właśnie dodano
DJMcMayhem
Ponadto, ponieważ każda komórka musi być niezerowa, możesz to zrobić Qzamiast2<
DJMcMayhem
1
@LeakyNun Możesz zmienić !t*na &*. To ostatnie oznacza „mnożenie jednym wejściem”, które zwielokrotnia (pod względem elementu) wkład przez jego transpozycję
Luis Mendo
14

Brain-Flak , 420 bajtów

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

Wypróbuj online!

Nie, wynik 420 nie był celowy. Obiecuję. Wersja do odczytu:

# 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
źródło
13

Kod maszynowy 6502 (C64), 59 56 bajtów

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

Demo online

Zastosowanie: SYS49152,Ngdzie N jest liczbą od 1 do 255.

(wartości większe niż 4 będą już za duże dla ekranu C64, począwszy od 8, wyjście jest nawet zbyt szerokie)

Objaśnienie :

         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)

Screenshot

Felix Palmen
źródło
5
+1 za nostalgię (montaż 6502 na c64 był moim pierwszym doświadczeniem programistycznym ...)
Olivier Dulac
10

Haskell , 43 bajty

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

Wypróbuj online!

Wyświetla listę ciągów znaków.

xnor
źródło
8

Python 2 , 55 bajtów

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

Wypróbuj online!

Zwraca listę znaków 2D.

Python 2 , 65 bajtów

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

Wypróbuj online!

Python 2 , 66 bajtów

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

Wypróbuj online!

Pan Xcoder
źródło
Wat witchkraft jest twoją stopą
Leaky Nun
@LeakyNun A dla pętli :)
Mr. Xcoder
Nie, mówię o f(i);przechowywaniu wyniku w temp i printdostępie do niego.
Leaky Nun
1
@LeakyNun Ya źle zrozumiany: f(i)drukuje iw printPython 2 dodaje nowy wiersz: P
Mr. Xcoder
Och, jak głupio ze mnie.
Leaky Nun
6

Węgiel drzewny , 21 bajtów

NθUOײθ#UOθ F²⟲OO²⁴⁶θ

Wypróbuj online! Link jest do pełnej wersji kodu. Początkowo próbowałem uroczego podejścia do bitmapy:

F⁵F⁵F&|ικ¹«J×ιIθ×κIθUOθ#

Wypróbuj online! Link jest do pełnej wersji kodu. Objaśnienie: Działa, biorąc pod uwagę #tablicę 5 x 5 kwadratów. Kwadraty w nieparzystych rzędach lub kolumnach należy wypełnić.

Neil
źródło
czy węgiel drzewny tak naprawdę nie ma wbudowanego kształtu hashtaga?
dzaima
Czy zawiązałem węgiel drzewny O_O?
Magic Octopus Urn
yay (wygląda na to, że muszę to trochę naprawić)
tylko ASCII,
@ Tylko ASCII Co wymaga naprawy?
Neil,
Oblong nie powinien drukować kroków dla wielokąta, którego używa wewnętrznie lol
tylko ASCII
6

J, 22 bajty

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

Wypróbuj online!

Dużo podobieństwa do drugiej odpowiedzi J, chociaż nie rozumiem dobrze pociągów z wieloma rzeczownikami, więc moja odpowiedź ma trzy potencjalne bajty do odcięcia (dwa pareny i zwrotny-~ ).

Wyjaśnienie

Generowanie oktotorpe

Oktotorpe składa się z wszystkiego w nawiasach, które zostały przedstawione poniżej dla wygody.

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

Wiele sposobów, w jakie robię oktotorpe, polega na nadużywaniu sposobu, w jaki J wstawia tablice, gdy nie są wystarczająco długie.

21,0 po prostu tworzy tablicę 21 0 .

5$ przekształca tę tablicę w tablicę 5-atomową: 21 0 21 0 21 .

#:konwertuje każdy atom na liczbę binarną. Ponieważ #:działa na każdy atom, wyjście jest macierzą. Każdy 21jest zastąpiony przez 1 0 1 0 1zgodnie z oczekiwaniami, ale każdy 0jest zastąpiony przez 0 0 0 0 0! Wynika to z tego, że J wstawia tablice niewystarczająco długie, aby pasowały do ​​kształtu wynikowej tablicy 2D, która musi być z 5 5powodu 1 0 1 0 1wierszy. Na szczęście dla liczb, do których się wpisuje 0, otrzymujemy macierz wynikową

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

'# '{~konwertuje każdy 1na spację i 0na #. {oznacza „bierz” i ~oznacza „przełączaj argumenty dyadne, więc J patrzy na każdy element w macierzy jako wskaźniki dla ciągu, '# 'co oznacza, że ​​każdy 0staje się elementem zerowym #i każdy1 staje się pierwszym elementem, spacją.

Zmiana rozmiaru oktora

Jest to po prostu kwestia kopiowania nczasów wzdłuż każdej osi, wykonywanych za pomocą

pierwszy #(który jest częścią haka) i #~"1]. #kopiuje wzdłuż osi poziomej i #"1kopiuje wzdłuż osi pionowej.

kapusta
źródło
1
##"1&('# '{~#:5$21,0)zapisuje bajt.
Zgarb,
6

CJam, 27 26 25 bajtów

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

Wypróbuj online!

Ciekawostka: Początkowo zaczynało się od 29 bajtów i od tego czasu bajty były usuwane jeden po drugim, na przemian między trybem blokowym a pełnym programem.

Wyjaśnienie:

{                          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#  "  ##  ##  "]
Esolanging Fruit
źródło
Ktoś był przygotowany na to wyzwanie: P
ETHproductions
@ETHproductions To była CMC i przeniosła się do głównej ...
Esolanging Fruit
@ETHproductions Naprawdę nie mogę go za to winić ...
Leaky Nun
6

Łuska , 12 10 bajtów

´Ṫ▲Ṙ" # # 

Wypróbuj online! Zwróć uwagę na spację końcową.

Wyjaśnienie

´Ṫ▲Ṙ" # #   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
źródło
6

jot , 23 19 bajtów

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

Zaoszczędź 4 bajty dzięki @LeakyNun.

Wypróbuj online!

Wyjaśnienie

' #'{~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
mile
źródło
Szczury Właśnie miałem opublikować własne (4 bajty dłuższe) rozwiązanie. Jestem pod wielkim wrażeniem tego, jak możesz komponować te funkcje bez wielkich liter i kilku spójników.
cole
@cole Thanks. Czasami czapek można uniknąć, używając rzeczownika i diady. Na przykład [:|:fmoże być0|:f
mile
' # '{~]#"1]#+./~@i:@2zapisuje bajt
Conor O'Brien
powtórz, zanim pomnożenie da ci 19 bajtów:f=:' #'{~1=]+./~@#i:@2
Leaky Nun
1
@hoosierEE To nowa funkcja w J 8.06. Możesz wypróbować wersję beta jsoftware.com/download/j806/install
mile
5

Galaretka , 14 13 11 bajtów

Zaoszczędź 2 bajty dzięki @JonathanAllen

5ẋ€Ẏ&þ`ị⁾ #

Monadyczny link zwracający listę linii. Zwróć uwagę na spację końcową.

Wypróbuj online!

Jak to działa

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.             "#####",
                                                              " # # ",
                                                              "#####",
                                                              " # # "]
ETHprodukcje
źródło
Ładna obserwacja dotycząca bitów lub - zaoszczędź dwa bajty, przełączając się z lub na i - usuwając potrzebę obniżenia, pozwalając na ukryty zasięg i usuwając potrzebę µ(lub tego, co można było zamiast tego) ...5ẋ€Ẏ&þ`ị⁾ #
Jonathan Allan
@JonathanAllan Interesujące - dlaczego 5Ḷẋ€wymaga µ, ale nie 5ẋ€?
ETHprodukcje
Myślałem, że trzeba po prostu przestać działać, na następnie przekazać go na prawo od ẋ€, ponieważ w przypadku monadycznego wywoływania łańcucha wiodącego nilad-diada nie jest to konieczne. Nie jestem jednak do końca pewien, jak `wydaje się umieszczać 5 (a może listę tej długości) po prawej stronie tabeli &.
Jonathan Allan,
4

Game Maker Language, 138 108 bajtów

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

Przeznaczony jako skrypt (nazwa Game Game'a dla funkcji zdefiniowanych przez użytkownika), a zatem n=argument0i return s. 20 bajtów można ogolić, pobierając nbezpośrednio z bieżącej instancji i wykorzystując sjako wynik. (Instancja i tak pobiera te zmienne, ponieważ nie zostały zadeklarowane za pomocąvar ).

Uważaj oczywiście, że elementy #graficzne Game Makera są używane jako alternatywny znak nowej linii, więc możesz chcieć poprzedzić go\ jeśli chcesz wyświetlać na ekranie;)

Zauważ też, że tutaj używam wersji GML Game Maker 8.0; nowoczesne wersje GML mogą mieć funkcje, które mogłyby zaoszczędzić dodatkowe bajty.

Kilka pomysłów dzięki uprzejmości znajomych Wareya i Chordbug.

Andrea
źródło
Myślę, że to pierwsza odpowiedź GML, jaką kiedykolwiek widziałem
Timothy Groote,
@TimothyGroote Szkoda, że ​​nie jest więcej używany, jego opcjonalne nawiasy i średniki są świetne do gry w golfa :)
Andrea
4

Perl 5 , 49 + 1 (-p) = 50 bajtów

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

Wypróbuj online!

W jaki sposób?

Niejawnie przechowuj dane wejściowe w $ _ za pomocą -pflagi. Zacznij od najbardziej podstawowej możliwej górnej linii " # # "z końcową nową linią. Skopiuj każdy z tych znaków według numeru wejściowego. Następnie powtórz to przez liczbę wejściową, aby utworzyć górną część oktotypu, przechowując wszystko z powrotem w $ . Następnie dodaj wiersz ze wszystkimi znakami zastąpionymi przez „#” razy liczba wejściowa. Następnie dołącz górną część. Wykonaj dwa ostatnie zdania dwa razy. Wyjście $ jest niejawne w -pflagi.

Xcali
źródło
Podoba mi się, że twoja odpowiedź jest tak samo czytelna jak moja.
AdmBorkBork,
Zawsze mówili, że Perl jest językiem tylko do zapisu.
Xcali,
3

05AB1E , 25 22 21 bajtów

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

Wypróbuj online!


-1, ponieważ Emigna nienawidzi transliteracji i, na szczęście, przypomina mi też, że powinnam: P.


Musi być lepszy sposób niż bitmapowanie ... Nadal działa.

Urna Magicznej Ośmiornicy
źródło
Refleksja ... nie jest odpowiedzią w 05AB1E, choć wydaje się, że mogłaby być ...
Magic Octopus Urn
5ôεS„# èJ¹F=zapisuje bajt.
Emigna
@Emigna byłaby do tego odpowiednia?
Magic Octopus Urn
Możliwie. Nie wypróbowałem jeszcze płótna, więc nie jestem pewien jego możliwości. Wygląda na coś, do czego został stworzony.
Emigna,
3

JavaScript (ES6), 79 bajtów

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>

Port podejścia do bitmapy, którego użyłem podczas mojej oryginalnej próby z węglem drzewnym.

Neil
źródło
3

Python 2 , 124 , 116 , 113 , 112 , 98 , 96 66 bajtów

Nowość (Źródło: HyperNeutrino):

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

Stary:

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

Wypróbuj online!

Oczywiście nie jest to najkrótsze rozwiązanie, ale myślę, że jest przyzwoite. Wszelkie uwagi będą mile widziane!

Braeden Smith
źródło
1
a,b,c=input()," #"powinien zapisać niektóre bajty.
DJMcMayhem
@DJMcMayhem To dało mi błąd. Miałeś na myśli a,b,c=input(),"#"," "? Co nie jest krótsze ... Doceniam pomoc!
Braeden Smith,
Przepraszam. Zakładałem, że to a,b="# "działa, ponieważ działa.
DJMcMayhem
a=input();b,c="# "będzie działać i zapisywać bajty
Wheat Wizard
Możesz także pozbyć się parenów (i==2)i dodać spację na początku.
Wheat Wizard
3

Brain-Flak , 338 332 bajtów

6 bajtów dzięki Riley.

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

Wypróbuj online!

Bardziej „czytelna” wersja

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

Wypróbuj online!

Leaky Nun
źródło
(({})<>)(())<>({}<>)na początku można zastąpić(({}<>)<(())>)
Riley,
2

SOGL (SOGLOnline commit 2940dbe) , 15 bajtów

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

Aby to uruchomić, pobierz to i uruchom kod z index.htmlpliku.

Używa, że ​​przy tym zatwierdzeniu (i przed nim) *powtarzano każdy znak, a nie cały ciąg.

Wyjaśnienie:

ø─Ζ┘Χ⁴‘          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: dodaj 2 dane wejściowe dla osobnej długości X i Y!

dzaima
źródło
"commit 2940dbe" - I like that idea. Can you explain why ø─Ζ┘Χ⁴‘ pushes that though?
Magic Octopus Urn
1
@MagicOctopusUrn That's SOGLs compression, which here stores a dictionary of " " and # and the base-2 data required for that string.
dzaima
Neat, is it stable enough for me to start using :)?
Magic Octopus Urn
1
@MagicOctopusUrn Well it's pretty stable as there have been no answer-breaking changes since SOGLOnline, but whether you can use it (as in understand it) is another question. You can try though and ask question in TNB
dzaima
Haha... Ill wait for documentation then. I do need coddled a little.
Magic Octopus Urn
2

brainfuck, 224 bytes

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

Try it online!

Making-of

I tried to build this code by hand and spent quite a few hours, so I decided to make a transpiler in Python.

Here is the code I entered to make this code:

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)

Try it online!

Leaky Nun
źródło
2

C (gcc), 98 93 bytes

5 bytes thanks to Felix Palmen.

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

Try it online!

Leaky Nun
źródło
2

Gaia, 9 bytes

 # ”ṫ&:Ṁ‡

Pretty much a port of Zgarb's great answer

Try it online! (the footer is just to pretty print, the program itself returns a 2D list of characters)

Explanation

 # ”       Push the string " # "
    ṫ      Bounce, giving " # # "
     &     Repeat each character by input
      :    Copy
       Ṁ‡  Tabled maximum with itself
Business Cat
źródło
2

Befunge, 105 103 bytes

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

Try it online!

Demur Rumed
źródło
Could you add a link to an online interpreter? tio.run/#befunge is a good one AFAIK.
DJMcMayhem
1

Python, 88 84 77 bytes

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

Try it online!

Returns 2D list of characters.

Uriel
źródło
1

PowerShell, 72 68 63 60 bytes

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

Try it online!

Takes input $a. Then, we do a bunch of magic string and array manipulation.

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

You can peel off the parts of the explanation starting from the bottom to see how the output is constructed, so hopefully my explanation makes sense.

AdmBorkBork
źródło
1

Haskell, 72 bytes

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

Returns a list of strings. Try it online!

How it works:

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
źródło
1

Mathematica, 63 bytes

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

Explanation

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)-## parses into Times[-1, ##]

JungHwan Min
źródło
ArrayFlatten is very nice.
Mark S.
1

Python 2, 113 bytes

As an array of strings:

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)]

As ASCII art:

Python 3, 115 bytes

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 bytes

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

As an array of booleans

Python 2, 75 bytes

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 Gates
źródło
1
Long time, no see :-)
ETHproductions
Yes, it has! @ETHproductions
Zach Gates
1

Java 8, 103 bytes

Lambda accepts Integer and prints the octothorpe to standard out. Cast to 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"));}

Try It Online

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

The key observation here is that, on a 5 by 5 grid of n by n cells, octothorpes appear wherever the row or column number (0-based) is odd. I'm pretty sure this is the cheapest general approach, but it seems further golfable.

Acknowledgments

  • -1 byte thanks to Kevin Cruijssen
Jakob
źródło
1
You can place the int s=5*n,x=0,y instead the for-loop to save a byte on the semicolon.
Kevin Cruijssen
1

R, 87 85 62 bytes

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

2 bytes saved by representing c(F,T) as !1:0, thanks to LeakyNun

23 bytes saved thanks to Giuseppe

Try it online!

Explanation (ungolfed):

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
źródło
It doesn't work on TIO because it scans the next line, which is a code.
Leaky Nun
1
85 bytes
Leaky Nun
78 bytes
Giuseppe