J'ai obtenu ce défi de Codingame et je suis curieux de trouver de meilleures solutions que la mienne:

Étant donné une largeur via l'entrée standard, dessinez un carré creux de «#» de largeur et de longueur données.

Exemple:

5 résultats dans

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

J'ai utilisé python pour résoudre ce problème, donc je suis particulièrement intéressé par d'autres codes python. Mais n'hésitez pas à publier votre solution dans la langue de votre choix.

Pyke, 11 octets

ttDd*n+*.X#

Essayez-le ici!

ttDd*n+*    - a square of spaces n-2*n-2 big
        .X# - surround in `#`

Fusain , 6 octets

Code:

ＮβＢββ#

Explication:

Ｎβ        # Get input from the command line and store into β
   Ｂ      # Draw a hollow box with...
     β     #  Width β
      β    #  Height β
       #   #  Filled with the character '#'
           # Implicitly output the box

Essayez-le en ligne!

MATL , 12 octets

:G\1>&*~35*c

Essayez-le en ligne!

Explication

:     % Input n implicitly. Push range [1 2 ... n]
      % STACK: [1 2 3 4 5]
G     % Push n again
      % STACK: [1 2 3 4 5], 5
\     % Modulo
      % STACK: [1 2 3 4 0]
1>    % Does each entry exceed 1?
      % STACK: [0 1 1 1 0]
&*    % Matrix with all pair-wise products
      % STACK: [0 0 0 0 0;
                0 1 1 1 0;
                0 1 1 1 0;
                0 1 1 1 0;
                0 0 0 0 0]
~     % Negate
      % STACK: [1 1 1 1 1;
                1 0 0 0 1;
                1 0 0 0 1;
                1 0 0 0 1;
                1 1 1 1 1]
35*   % Multiply by 35
      % STACK: [35 35 35 35 35;
                35  0  0  0 35;
                35  0  0  0 35;
                35  0  0  0 35;
                35 35 35 35 35]
c     % Convert to char. 0 is interpreted as space. Display implicitly
      % STACK: ['#####';
                '#   #';
                '#   #';
                '#   #';
                '#####']

Jolf, 8 octets

,ajj"###
,ajj      draw a box with height (input) and width (input)
    "###  with a hash border

Python 2, 62 54 octets

f=lambda n:'#'*n+'\n#%s#'%(' '*(n-2))*(n-2)+'\n'+'#'*n

Renvoie #\n#lorsque l'entrée est1

Version de 55 octets qui imprime

def f(n):a=n-2;print'#'*n,'\n#%s#'%(' '*a)*a,'\n'+'#'*n

Version de 62 octets qui fonctionne pour n'importe quelle entrée:

f=lambda n:'#'*n+'\n#%s#'%(' '*(n-2))*(n-2)+('\n'+'#'*n)*(n>1)

COW , 426 405 348 330 octets

MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMMMmoOMMMMoOMoOMoOMoOMoOMoOMoOMoOMoO
MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMMMmoOMMMMoOMoOMoOmoOoomMMM
moOMMMMOOmOomOoMoomoOmoOMOomoomOoMMMmoOMMMMOoMOoMOOmOomOomOomOoMoo
moOmoOMoomoOMMMmoOmoOMMMMOoMOoMOOmOomOomOomOoMoomoOmoOmoOmoOMOomoo
mOomOomOoMoomoOmoOMOomoomOomOomOomOoMoomoOmoOmoOMOOmOoMoomoOMOomoo

Essayez-le en ligne! Remplacez le nombre de la deuxième ligne par n'importe quel nombre pour modifier la sortie.

L'interpréteur COW que j'utilise ici a été écrit en Perl (et est plus récent que ce défi), mais vous pouvez toujours obtenir le même résultat en saisissant le code ici .

Explication

