Défi

Étant donné une taille s, imprimez un cube net de cette taille composé de symboles de hachage ( #) et d'espaces ( ).

Exemples:

1:
  #
# # #    
  #
  #

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

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

Le filet peut en fait être n'importe quel filet de cube valide qui peut se replier en cube, par exemple ceux-ci:

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

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

Règles

• Le filet résultant doit être géométriquement valide (pliable en cube)
• Failles standard interdites
• Lisez attentivement les règles
• Il s'agit du code-golf , la réponse la plus courte l'emporte, mais ne sera pas sélectionnée

Python 2, 47 octets

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

Essayez-le en ligne!

Imprime ce filet, choisi pour être justifié à gauche:

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

Les lignes ont nou des 4*ncopies de '# '. Pour chacun 1,4,1, nous imprimons des ntemps autant de copies, des ntemps faits pour les nlignes. Avoir une execboucle à l'intérieur d'une forboucle semble être du gaspillage, mais je n'ai pas vu mieux.

Alternatives que j'ai testées:

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

(Les deffonctions peuvent toutes être plus courtes en tant que programme.)

Octave, 58 44 42 32 octets

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

en partie inspiré par la réponse python de @xnor.

z=repmat('# ',n);

crée un motif carré de '#' pour l'entrée 2 donne le motif suivant:

# #             
# # 

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

quatre zs sont concaténés horizontalement:

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

[z;y;z]

zet yet zsont concaténés verticalement

Essayez-le en ligne!

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

Réponse précédente:

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

Essayez-le en ligne!

Génère un en forme de T

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

Mathematica, 77 60 52 octets

Merci à Martin Ender d'avoir joué au golf à 8 octets!

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

Fonction sans nom prenant un argument entier positif #et renvoyant une chaîne avec des retours à la ligne (y compris un retour à la ligne de fin); chaque ligne a également un espace de fin. D'abord, nous définissons ±comme une fonction qui répète ses #temps d' entrée ; aest alors défini comme ±"# "( #c'est un caractère, pas l'entrée!), et à partir de cela best défini comme l'ensemble des #lignes courtes, tandis que ±{a,a,a,a}<>nl'ensemble des #lignes longues. (Dans les deux cas, il y a un saut de ligne littéral entre les guillemets correspondants.) La finale <>bconcatène la liste résultante de chaînes avec la deuxième copie de l'ensemble de lignes courtes. Exemple de sortie lorsque #=2( la réponse de xnor m'a appris que cette orientation est golfeuse):

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

Version précédente de cette implémentation:

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

Soumission originale:

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

Construit une chaîne sur des 4*(3#+1)pièces, qui est soit chacun "# ", " "ou "\n"; calcule simplement les pièces à utiliser en fonction de l'index n. Exemple de sortie lorsque #=2:

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

JavaScript (ES6), 59 octets

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

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

La sortie comprend un espace de fin à la fin de chaque ligne et une nouvelle ligne de fin.

Rubis, 36 octets

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

Usage:

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

Rubis, 38 octets

Cette forme est plus longue en Ruby mais je m'attends à ce qu'il y ait certaines langues où elle est plus courte.

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

Usage:

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

Les deux réponses peuvent être plus courtes s'il est permis de renvoyer (de préférence) un tableau de chaînes ou (moins préférablement) une seule chaîne au lieu d'imprimer.

Scala, 56 octets

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

Tester

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 octets

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 octets

Ài# ddÀpLyGïp3PGïp

Avec tous les personnages cachés montrés

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

^[is 0x1b(littéral caractère d'échappement) et ^Vis 0x16( C-v)

Essayez-le en ligne!

J'ai dû augmenter bytecount parce que la Äcommande était buggée dans ce nouveau pull V

Sorties dans ce format:

# 
# # # # 
# 

avec une nouvelle ligne leader

Hexdump:

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

Explication

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

Maintenant qu'une face du filet est terminée, nous devons créer le filet

^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

Solution alternative si nous ne sortons pas les espaces:

21 20 18 16 18 octets

Àé#ddÀpLyGïp3pGïp

(pour la même raison que la meilleure solution, ce lien TIO est modifié)

Essayez-le en ligne!

V , 14 octets (non concurrent)

Ài# 5Ù4JjòÀÄk

Essayez-le en ligne!

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

Pour une raison quelconque, ce défi a révélé de nombreux bugs. Maintenant qu'ils sont tous corrigés, cette version n'est malheureusement pas concurrente, mais c'est agréable de voir à quoi devrait ressembler une réponse V à ce défi quand elle n'a pas besoin d'ajouter des tonnes d'octets pour suivre mon codage bâclé.

Explication:

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

Gelée , 20 19 octets

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

Essayez-le en ligne!

-1 grâce à 44874 (steenbergh).

^{JE NE PEUX PAS AIDER LE MUDDYFISH AIDE!}

Est-ce jouable au golf ??? 20 19 octets semble trop , voir le lien 1.

Explication:

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

Fusain , 20 octets

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

Le code se termine par un espace. Essayez-le en ligne!

Explication

Le fusain est une langue spécialisée dans l'art ASCII. Il est également incomplet, bogué et sous-documenté. Qu'il suffise de dire que cela a pris pas mal d'essais et d'erreurs avant de faire ce qu'il était censé faire.

• Ｎλentre un nombre dans λ.
• Ｇest la commande polygone, que nous utiliserons ici pour dessiner un rectangle. ↑λ←×⁶λ↓λspécifie la bordure du polygone: λpas vers le haut, pas de 6 fois vers la gauche λet λpas vers le bas . (C'est trois λpar λblocs côte à côte.) Le bord inférieur du rectangle est déduit. Le polygone est ensuite rempli avec la chaîne # .
• Ｄ vide le canevas courant vers stdout, ce qui donne quelque chose comme ceci:

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

• Après la Ｇcommande, le curseur se trouve dans le coin inférieur gauche du canevas. Ｍ×⁴λ←le déplace vers la gauche par pas de 4 fois λ(équivalent à deux λpar λblocs).
• génère un espace à cet endroit, étendant le canevas vers la gauche de la bonne quantité.
• À la fin du programme, le canevas est (encore) envoyé à stdout:

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

Mettez-les ensemble et vous avez un filet de cube.

Utilitaires Bash / Unix, 72 69 68 66 octets

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

Essayez-le en ligne!

Cela fonctionne en utilisant le fait que [4 ^ k / 3], lorsqu'il est écrit en base 2, est 10101010 ... 01, avec k 1. (Les crochets indiquent ici la fonction de plancher.)

Pyke, 16 octets

uAD,sXF**"# 

Essayez-le ici!

Équivalent à

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

En raison d'imprimables

Cela utilise quelques astuces pour réduire le nombre d'octets:

• Il utilise certains non imprimables pour représenter la liste [1, 4, 1]
• XF vide automatiquement la sortie dans la pile
• La chaîne "#à la fin est échangée avec la dernière *, ce qui signifie que la fermeture "n'est pas requise. Cela se produit implicitement lorsque le dernier jeton est une chaîne.

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

Python 2 , 68 71 65 octets

-6 avec merci à @sagiksp

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

Essayez-le en ligne!

En l'absence de trouver un moyen de battre @xnor, je publierai ma fonction récursive simplement comme une approche alternative. Pour les impressions f (5)

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

Ce modèle a été choisi simplement parce qu'il peut être divisé en deux parties contrairement à toutes les autres.

PHP, 64 62 octets

Enregistré 2 octets grâce à Christoph .

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

Imprime un filet comme ceci:

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

(avec une nouvelle ligne leader)

Lot, 111 octets

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

Imprime le cube net justifié à gauche. C'était difficile de jouer au golf ...

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

Essayez-le en ligne!

Rétine , 39 37 octets

C'est ma première utilisation de Retina, j'essaie toujours de comprendre comment faire les choses.

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

(avec deux espaces de fin après les 4e et 5e lignes)

Merci à Martin Ender pour avoir joué au golf 2 octets!

Essayez-le en ligne!

QBIC , 52 67 40 octets

Réécriture complète:

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

Cela utilise maintenant ce modèle:

###--
--###

Où ils -sont remplis d'espaces.

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

15 octets de code, +1 pour l' -nindicateur.

"# "Xa*_RLaM141

Prend la taille comme argument de ligne de commande. Essayez-le en ligne!

Explication

                 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)

Ce qui suit n'est pas exactement comment les données sont modifiées, mais cela donne l'idée de base (pour a=2):

141

[1;4;1]

[2;8;2]

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

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

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

05AB1E , 13 octets

D141S×S*„# ×»

Essayez-le en ligne!

Explication

Exemple d'entrée 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 octets

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 octets

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

Expliqué:

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

Après la première impression (taille = 2, @ est la position du curseur):

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

@ 

Après le défilement:

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

Après la deuxième impression:

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

Lisp commun, 83 81 79 octets

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

Usage:

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

Sortie:

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

Comment ça marche?

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

Les idées d'amélioration sont les bienvenues.