Tantangan

Dengan ukuran s, cetak jaring kubus dengan ukuran itu terbuat dari simbol hash ( #) dan spasi ( ).

Contoh:

1:
  #
# # #    
  #
  #

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

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

Jaring sebenarnya bisa berupa jaring kubus apa pun yang valid yang dapat dilipat menjadi kubus, misalnya ini:

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

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

Aturan

• Jaring yang dihasilkan harus valid secara geometris (dapat dilipat menjadi kubus)
• Celah standar dilarang
• Baca aturannya dengan cermat
• Ini kode-golf , jawaban terpendek menang, tetapi tidak akan dipilih

Python 2, 47 byte

n=input()
for c in 1,4,1:exec"print'# '*c*n;"*n

Cobalah online!

Mencetak jaring ini, dipilih karena dibenarkan kiri:

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

Garis-garis memiliki natau 4*nsalinan '# '. Untuk masing-masing 1,4,1, kami mencetak nwaktu yang banyak salinan, dilakukan nkali untuk ngaris. Memiliki execloop di dalam forloop tampaknya sia-sia, tetapi saya tidak melihat lebih baik.

Alternatif yang saya uji:

lambda n:('# '*n*3+'\n')*n+('  '*n+'# '*n+'\n')*3*n

lambda n:('# '*n*3+'\n')*n+(' '*4*n+'# '*n*3+'\n')*n

def f(n):
 for c in[3]*n+[1]*3*n:print('# '*c*n).center(6*n)

def f(n):
 for c in[4]*n+[0]*n:print' '*c*n+'# '*n*3

def f(n):
 for c in[1]*n+[4]*n+[1]*n:print'# '*c*n

def f(n):
 c=1;exec("print'# '*c*n;"*n+"c^=5;"*n)*3

def f(n):
 for i in range(3*n):print'# '*[1,4,1][i/n]*n

def f(n):
 for c in 1,4,1:print('# '*c*n+'\n')*n,

def f(n):
 for c in 1,4,1:exec"print'# '*c*n;"*n

(Semua deffungsi dapat menjadi lebih pendek sebagai sebuah program.)

Oktaf, 58 44 42 32 byte

@(n)[z=repmat('# ',n);z,z,z,z;z]

sebagian terinspirasi oleh jawaban python @xnor.

z=repmat('# ',n);

membuat pola squre '#' untuk input 2 menghasilkan pola berikut:

# #             
# # 

y=[z,z,z,z];

empat zs digabungkan secara horizontal:

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

[z;y;z]

z dan y dan zdigabungkan secara vertikal

Cobalah secara Online!

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

Jawaban sebelumnya:

@(n){h(1:n,1:2:n*6)=1;h(1:n*4,n*2+1:2:4*n)=1;' #'(h+1)}{3}

Cobalah secara Online!

Menghasilkan yang berbentuk T

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

Mathematica, 77 60 52 byte

Terima kasih kepada Martin Ender untuk bermain golf sejauh 8 byte!

{±s_:=s~Table~#;b=±{a=±"# ","
"},±{a,a,a,a,"
"}}<>b&

Fungsi tanpa nama mengambil argumen integer positif #dan mengembalikan string dengan baris baru (termasuk baris baru); setiap baris memiliki ruang trailing juga. Pertama kita mendefinisikan ±sebagai fungsi yang mengulang #waktu inputnya ; kemudian adidefinisikan sebagai ±"# "(ini #adalah karakter, bukan input!), dan dari yang bdidefinisikan sebagai himpunan #garis pendek, sedangkan ±{a,a,a,a}<>nhimpunan #garis panjang. (Dalam kedua kasus, ada linefeed literal antara kutipan yang cocok.) Final <>bmenyatukan daftar string yang dihasilkan dengan salinan kedua dari set baris pendek. Contoh keluaran ketika #=2( jawaban xnor mengajari saya bahwa orientasi ini lebih golf):

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

Versi sebelumnya dari implementasi ini:

""<>(±s_:=s&~Array~#;{b=±{a=±"# ",n="\n"},±{a,a,a,a}<>n,b})&

Pengajuan asli:

""<>If[(m=n~Mod~t)==0,"\n",If[n<t#||#<m<=2#,"# ","  "]]~Table~{n,4(t=3#+1)#}&

Membangun keluar string 4*(3#+1)buah, masing-masing yang baik "# ", " "atau "\n"; cukup hitung potongan mana yang akan digunakan berdasarkan indeks n. Contoh output ketika #=2:

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

JavaScript (ES6), 59 byte

f=
n=>`141`.replace(/./g,m=>`${`# `.repeat(n*m)}\n`.repeat(n))

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

Output mencakup spasi tambahan di akhir setiap baris dan baris tambahan tambahan.

Ruby, 36 byte

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}

Pemakaian:

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}
f[3]
# # #
# # #
# # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # #
# # #
# # #

Ruby, 38 byte

Bentuk ini lebih panjang di Ruby tapi saya berharap ada beberapa bahasa yang lebih pendek.

->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}

Pemakaian:

g=->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}
g[3]
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #

Kedua jawaban bisa lebih pendek jika diizinkan untuk mengembalikan (lebih disukai) serangkaian string atau (kurang disukai) string tunggal daripada mencetak.

Scala, 56 byte

(n:Int)=>Seq(1,4,1)map("# "*_*n+"\n")map(_*n)mkString ""

JavaScript (ES6), 71

n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

Uji

f=
n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

function update() {
  O.textContent=f(I.value)
}

update()

<input id=I type=number value=3 oninput='update()'><pre id=O></pre>

Java 8, 99 byte

l->{for(int i=-1,j;++i<3*l;)for(j=-1,k=(i/l==2)?4*l:l;++j<k;)System.out.print("# "+j>k-2?"\n":"");}

V , 24 23 20 18 20 byte

Ài# ddÀpLyGïp3PGïp

Dengan semua karakter tersembunyi ditampilkan

Ài# ^[ddÀp^VLyGïp3PGoïp

^[is 0x1b(escape character literal) dan ^Vis 0x16( C-v)

Cobalah online!

Saya harus meningkatkan bytecount karena Äperintah sedang buggy dalam tarikan V baru ini

Output dalam format ini:

# 
# # # # 
# 

dengan baris baru terkemuka

Hexdump:

00000000: c069 2320 1b64 64c0 7016 4c79 47ef 7033  .i# .dd.p.LyG.p3
00000010: 5047 ef70                                PG.p

Penjelasan

Ài# ^[              " Argument times insert "# "
ddÀp                " Argument times duplicate line

Sekarang setelah satu sisi jaring telah selesai, kita harus membuat jaring

^VLy                " Copy the face
Gïp                 " Paste it at the end of buffer
3P                  " Paste 3 times (these form the line)
Gïp                 " Paste at end of buffer again

Solusi alternatif jika kami tidak menampilkan spasi:

21 20 18 16 18 byte

Àé#ddÀpLyGïp3pGïp

(untuk alasan yang sama dengan solusi teratas, tautan TIO ini dimodifikasi)

Cobalah online!

V , 14 byte (tidak bersaing)

Ài# 5Ù4JjòÀÄk

Cobalah online!

00000000: c069 2320 1b35 d934 4a6a f2c0 c46b       .i# .5.4Jj...k

Untuk alasan apa pun, tantangan ini menemukan banyak bug. Sekarang semuanya sudah diperbaiki, sayangnya versi ini tidak bersaing, tetapi senang melihat seperti apa jawaban V untuk tantangan ini ketika tidak perlu menambahkan banyak byte untuk mengikuti kode ceroboh saya.

Penjelasan:

À                   " Arg 1 times:
 i# <esc>           "   Insert the string "# "
         5Ù         " Make 5 copies of this line, and put the cursor on the second copy
           4J       " Join four of these lines together
             j      " Move down to the last line
              ò     " Recursively:
               ÀÄ   "   Make Arg 1 copies of this line
                 k  "   And move up a line

Jelly , 20 19 byte

”#xẋ³Wẋ³K€Y
141DÇ€Y

Cobalah online!

-1 Terima kasih kepada 44874 (steenbergh).

^{AKU TIDAK BISA OUTGOLF MUDDYFISH BANTUAN!}

Apakah golf ini ??? 20 19 byte sepertinya terlalu banyak , melihat Link 1.

Penjelasan:

”#xẋ³Wẋ³K€Y Helper link. Arguments: z
”#          Character #.
            y (implicit)
  x         Repeat each element of y x times.
    ³       1st command-line argument.
   ẋ        Repeat x y times.
     W      Wrap z.
       ³    1st command-line argument.
      ẋ     Repeat x y times.
        K   Join z on spaces.
         €  Map this link on x.
          Y Join z on newlines.

141DÇ€Y Main link. Arguments: 0
141     Integer 141.
   D    Convert z to base 10.
    Ç   The above link as a monad.
     €  Map this link on x.
      Y Join z on newlines.

Arang , 20 byte

ＮλＧ↑λ←×⁶λ↓λ# ＤＭ×⁴λ← 

Kode berakhir dengan spasi. Cobalah online!

Penjelasan

Arang adalah bahasa yang berspesialisasi dalam seni ASCII. Ini juga tidak lengkap, bermasalah, dan kurang didokumentasikan. Cukuplah untuk mengatakan, ini membutuhkan cukup banyak trial and error sebelum melakukan apa yang seharusnya.

• Ｎλmemasukkan nomor ke dalam λ.
• Ｇadalah perintah poligon, yang akan kita gunakan di sini untuk menggambar persegi panjang. ↑λ←×⁶λ↓λmenentukan batas poligon: λlangkah ke atas , langkah ke kiri 6 kali λ, dan λlangkah ke bawah . (Itu tiga λdengan λblok sisi-by-side.) Tepi bawah persegi panjang disimpulkan. Poligon kemudian diisi dengan string # .
• Ｄ membuang kanvas saat ini ke stdout, menghasilkan sesuatu seperti ini:

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

• Setelah Ｇperintah, kursor berada di sudut kiri bawah kanvas. Ｍ×⁴λ←bergerak itu ke kiri dengan 4 kali λlangkah (setara dengan dua λoleh λblok).
• menghasilkan ruang di sana, memperluas kanvas ke kiri dengan jumlah yang benar.
• Di akhir program, kanvas dikirim kembali ke stdout:

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

Menyatukan mereka dan Anda punya jaring kubus.

Utilitas Bash / Unix, 72 69 68 66 byte

b()(yes `dc<<<2o4d$n^$1^3/p`|tr 01 ' #'|head -$n);n=$1;b 1;b 4;b 1

Cobalah online!

Ini bekerja dengan menggunakan fakta bahwa [4 ^ k / 3], ketika ditulis dalam basis 2, adalah 10101010 ... 01, dengan k 1. (Kurung kotak disini menunjukkan fungsi lantai.)

Pyke, 16 byte

uAD,sXF**"# 

Coba di sini!

Setara dengan

1 4 1]3AD,sXF**"# 

Karena tidak diinginkan

Ini menggunakan beberapa trik untuk menurunkan byte-count:

• Ini menggunakan beberapa unsintables untuk mewakili daftar [1, 4, 1]
• XF secara otomatis membuang output ke stack
• String "#pada akhirnya ditukar dengan yang terakhir *, yang berarti bahwa penutupan "tidak diperlukan. Ini terjadi secara implisit ketika token terakhir adalah string.

u                -      [1, 4, 1]
     AD          -     apply(*, ^, input)
       ,         -    zip(^)
        s        -   sum(^)
          F**"#  -  for i in ^:
           *     -    ^ * input
            *    -   ^ * v
             "#  -    "# "
         X       - splat(^)

Python 2 , 68 71 65 byte

-6 dengan terima kasih kepada @sagiksp

def f(i,c=1):
 print(' '*i*4,'')[c>i]+'# '*i*3
 if i*2>c:f(i,c+1)

Cobalah online!

Dengan tidak adanya menemukan cara untuk mengalahkan @ xnor saya akan memposting fungsi rekursif saya hanya sebagai pendekatan alternatif. Untuk f (5) cetakan

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

Pola ini dipilih hanya karena dapat dibagi menjadi dua bagian tidak seperti yang lainnya.

PHP, 64 62 byte

Disimpan 2 byte berkat Christoph .

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("
",$a,"# ");

Mencetak jaring seperti ini:

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

(dengan baris baru terkemuka)

Batch, 111 byte

@set s=
@set i=@for /l %%i in (1,1,%1)do @
%i%call set s=%%s%% #
%i%echo%s%
%i%echo%s%%s%%s%%s%
%i%echo%s%

Pushy , 32 29 28 byte

Mencetak jaring kubus dibenarkan kiri. Ini sulit untuk golf ...

&V:`# `;{:";N^:4:";T'.;TD^:"

Cobalah online!

Retina , 39 37 byte

Ini adalah pertama kalinya saya menggunakan Retina, saya masih mencoba memahami cara melakukan sesuatu.

.+
$*#
#
# 
\`# 
$_¶
G`.
)*%`^
$_$_$_

(dengan dua spasi tambahan setelah baris ke-4 dan ke-5)

Terima kasih kepada Martin Ender untuk bermain golf 2 byte!

Cobalah online!

QBIC , 52 67 40 byte

Lengkap menulis ulang:

:[a*3|G=G+@#`][a*2|G=G+@ `][a|?G][a|?_fG

Ini sekarang menggunakan pola ini:

###--
--###

Di mana -diisi dengan spasi.

:        Read 'a' from the command line        > Assume 3
[a*3|    Create 3 segments times 'a' filling   > 3*3 = 9
G=G+@#`] Define A$ to be '#' and add this to G > G = "#########" 
[a*2|    Create 2 segments times 'a' spacer
G=G+@ `] Define B$ to be ' ' and add this to G > G = "#########       " 
[a|      FOR d == 1; d <= a; d++
?G]      Display G$:
            "#########       " 
            "#########       " 
            "#########       " 
[a|      FOR e == 1; e <= a; e++
?_fG     Display G$ in reverse (_f...|):
            "      #########" 
            "      #########" 
            "      #########" 
         (For loop and function call to Flip impicitly closed by QBIC)

Pip , 28 17 16 byte

15 byte kode, +1 untuk -nbendera.

"# "Xa*_RLaM141

Mengambil ukuran sebagai argumen baris perintah. Cobalah online!

Penjelasan

                 a is 1st cmdline arg
       _         Build a lambda function
     a*          (a) times argument
"# "X            Repeat string "# " that many times
        RLa      Wrap in a list and repeat list (a) times
           M141  Map that function to the characters of 141
                 Autoprint (-n flag separating list items with newlines)

Berikut ini tidak persis bagaimana data akan dimodifikasi, tetapi memberikan ide dasar (untuk a=2):

141

[1;4;1]

[2;8;2]

["# # ";"# # # # # # # # ";"# # "]

[["# # ";"# # "];["# # # # # # # # ";"# # # # # # # # "];["# # ";"# # "]]

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

05AB1E , 13 byte

D141S×S*„# ×»

Cobalah online!

Penjelasan

Contoh input n=2

D              # duplicate input
               # STACK: 2, 2
 141S          # push the list [1,4,1]
               # STACK: 2, 2, [1,4,1]
     ×         # repeat each item in the list input_no times
               # STACK: 2, [11, 44, 11]
      S        # split into list of digits
               # STACK: 2, [1, 1, 4, 4, 1, 1]
       *       # multiply each digit with input
               # STACK: [2, 2, 8, 8, 2, 2]
        „# ×   # repeat the string "# " for each item in the list
               # STACK: ['# # ','# # ','# # # # # # # # ','# # # # # # # # ','# # ','# # ']
            »  # join by newlines
               # OUTPUT: # # 
                         # # 
                         # # # # # # # # 
                         # # # # # # # # 
                         # # 
                         # # 

C #, 152 byte

n=>{var m="";foreach(int c in new[]{1,4,1})for(int i=0,j;i++<n;){for(j=0;j++<c;)m+=new System.Text.StringBuilder().Insert(0,"# ",n);m+="\n";}return m;};

SmileBASIC, 57 50 byte

INPUT S
E$=("#"*S*3+CHR$(10))*S?E$SCROLL-S*2,-1?E$

Dijelaskan:

INPUT SIZE
PART$=("#"*SIZE*3+CHR$(10))*S 'generate half of the pattern
PRINT PART$ 'print half the pattern
SCROLL SIZE*-2,-1 'scroll the text 2 squares right (and 1 character down)
PRINT PART$ 'print half the pattern again

Setelah PRINT pertama (size = 2, @ adalah posisi kursor):

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

@ 

Setelah GULIRAN:

    ######
    ######
@

Setelah PRINT kedua:

    ######
    ######
######
######
@

Common Lisp, 83 81 79 byte

(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))

Pemakaian:

(funcall #'(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))2)

Keluaran:

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

Bagaimana cara kerjanya?

in format there is control string (inside "") and arguments after it
certain commands in string can use arguments (for example ~a displays argument)
~v{~} - takes argument and does commends inside {~} number of times 
                                      (number is given by argument)
       we can write text in loop body - it'll get displayed. Even if
       in loop body there are none commends to use arguments loop itself                 
       will consume one argument (it doesn't matter what it'll be -
       it doesn't seem to affect output)
~% - newline
~n* - jump n arguments forward (relative)
~n:* - jump n arguments backwards (relative)
~n@* - jump to argument n (global, counting from 0)

~v@{~v{# ~}~%~1@*~} <--- we make x rowns, 3x columns of string "# ". 
                         ~1@* is used during looping, it also means we end on argument 1. 
                         (second argument: (* x 3))
~v@{~vt~0@*~v{# ~}~%~} <--- we now make 3x rows, x columns of "(spaces)# "
                         ~vt - is used to move to accurate column. 
                         Here it takes argument (* x 2) - this is 
                         minimal number of columns to display. It uses
                         space as default character for missing characters
                         (when string inside <~> is shorter than min 
                         number of columns). I use it to make (* x 2) spaces, 
                         by giving it no text.
      ~0@* <--- after making spaces we have no new arguments, we go back to
                argument number zero - it is used to determine number of columns in our block

Ide untuk perbaikan disambut.