; Note: [n] means "value stored in the nth block of memory".
MoOMoOMoOMoOMoOMoOMoOMoOMoOMoO                                                  ;Stores 10 in [0].  10 is the code point for carriage return
MMMmoOMMMMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoO     ;Stores 32 in [1].  32 is the code point for whitespace
MMMmoOMMMMoOMoOMoO                                                              ;Stores 35 in [2].  35 is the code point for #
moOoom                                                                          ;Reads STDIN for an integer, and stores it in [3]
MMMmoOMMM                                                                       ;Copies [3] into [4] 
MOO                                                                             ;Loop as long as [4] is non-zero
    mOomOoMoo                                                                   ;Navigate to [2] and print the character with that code point
    moOmoOMOo                                                                   ;Navigate to [4] and decrement
moo                                                                             ;End loop
mOoMMMmoOMMMMOoMOo                                                              ;Copy [3] into [4] and decrement [4] twice
MOO                                                                             ;Loop as long as [4] is non-zero
    mOomOomOomOoMoo                                                             ;Navigate to [0] and print the character with that code point
    moOmoOMoo                                                                   ;Navigate to [2] and print the character with that code point
    moOMMMmoOmoOMMMMOoMOo                                                       ;Navigate to [3] and copy it into [5], then decrement [5] twice
    MOO                                                                         ;Loop as long as [5] is non-zero
        mOomOomOomOoMoo                                                         ;Navigate to [1] and print the character with that code point
        moOmoOmoOmoOMOo                                                         ;Navigate to [5] and decrement
    moo                                                                         ;End loop
    mOomOomOoMoo                                                                ;Navigate to [2] and print the character with that code point
    moOmoOMOo                                                                   ;Navigate to [4] and decrement
moo                                                                             ;End loop
mOomOomOomOoMoo                                                                 ;Navigate to [0] and print the character with that code point
moOmoOmoO                                                                       ;Navigate to [3]
MOO                                                                             ;Loop as long as [3] is non-zero
    mOoMoo                                                                      ;Navigate to [2] and print the character with that code point
    moOMOo                                                                      ;Navigate to [3] and decrement
moo                                                                             ;End loop

Python 2, 59 58 octets

n=i=input()
while i:print'#%s#'%((' #'[i%n<2])*(n-2));i-=1

repl.it

Remarque: Une entrée de 1produit une sortie de ##, mais un carré creux ne serait jamais produit pour une entrée inférieure à 3, donc je suppose que c'est bien.

Java 7, 113 112 110 octets

String c(int n){String r="";for(int i=n,j;i-->0;r+="\n")for(j=0;j<n;r+=i*j<1|n-i<2|n-j++<2?"#":" ");return r;}

1 octet économisé grâce à @ OlivierGrégoire ;
2 octets enregistrés grâce à @cliffroot .

Solution dérivée basée sur ma réponse Création d'un carré croisé .

Essayez-le ici.

PowerShell v2 +, 48 47 octets

param($n)($z='#'*$n--);,("#$(' '*--$n)#")*$n;$z

-1 octet grâce à JohnLBevan

Prend l'entrée $n, définit $zcomme des $nhachages, avec $npost-décrémenté. Encapsule cela en parens pour placer une copie sur le pipeline. Utilise ensuite l'opérateur virgule pour créer un tableau de pré-décrémenté $nlignes #, espaces, #. Ceux-ci sont laissés sur le pipeline. Place ensuite à $znouveau sur le pipeline. La sortie via implicite Write-Outputà la fin introduit une nouvelle ligne entre les éléments, nous l'obtenons donc gratuitement.

Puisque le code de l' OP ne fonctionne pas pour la saisie n <= 1, j'ai compris que nous n'avions pas non plus besoin de prendre en charge la saisie 1.

Exemples

PS C:\Tools\Scripts\golfing> 2..6|%{"$_";.\draw-a-hollow-square.ps1 $_;""}
2
##
##

3
###
# #
###

4
####
#  #
#  #
####

5
#####
#   #
#   #
#   #
#####

6
######
#    #
#    #
#    #
#    #
######

C, 98 octets

f(n,i){i=n*(n+1);while(i--){putchar(i%(n+1)==n?10:i<n||i>n*n-1||i%(n+1)==0||i%(n+1)==n-1?35:32);}}

Usage:

f(5)

05AB1E , 20 octets

'#×D¹Íð×'#.ø¹Í×sJ¹ä»

Essayez-le en ligne!

Ou 18 octets si on peut ignorer 1 <= n:

