Herausforderung

Bei einer vorgegebenen Größe s drucken Sie ein Würfelnetz dieser Größe aus Hash-Symbolen ( #) und Leerzeichen ( ).

Beispiele:

1:
  #
# # #    
  #
  #

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

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

Das Netz kann tatsächlich ein beliebiges gültiges Würfelnetz sein, das sich zu einem Würfel zusammenfalten lässt, zum Beispiel:

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

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

Regeln

• Das resultierende Netz muss geometrisch gültig sein (in einen Würfel faltbar)
• Standardlücken verboten
• Lesen Sie die Regeln sorgfältig durch
• Dies ist Code-Golf , die kürzeste Antwort gewinnt, wird aber nicht ausgewählt

Python 2, 47 Bytes

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

Probieren Sie es online!

Druckt dieses Netz, das als linksbündig ausgewählt wurde:

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

Die Zeilen haben noder 4*nKopien von '# '. Für jeden von 1,4,1uns werden nso viele Kopien gedruckt , nund zwar für nZeilen. Eine execSchleife in einer forSchleife zu haben, scheint verschwenderisch, aber ich habe nicht besser gesehen.

Alternativen, die ich getestet habe:

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

(Die defFunktionen können alle eine kürzere als ein Programm sein.)

Oktave, 58 44 42 32 Bytes

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

teilweise inspiriert von @xnors Python-Antwort.

z=repmat('# ',n);

Erstellt ein Quadratmuster von '#' für Eingabe 2, ergibt sich folgendes Muster:

# #             
# # 

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

vier zs sind horizontal verkettet:

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

[z;y;z]

zund yund zsind vertikal verkettet

Probieren Sie es online!

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

Vorherige Antwort:

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

Probieren Sie es online!

Erzeugt eine T-förmige

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

Mathematica, 77 60 52 Bytes

Vielen Dank an Martin Ender für das Golfen in 8 Bytes Entfernung!

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

Unbenannte Funktion, die ein positives ganzzahliges Argument verwendet #und eine Zeichenfolge mit Zeilenumbrüchen (einschließlich einer nachgestellten Zeile) zurückgibt; Jede Zeile hat auch ein Leerzeichen. Zunächst definieren wir ±eine Funktion, die ihre Eingabezeiten wiederholt #. Dann awird definiert als ±"# "(dies #ist ein Zeichen, nicht die Eingabe!) und daraus bwird die Menge der #kurzen Zeilen definiert, während ±{a,a,a,a}<>ndie Menge der #langen Zeilen ist. (In beiden Fällen wird zwischen übereinstimmenden Anführungszeichen ein Zeilenvorschub eingefügt.) Das Endergebnis <>bverkettet die resultierende Liste der Zeichenfolgen mit der zweiten Kopie des Satzes von kurzen Zeilen. Beispielausgabe bei #=2( xnors Antwort lehrte mich, dass diese Ausrichtung Golfspieler ist):

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

Vorherige Version dieser Implementierung:

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

Ursprüngliche Einreichung:

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

Baut einen String aus 4*(3#+1)Stücken, von denen jedes entweder "# ", " "oder "\n"; berechnet einfach die zu verwendenden Teile basierend auf dem Index n. Beispielausgabe bei #=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>

Die Ausgabe enthält ein Leerzeichen am Ende jeder Zeile und ein Leerzeichen am Ende einer neuen Zeile.

Ruby, 36 Bytes

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

Verwendung:

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

Ruby, 38 Bytes

Diese Form ist in Ruby länger, aber ich gehe davon aus, dass es einige Sprachen gibt, in denen sie kürzer ist.

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

Verwendung:

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

Beide Antworten können kürzer sein, wenn es zulässig ist, (bevorzugt) ein Array von Zeichenfolgen oder (weniger bevorzugt) eine einzelne Zeichenfolge zurückzugeben, anstatt zu drucken.

Scala, 56 Bytes

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

Prüfung

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 Bytes

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 Bytes

Ài# ddÀpLyGïp3PGïp

Mit allen versteckten Zeichen angezeigt

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

^[ist 0x1b(Escape-Zeichen-Literal) und ^Vist 0x16( C-v)

Probieren Sie es online!

Ich musste bytecount erhöhen, weil der ÄBefehl in diesem neuen V-Pull fehlerhaft war

Ausgaben in diesem Format:

# 
# # # # 
# 

mit einer führenden Newline

Hexdump:

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

Erläuterung

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

Nachdem eine Seite des Netzes fertiggestellt ist, müssen wir das Netz erstellen

^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

Alternative Lösung, wenn wir die Leerzeichen nicht ausgeben:

21 20 18 16 18 Bytes

Àé#ddÀpLyGïp3pGïp

(Aus dem gleichen Grund wie bei der Top-Lösung wurde dieser TIO-Link geändert.)

Probieren Sie es online!

V , 14 Bytes (nicht konkurrierend)

Ài# 5Ù4JjòÀÄk

Probieren Sie es online!

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

Aus welchem ​​Grund auch immer, diese Herausforderung deckte zahlreiche Fehler auf. Jetzt, da sie alle repariert sind, ist diese Version leider nicht konkurrierend, aber es ist schön zu sehen, wie eine V-Antwort auf diese Herausforderung aussehen sollte, wenn nicht Tonnen von Bytes hinzugefügt werden müssen, um mit meiner schlampigen Codierung Schritt zu halten.

Erläuterung:

À                   " 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 bis 19 Bytes

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

Probieren Sie es online!

-1 dank 44874 (steenbergh).

^{Ich kann nicht MUDDYFISH HILFE OUTGOLF!}

Ist das golfen ??? 20 - 19 Bytes scheinen einfach zu viel zu sein , siehe Link 1.

Erläuterung:

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

Holzkohle , 20 Bytes

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

Der Code endet mit einem Leerzeichen. Probieren Sie es online!

Erläuterung

Charcoal ist eine auf ASCII-Kunst spezialisierte Sprache. Es ist auch unvollständig, fehlerhaft und nicht ausreichend dokumentiert. Es genügt zu sagen, dass dies einiges an Versuch und Irrtum erforderte, bevor es tat, was es sollte.

• Ｎλgibt eine Zahl in ein λ.
• Ｇist der Polygon-Befehl, mit dem wir hier ein Rechteck zeichnen. ↑λ←×⁶λ↓λGibt den Rand des Polygons an: Aufwärtsschritte λ, sechsmal nach links λund abwärts λ. (Das sind drei λvon λBlöcken Seite an Seite.) Die Unterkante des Rechtecks zu entnehmen ist. Das Polygon wird dann mit der Zeichenfolge gefüllt # .
• Ｄ kopiert den aktuellen Canvas auf stdout, was ungefähr so ​​aussieht:

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

• Nach dem ＧBefehl befindet sich der Cursor in der unteren linken Ecke der Zeichenfläche. Ｍ×⁴λ←bewegt sie sich nach links um 4 mal λSchritte (entspricht zwei λvon λBlöcken).
• Gibt dort ein Leerzeichen aus, wobei die Zeichenfläche um den richtigen Betrag nach links verlängert wird.
• Am Ende des Programms wird der Canvas (erneut) an stdout gesendet:

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

Setze sie zusammen und du hast ein Würfelnetz.

Bash / Unix-Dienstprogramme, 72 69 68 66 Bytes

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

Probieren Sie es online!

Dies funktioniert unter Verwendung der Tatsache, dass [4 ^ k / 3], wenn es in Basis 2 geschrieben wird, 10101010 ... 01 mit k 1 ist. (Die eckigen Klammern kennzeichnen hier die Bodenfunktion.)

Pyke, 16 Bytes

uAD,sXF**"# 

Probieren Sie es hier aus!

Gleichwertig

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

Wegen Unbedruckbaren

Dies setzt ein paar Tricks ein, um die Byteanzahl zu verringern:

• Es werden einige nicht druckbare Elemente verwendet, um die Liste darzustellen [1, 4, 1]
• XF legt die Ausgabe automatisch im Stapel ab
• Die Zeichenkette "#am Ende wird mit der letzten getauscht *, was bedeutet, dass das Schließen "nicht erforderlich ist. Dies geschieht implizit, wenn das letzte Token eine Zeichenfolge ist.

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

Python 2 , 68 71 65 Bytes

-6 danke an @sagiksp

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

Probieren Sie es online!

In Ermangelung einer Möglichkeit, @xnor zu schlagen, poste ich meine rekursive Funktion einfach als alternativen Ansatz. Für f (5) druckt

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

Dieses Muster wurde einfach gewählt, weil es im Gegensatz zu allen anderen in zwei Teile geteilt werden kann.

PHP, 64 62 Bytes

2 Bytes gespart dank Christoph .

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

Druckt ein Netz wie dieses:

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

(mit einer führenden Newline)

Batch, 111 Bytes

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

Aufdringlich , 32 29 28 Bytes

Druckt das Würfelnetz linksbündig. Das war schwer zu golfen ...

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

Probieren Sie es online!

Retina , 39 37 Bytes

Ich benutze Retina zum ersten Mal und versuche immer noch zu verstehen, wie man Dinge macht.

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

(mit zwei nachgestellten Leerzeichen nach der 4. und 5. Zeile)

Vielen Dank an Martin Ender für das Golfen mit 2 Bytes!

Probieren Sie es online!

QBIC , 52 67 40 Bytes

Komplette Neuschreibung:

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

Dies verwendet nun dieses Muster:

###--
--###

Wo die -mit Leerzeichen gefüllt sind.

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

15 Byte Code, +1 für -nFlag.

"# "Xa*_RLaM141

Nimmt die Größe als Befehlszeilenargument. Probieren Sie es online!

Erläuterung

                 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)

Das Folgende ist nicht genau, wie die Daten geändert werden, aber es gibt die Grundidee (für a=2):

141

[1;4;1]

[2;8;2]

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

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

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

05AB1E , 13 Bytes

D141S×S*„# ×»

Probieren Sie es online!

Erläuterung

Beispiel Eingabe 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: # # 
                         # # 
                         # # # # # # # # 
                         # # # # # # # # 
                         # # 
                         # # 

152 Bytes

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 Bytes

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

Erklärt:

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

Nach dem ersten DRUCKEN (Größe = 2, @ ist die Cursorposition):

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

@ 

Nach dem SCROLL:

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

Nach dem zweiten DRUCK:

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

Common Lisp, 83 81 79 Bytes

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

Verwendung:

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

Ausgabe:

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

Wie funktioniert es?

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

Verbesserungsvorschläge sind willkommen.