Meydan okuma

S boyutuna bakılırsa, hash sembollerinden ( #) ve spaces ( ) 'dan oluşan o büyüklükteki bir küpü yazdır .

Örnekler:

1:
  #
# # #    
  #
  #

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

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

Ağ aslında bir küp içine katlanabilen herhangi bir geçerli küp ağı olabilir, örneğin:

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

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

kurallar

• Elde edilen net geometrik olarak geçerli olmalıdır (bir küpün içine katlanabilir)
• Standart boşluklar yasaktır
• Kuralları dikkatlice okuyun
• Bu kod-golf , en kısa cevap kazandı, ancak seçilmeyecek

Python 2, 47 bayt

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

Çevrimiçi deneyin!

Sola dayalı olması için seçilen bu ağı yazdırır:

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

Satırların kopyaları nveya 4*nkopyaları '# '. Her biri için 1,4,1, nbirçok kopyaların nzamanlarını, nsatırlar için yapılan zamanları basarız. Bir execdöngü içinde bir fordöngü olması israf gibi görünüyor, ama daha iyi görmedim.

Test ettiğim alternatifler:

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

( defİşlevlerin hepsi bir program olarak daha kısa olabilir.)

Octave, 58 44 42 32 bayt

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

kısmen @xnor'ın python cevabından ilham aldı.

z=repmat('# ',n);

giriş 2 için şu şekilde bir sonuç deseni alır:

# #             
# # 

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

dört zs yatay olarak birleştirildi:

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

[z;y;z]

zve yve zdikey olarak birleştirilir

Çevrimiçi Deneyin!

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

Önceki cevap:

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

Çevrimiçi Deneyin!

T şeklinde bir tane oluşturur

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

Mathematica, 77 60 52 bayt

Martin Ender'e 8 byte golf oynadığı için teşekkürler!

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

Olumsuz bir tamsayı argümanı alan #ve yeni satırlı bir dize döndüren adsız işlev (izleyen bir yeni satır dahil); Her çizginin de sondası vardır. İlk önce ±giriş #zamanlarını tekrarlayan bir fonksiyon olarak tanımlarız ; Sonra aolarak tanımlanır ±"# "(bu #bir karakter değil girişidir!) ve bundan bsetini olarak tanımlanır #iken, kısa çizgilerin ±{a,a,a,a}<>nkümesidir #uzun hatlar. (Her iki durumda da, eşleşen tırnak işaretleri arasında değişmez satır beslemesi vardır.) Son sonuç <>b, sonuçtaki dizeler listesini kısa çizgi grubunun ikinci kopyasıyla birleştirir. Örnek çıktı: #=2( xnor'ın cevabı bana bu yönelimin golfçü olduğunu öğretti):

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

Bu uygulamanın önceki sürümü:

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

Orijinal gönderim:

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

Bir dizisini oluşturur 4*(3#+1), bunların her biri, ya olduğu, parçalar "# ", " "ya da "\n"; Dizine göre hangi parçaları kullanacağınızı hesaplar n. Aşağıdaki durumlarda örnek çıktı #=2:

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

JavaScript (ES6), 59 bayt

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

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

Çıktı, her satırın sonunda bir boşluk ve izleyen bir yeni satır içerir.

Ruby, 36 bayt

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

Kullanımı:

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

Ruby, 38 bayt

Bu şekil Ruby'de daha uzundur ancak bence daha kısa olan bazı diller vardır.

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

Kullanımı:

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

Her iki cevap da, bir dizi dizenin döndürülmesine (tercihen) ya da (daha az tercihen) baskı yerine tek bir dizgenin döndürülmesine izin verilirse daha kısa olabilir.

Scala, 56 bayt

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

Ölçek

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 bayt

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 bayt

Ài# ddÀpLyGïp3PGïp

Tüm gizli karakterler gösteriliyor

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

^[olduğu 0x1b(kaçış karakter değişmezi) ve ^Vbir 0x16( C-v)

Çevrimiçi deneyin!

Bayt sayısını artırmak zorunda kaldım çünkü Äkomut bu yeni V çekişinde hata veriyordu.

Bu formattaki çıktılar:

# 
# # # # 
# 

önde gelen bir newline ile

HexDump:

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

açıklama

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

Ağın bir yüzü tamamlandıktan sonra, ağı oluşturmak zorundayız

^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

Boşlukları çıkarmazsak alternatif çözüm:

21 20 18 16 18 bayt

Àé#ddÀpLyGïp3pGïp

(En iyi çözümle aynı nedenle, bu TIO bağlantısı değiştirildi)

Çevrimiçi deneyin!

V , 14 bayt (rekabet etmeyen)

Ài# 5Ù4JjòÀÄk

Çevrimiçi deneyin!

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

Sebep ne olursa olsun, bu meydan okuma çok sayıda hata ortaya çıkardı. Şimdi hepsi düzeldi, bu sürüm maalesef rekabet etmiyor, ancak bu zorluğa bir V cevabının özensiz kodlamamı sürdürmek için ton bayt eklemek zorunda olmadığı durumlarda nasıl görünmesi gerektiğini görmek güzel.

Açıklama:

À                   " 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

Jöle , 20 19 bayt

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

Çevrimiçi deneyin!

-1, 44874 (steenbergh) sayesinde.

^{ÇAMURLUK BALIKÇILIĞI YARDIM EDEMEZ!}

Bu golf oynuyor mu ??? 20 19 bayt Bağlantı 1'i görünce çok fazla görünüyor .

Açıklama:

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

Kömür , 20 bayt

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

Kod boşlukla bitiyor. Çevrimiçi deneyin!

açıklama

Kömür ASCII sanatında uzmanlaşmış bir dildir. Aynı zamanda eksik, hatalı ve belgelenmemiş. Söylemesi yeterli, bunun gerekeni yapmadan önce adil bir şekilde yargılanma ve yanılma oldu.

• Ｎλiçine bir sayı girer λ.
• ＧDikdörtgen çizmek için burada kullanacağımız çokgen komutudur. ↑λ←×⁶λ↓λÇokgenin kenarlığını belirtir: yukarı λadımlar, 6 kez sola λdoğru λadımlar ve aşağı doğru adımlar. (Üç etti λile λdikdörtgen alt kenarında çıkarılır yan tarafı. Bloklar). Çokgen daha sonra dizeyle doldurulur # .
• Ｄ mevcut tuvali stdout'a döker ve şöyle bir şeye yol açar:

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

• Komuttan sonra Ｇimleç, tuvalin sol alt köşesindedir. Ｍ×⁴λ←hareket 4 kez tarafından sola doğru λadım (iki eşdeğer λile λblok).
• orada bir boşluk çıkarır ve tuvali doğru miktarda sola doğru uzatır.
• Program sonunda, tuval (yine) stdout'a gönderilir:

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

Onları bir araya getir ve bir küp ağın var.

Bash / Unix yardımcı programları, 72 69 68 66 bayt

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

Çevrimiçi deneyin!

Bu, temel 2'ye yazıldığında [4 ^ k / 3] 'ün k10'larla birlikte 10101010 ... 01 olduğu gerçeğini kullanarak çalışır. (Buradaki köşeli parantezler döşeme işlevini gösterir.)

Pyke, 16 bayt

uAD,sXF**"# 

Burada dene!

Eşittir

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

Yazdırılamaz yüzünden

Bu, bayt sayısını azaltmak için birkaç püf noktası kullanır:

• Listeyi göstermek için bazı yazdırılamayanları kullanır. [1, 4, 1]
• XF çıktıyı yığına otomatik olarak aktarır
• "#Sonunda dize en son ile değiştirilir *, bu da kapanmanın "gerekli olmadığı anlamına gelir . Bu, son simge bir dize olduğunda örtük olarak gerçekleşir.

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

Python 2 , 68 71 65 bayt

-6 (@sagiksp sayesinde)

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

Çevrimiçi deneyin!

@Xnor'ı geçmenin bir yolunu bulamıyorsanız, özyinelemeyi basit bir alternatif yaklaşım olarak göndereceğim. F (5) baskılar için

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

Bu desen basitçe seçildi çünkü diğerlerinden farklı olarak iki bölüme ayrılabilir.

PHP, 64 62 bayt

Christoph sayesinde 2 bayt kaydedildi .

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

Bunun gibi bir net yazdırır:

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

(önde gelen bir yeni hat ile)

Toplu iş, 111 bayt

@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 bayt

Sola yaslanmış küp ağı yazdırır. Golf oynamak zordu ...

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

Çevrimiçi deneyin!

Retina , 39 37 bayt

Bu benim Retina'yı ilk kez kullanıyor, hala nasıl yapılacağını anlamaya çalışıyorum.

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

(4. ve 5. satırlardan sonra iki boşlukla)

Martin Ender'e 2 byte golf attığı için teşekkürler!

Çevrimiçi deneyin!

QBIC , 52 67 40 bayt

Yeniden yazmayı tamamlayın:

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

Bu şimdi bu modeli kullanır:

###--
--###

Burada -boşluk ile doldurulur.

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

15 baytlık kod, -nbayrak için +1 .

"# "Xa*_RLaM141

Boyutu komut satırı argümanı olarak alır. Çevrimiçi deneyin!

açıklama

                 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)

Aşağıdakiler tam olarak verilerin nasıl değiştirildiğini değil a=2;

141

[1;4;1]

[2;8;2]

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

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

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

05AB1E , 13 bayt

D141S×S*„# ×»

Çevrimiçi deneyin!

açıklama

Örnek giriş 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 bayt

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 bayt

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

Açıklaması:

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

İlk PRINT'ten sonra (size = 2, @ imleç konumudur):

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

@ 

SCROLL'den sonra:

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

İkinci BASKI'dan sonra:

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

Ortak Lisp, 83 81 79 bayt

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

Kullanımı:

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

Çıktı:

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

O nasıl çalışır?

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

İyileştirme fikirleri memnuniyetle karşılanmaktadır.