F„ #N¹<%_è¹Í×'#.ø,

Essayez-le en ligne!

WinDbg, 206 200 182 170 octets

.if@$t0{r$t3=2000000;f@$t3 L@$t0 23;f2*@$t3 L@$t0 20;eb2*@$t3 23;eb2*@$t3+@$t0-1 23;da@$t3 L@$t0;j1<@$t0'.for(r$t1=@$t0-2;@$t1;r$t1=@$t1-1){da2*@$t3 L@$t0};da@$t3 L@$t0'}

-6 octets pour supprimer les parens .ifet les utiliser jau lieu de la seconde.if

-18 octets en utilisant fau lieu d'un .forpour construire les chaînes.

-12 octets par des chaînes ne se terminant pas par NULL, en passant plutôt la longueur à da

L'entrée est transmise via le pseudo-registre $t0(par exemple r $t0 = 5; {above-code}).

Explication:

.if @$t0                                                *Verify width($t0) at least 1 
{                                                       *(registers have unsigned values) 
    r $t3 = 2000000;                                    *Set $t3 to address where the 
                                                        *string will be constructed
    f @$t3 L@$t0 23;                                    *Put width($t0) '#' at 2000000($t3)
    f 2 * @$t3 L@$t0 20;                                *Put width($t0) ' ' at 4000000(2*$t3)
    eb 2 * @$t3 23;                                     *Put '#' on left of ' ' string
    eb 2 * @$t3 + @$t0 - 1 23;                          *Put '#' on right of ' ' string
    da @$t3 L@$t0;                                      *Print the top of the box
    j 1 < @$t0                                          *If width($t1) at least 2
    '
        .for (r $t1 = @$t0 - 2; @$t1; r $t1 = @$t1 - 1) *Loop width($t0)-2 times to...
        {
            da 2 * @$t3 L@$t0                           *...print the sides of the box
        };
        da @$t3 L@$t0                                   *Print the bottom of the box
    '
}

Exemple de sortie:

0:000> r$t0=0
0:000> .if@$t0{r$t3=2000000;f@$t3 L@$t0 23;f2*@$t3 L@$t0 20;eb2*@$t3 23;eb2*@$t3+@$t0-1 23;da@$t3 L@$t0;j1<@$t0'.for(r$t1=@$t0-2;@$t1;r$t1=@$t1-1){da2*@$t3 L@$t0};da@$t3 L@$t0'}

0:000> r$t0=1
0:000> .if@$t0{r$t3=2000000;f@$t3 L@$t0 23;f2*@$t3 L@$t0 20;eb2*@$t3 23;eb2*@$t3+@$t0-1 23;da@$t3 L@$t0;j1<@$t0'.for(r$t1=@$t0-2;@$t1;r$t1=@$t1-1){da2*@$t3 L@$t0};da@$t3 L@$t0'}
Filled 0x1 bytes
Filled 0x1 bytes
02000000  "#"

0:000> r$t0=2
0:000> .if@$t0{r$t3=2000000;f@$t3 L@$t0 23;f2*@$t3 L@$t0 20;eb2*@$t3 23;eb2*@$t3+@$t0-1 23;da@$t3 L@$t0;j1<@$t0'.for(r$t1=@$t0-2;@$t1;r$t1=@$t1-1){da2*@$t3 L@$t0};da@$t3 L@$t0'}
Filled 0x2 bytes
Filled 0x2 bytes
02000000  "##"
02000000  "##"

0:000> r$t0=5
0:000> .if@$t0{r$t3=2000000;f@$t3 L@$t0 23;f2*@$t3 L@$t0 20;eb2*@$t3 23;eb2*@$t3+@$t0-1 23;da@$t3 L@$t0;j1<@$t0'.for(r$t1=@$t0-2;@$t1;r$t1=@$t1-1){da2*@$t3 L@$t0};da@$t3 L@$t0'}
Filled 0x5 bytes
Filled 0x5 bytes
02000000  "#####"
04000000  "#   #"
04000000  "#   #"
04000000  "#   #"
02000000  "#####"

JavaScript, 61 58 octets

Enregistré 3 octets grâce à @lmis !

n=>(b='#'[r='repeat'](n))+`
#${' '[r](n-=2)}#`[r](n)+`
`+b

(Ne gère pas 0ou 1)

Pour 13 octets supplémentaires (à 71 octets ), c'est possible!

n=>n?n-1?(b='#'[r='repeat'](n))+`
#${' '[r](n-=2)}#`[r](n)+`
`+b:'#':''

Ces solutions sont assez simples: elles font beaucoup de stockage pour ne pas se répéter pour économiser quelques octets. Non minifié sans le variablsm, il ressemblerait à:

n => // Anonymous function definition (Param `n` is the size)
    '#'.repeat(n) +      // # `n` times to form the top
    `
#${' '.repeat(n - 2)}#`  // Followed by a newline followed by a hash and `n` - 2 spaces and
                         // another hash to make one of the middle lines
    .repeat(n - 2) +     // The above middle lines repeated `n` - 2 times
    '#'.repeat(n)        // Followed by the top line again

Essayez!

<script type="text/babel">var f=n=>n?n-1?(b='#'[r='repeat'](n))+`\n#${' '[r](n-=2)}#`[r](n)+`\n`+b:'#':'',b,r;function c(){document.getElementById('pre').textContent = f(+document.getElementById('input').value);}</script><input id="input" onkeydown="c();" onkeyup="c();" onchange="c();" onclick="c();" placeholder="Size"><pre id="pre"></pre>

Python, 109 octets

n=int(input())
for x in range(n):
 r=list(' '*n);r[0]=r[-1]='#'
 if x%(n-1)==0:r='#'*n
 print("".join(r))

Rubis, 39 octets

->n{puts a=?#*n,[?#+' '*(n-=2)+?#]*n,a}

Se révèle être plus court de cette façon que toutes les choses fantaisistes que j'essayais. Sachez que cela ne gère pas du tout 0 ou 1.

Python 2, 50 octets

m=input()-2
for c in'#'+' '*m+'#':print'#'+m*c+'#'

Fonctionne pour n>=2. Imprime chaque ligne avec un signe dièse, n-2du symbole approprié, puis un autre signe dièse.

Le repliement du symbole de la livre donne la même longueur:

m=input()-2;p='#'
for c in p+' '*m+p:print p+m*c+p

Autres tentatives:

lambda n:'#'*n+('\n#'+' '*(n-2)+'#')*(n-2)+'\n'+'#'*n

lambda n:'#'*n+'\n#%s#'%((n-2)*' ')*(n-2)+'\n'+'#'*n

lambda n:'\n'.join(['#'*n]+['#'+' '*(n-2)+'#']*(n-2)+['#'*n])

n=input();s='#'+' '*(n-2)+'#'
for c in s:print[s,'#'*n][c>' ']

s='##'+' #'*(input()-2)+'##'
for c in s[::2]:print s[c>' '::2]

s='#'+' '*(input()-2)+'#'
for c in s:print s.replace(' ',c)

Haskell, 49 octets

n%b='#':(b<$[3..n])++"#\n"
f n=(n%)=<<init(n%' ')

Fonctionne pour n>=2. Définit l'opération de prise en sandwich d'un caractère entre #une nchaîne terminée par un saut de ligne de caractère, puis l'applique deux fois pour créer une grille 2D.

Appelez comme:

*Main> putStrLn$ f 5
#####
#   #
#   #
#   #
#####

C, 83 82 80 78 77 octets

i,j;f(n){for(i=n;i--;puts(""))for(j=n;j--;putchar(i*j&&i^n-1&&j^n-1?32:35));}

Se faufiler dans une multiplication et enregistrer un octet ...

i,j;f(n){for(i=n;i--;puts(""))for(j=n;j--;putchar(i&&j&&i^n-1&&j^n-1?32:35));}

Comptez également j et économisez quelques autres ...

i,j;f(n){for(i=n;i--;puts(""))for(j=0;j++<n;putchar(i&&j^1&&i^n-1&&j^n?32:35));}

Compte à rebours i de n à zéro et économise quelques octets ...

i,j;f(n){for(i=0;i++<n;puts(""))for(j=0;j++<n;putchar(i^1&&j^1&&i^n&&j^n?32:35));}

Un peu plus facile à comprendre et 1 octet de plus

i,j;f(n){for(i=0;i++<n;puts(""))for(j=0;j++<n;putchar(i==1|i==n|j==1|j==n?35:32));}

Groovy, 51 50 octets

{n->a="*"*n+"\n";n-=2;print(a+"*${' '*n}*\n"*n+a)}

PHP, 81 69 octets

for($n=-1+$i=$argv[1];$i--;)echo str_pad("#",$n," #"[$i%$n<1]),"#\n";

Courir avec -r; fournir une entrée comme argument.

Lance un DivisionByZeroErrorpour entrée = 1.

R, 68 70 octets

Fonctionne pour n> 1. Merci à @Billywob pour quelques octets échangeant le tableau pour une matrice.

cat(rbind(b<-'#',cbind(b,matrix(' ',n<-scan()-2,n),b),b,'
'),sep='')

Utilise rbind et cbind pour placer des lignes et des colonnes de #'s autour d'une matrice carrée n-2 d'espaces. Les retours à la ligne sont également liés aux lignes. La nouvelle ligne dans la source est importante. L'entrée provient de STDIN

Lisp commun, 150 130 octets

-20 grâce à @Cyoce et @AlexL.

(defun s(v)(format t"~v,,,vA~%"v #\# #\#)(dotimes(h(- v 2))(format t"~v,,,vA~A~%"(- v 1)#\  #\# #\#))(format t"~v,,,vA"v #\# #\#))

Usage:

* (s 5)
#####
#   #
#   #
#   #
#####

Utilise essentiellement formatdeux fois pour le haut et le bas et une boucle pour les lignes entre les deux. L'appel de format pour le haut et le bas génère une ligne commençant par #et complétée à la largeur appropriée avec #s. L'appel de format pour les lignes entre les deux fonctionne de manière similaire, sauf que le remplissage est des espaces et un #est imprimé à la fin de la ligne.

Remarque: Je suis plutôt nouveau pour Lisp et je m'attends à avoir beaucoup de marge d'amélioration à ce sujet.

Haskell, 67 octets

l#n=l<$[1..n]
f n=unlines$'#'#n:('#':' '#(n-2)++"#")#(n-2)++['#'#n]

Exemple d'utilisation:

Prelude> putStrLn $ f 4
####
#  #
#  #
####

Comment ça marche:

l#n=l<$[1..n]                      -- helper function that makes n copies of l

   '#'#n                           -- make a string of n copies of #, followed by
                        #(n-2)     -- n-2 copies of
     '#':' '#(n-2)++"#"            -- # followed by n-2 times spaces, followed by #
                           ['#'#n] -- and a final string with n copies of #
unlines                            -- join with newlines in-between

Gelée , 13, octets

,þ%µỊṀ€€ị⁾# Y

TryItOnline! ou essayez de 0 à 15

Comment?

,þ%µỊṀ€€ị⁾# Y - Main link: n
 þ            - outer product with
,             -    pair:   [[[1,1],[2,1],...,[n,1]],[[1,2],[2,2],...,[n,2]], ... ,[[1,n],[2,n],...,[n,n]]]
  %           - mod n:     [[[1,1],[2,1],...,[0,1]],[[1,2],[2,2],...,[0,2]], ... ,[[1,0],[2,0],...,[0,0]]]
   µ          - monadic chain separation
    Ị         - abs(z)<=1: [[[1,1],[0,1],...,[1,1]],[[1,0],[0,0],...,[1,0]], ... ,[[1,1],[0,1],...,[1,1]]]
      €€      - for each for each
     Ṁ        - maximum:   [[1,    1,    ...,1],    [1,    0,    ..., 1],    ... ,[1,    1,    ..., 1]   ]
        ị     - index into (1 based)
         ⁾#   - "# ":      ["##...#","# ...#", ...,"##...#"]
           Y  - join with line feeds

Pip , 16 octets

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

(Y_Xa-2WR'#s)My

Fonctionne pour la saisie> = 2. Essayez-le en ligne!

Explication d'une version quelque peu non golfée

Tout d'abord, nous définissons une fonction yqui prend un argument de chaîne, le répète a-2fois (où aest la première entrée de ligne de commande) et encapsule le résultat #.

Y _ X a-2 WR '#
  _              Identity function
    X a-2        String-repeated by a-2
          WR '#  Wrapped in #
Y                Yank the resulting function into y

Ensuite, nous appliquons cette fonction deux fois - une fois normalement, puis à nouveau avec map - pour obtenir le carré sous forme de liste de chaînes:

y M (y s)
    (y s)  Call function y with s (preinitialized to " ") as argument
y M        Map y to each character of the resulting string

Pour l'entrée de 4, (y s)résulte en "# #"et y M (y s)en ["####"; "# #"; "# #"; "####"]. Cette dernière valeur est ensuite imprimée, le -ndrapeau entraînant sa séparation par des sauts de ligne.

Astuces de golf

Pour passer de la version non golfée à la version golfée:

• Supprimez les espaces.
• Yest un opérateur, ce qui signifie que nous pouvons l'utiliser dans une expression. Au lieu d'être Y...suivi (ys), nous pouvons simplement le faire (Y...s).
• Le problème est que nous devons extraire la fonction avant de la référencer à nouveau comme y; donc ça yM(Y_Xa-2WR'#s)ne marchera pas. Solution: permutez les opérandes de l' Mopérateur ap. Tant que l'un d'eux est une fonction et l'autre est un type itérable, peu importe l'ordre dans lequel ils entrent.

Raquette 113 octets

(let*((d display)(g(λ()(for((i n))(d"#")))))(g)(d"\n")(for((i(- n 2)))(d"#")(for((i(- n 2)))(d" "))(d"#\n"))(g))

Non golfé:

(define (f n)
  (let* ((d display)
         (g (λ () 
              (for ((i n))
                (d "#"))
              (d "\n"))))
    (g)
    (for ((i (- n 2)))
      (d "#")
      (for ((i (- n 2)))
        (d " ") )
      (d "#\n"))
    (g)))

Essai:

(f 5)

Sortie:

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

SpecBAS - 57 octets

1 INPUT n: a$="#"*n,n-=2,b$="#"+" "*n+"#"#13: ?a$'b$*n;a$

?est un raccourci pour PRINT, #13est un retour chariot qui peut être cloué à la fin d'une chaîne sans avoir besoin +de se joindre à eux.

L'apostrophe déplace le curseur d'impression d'une ligne vers le bas.

Coincé, 29 27 octets

C'est sacrément long pour une langue de "golf", mais j'ai oublié comment ça marche: P

i_2-_u'#*N+_'#' u*'#N+++u*u

Explication:

i_2-_u                           # take input and triplicate, subtracting 2 (5 -> [3,3,5])
      '#*N+_                     # create the top and bottom rows
            '#' u*'#N+++u*       # create input - 2 copies of middle rows
                          u      # rotate left 1 to get correct order, implicit output

C #, 154 152 octets

Golfé:

void F(int n){Console.Write($"{new string('#',n)}\n");for(int i=2;i<n;i++)Console.Write($"#{new string(' ',n-2)}#\n");Console.Write(new string('#',n));}

Non golfé:

    void F(int n)
    {
        Console.Write($"{new string('#', n)}\n");

        for (int i = 2; i < n; i++)
            Console.Write($"#{new string(' ', n - 2)}#\n");

        Console.Write(new string('#', n));
    }

EDIT1: optimisation de la plage de boucle.

Lithp , 117 octets

Ligne divisée en deux pour plus de lisibilité:

#N::((var X (repeat "#" N))(print X)(each (seq 3 N) (scope #X::((print (+ "#" 
     (repeat " " (- N 2)) "#")))))(print X))

Exemple d'utilisation:

% square.lithp
(
    (import "lists")
    (def s #N::((var X (repeat "#" N))(print X)(each (seq 3 N) (scope #X::((print (+ "#" (repeat " " (- N 2)) "#")))))(print X)))
    (s 10)
)

Output:
$ ./run square.lithp
##########
#        #
#        #
#        #
#        #
#        #
#        #
#        #
#        #
##########