Recibí este desafío de Codingame y tengo curiosidad por encontrar mejores soluciones que la mía:

Dado un ancho a través de la entrada estándar, dibuje un cuadrado hueco de '#' en el ancho y largo dados.

Ejemplo:

5 resultados en

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

Usé Python para resolver esto, así que estoy particularmente interesado en otro código de Python. Pero no dude en publicar su solución en el idioma que desee.

Pyke, 11 bytes

ttDd*n+*.X#

Pruébalo aquí!

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

Carbón de leña , 6 bytes

Código:

ＮβＢββ#

Explicación:

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

Pruébalo en línea!

MATL , 12 bytes

:G\1>&*~35*c

Pruébalo en línea!

Explicación

:     % 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 bytes

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

Python 2, 62 54 bytes

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

Devuelve #\n#cuando la entrada es1

Versión de 55 bytes que imprime

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

Versión de 62 bytes que funciona para cualquier entrada:

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

COW , 426 405 348 330 bytes

MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMMMmoOMMMMoOMoOMoOMoOMoOMoOMoOMoOMoO
MoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMMMmoOMMMMoOMoOMoOmoOoomMMM
moOMMMMOOmOomOoMoomoOmoOMOomoomOoMMMmoOMMMMOoMOoMOOmOomOomOomOoMoo
moOmoOMoomoOMMMmoOmoOMMMMOoMOoMOOmOomOomOomOoMoomoOmoOmoOmoOMOomoo
mOomOomOoMoomoOmoOMOomoomOomOomOomOoMoomoOmoOmoOMOOmOoMoomoOMOomoo

Pruébalo en línea! Cambie el número en la segunda línea a cualquier número para cambiar la salida.

El intérprete de COW que estoy usando aquí fue escrito en Perl (y es más nuevo que este desafío), pero aún puede obtener el mismo resultado ingresando el código aquí .

Explicación

; 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 bytes

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

repl.it

Nota: Una entrada de 1produce una salida de ##, pero nunca se produciría un cuadrado hueco para una entrada menor que 3, por lo que supongo que esto está bien.

Java 7, 113 112 110 bytes

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 byte guardado gracias a @ OlivierGrégoire ;
2 bytes guardados gracias a @cliffroot .

Solución derivada basada en mi respuesta Crear un cuadrado cruzado .

Pruébalo aquí

PowerShell v2 +, 48 47 bytes

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

-1 byte gracias a JohnLBevan

Toma entrada $n, establece $zcomo $nhashmarks, con $npost-decrementado. Encapsula eso en parens para colocar una copia en la tubería. Luego usa el operador de coma para crear una matriz de $nlíneas pre-decrementadas de #espacios #. Esos quedan en la tubería. Luego se coloca $znuevamente en la tubería. La salida implícita Write-Outputal final introduce una nueva línea entre elementos, por lo que la obtenemos gratis.

Dado que el código del OP no funciona para la entrada n <= 1, tomé eso como que tampoco necesitamos admitir la entrada 1.

Ejemplos

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

3
###
# #
###

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

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

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

C, 98 bytes

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);}}

Uso:

f(5)

05AB1E , 20 bytes

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

Pruébalo en línea!

O 18 bytes si podemos ignorar 1 <= n:

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

Pruébalo en línea!

WinDbg, 206 200 182 170 bytes

.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 bytes desde la eliminación de parens .ify el uso en jlugar de segundo.if

-18 bytes utilizando en flugar de a .forpara construir las cadenas.

-12 bytes por cadenas que no terminan en NULL, sino que pasan la longitud a da

La entrada se pasa a través del pseudo-registro $t0(por ejemplo r $t0 = 5; {above-code}).

Explicación:

.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
    '
}

Salida de muestra:

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 bytes

¡Guardado 3 bytes gracias a @lmis !

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

(No maneja 0o 1)

¡Para 13 bytes adicionales (a 71 bytes ), puede!

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

Estas soluciones son bastante simples: almacenan mucho para no repetirse y ahorrar unos pocos bytes. Sin minificar sin la variablsm se vería así:

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

¡Intentalo!

<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 bytes

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

Ruby, 39 bytes

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

Resulta ser más corto de esta manera que todas las cosas elegantes que estaba intentando. Tenga en cuenta que esto no maneja 0 o 1 en absoluto.

Python 2, 50 bytes

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

Obras para n>=2. Imprime cada línea con un signo de libra, n-2del símbolo apropiado, luego otro signo de libra.

Aliasing el símbolo de la libra da la misma longitud:

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

Otros intentos

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 bytes

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

Obras para n>=2. Define la operación de intercalar un carácter entre #una ncadena de caracteres terminados en línea nueva, luego lo aplica dos veces para hacer una cuadrícula 2D.

Llamar como:

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

C, 83 82 80 78 77 Bytes

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

Escóndete en una multiplicación y guarda un byte ...

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

También cuenta atrás j y ahorra unos cuantos más ...

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));}

Cuenta atrás i de n a cero y guarda algunos bytes ...

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 poco más fácil de entender y 1 byte más

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 bytes

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

PHP, 81 69 bytes

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

Correr con -r; proporcionar información como argumento.

Lanza un DivisionByZeroErrorpara input = 1.

R, 68 70 bytes

Funciona para n> 1. Gracias a @Billywob por un par de bytes intercambiando la matriz por una matriz.

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

Utiliza rbind y cbind para colocar filas y columnas de #'s alrededor de una matriz de espacios n-2. Las nuevas líneas también están vinculadas a las filas. La nueva línea en la fuente es significativa. La entrada es de STDIN

Lisp común, 150 130 bytes

-20 gracias a @Cyoce y @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 #\# #\#))

Uso:

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

Básicamente se usa formatdos veces para la parte superior e inferior y un bucle para las filas intermedias. La llamada de formato para la parte superior e inferior genera una línea que comienza #y se rellena al ancho apropiado con #s. La llamada de formato para las filas intermedias funciona de manera similar, excepto que el relleno es espacios y #se imprime al final de la línea.

Nota: Soy bastante nuevo en Lisp y espero tener mucho margen de mejora en esto.

Haskell, 67 bytes

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

Ejemplo de uso:

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

Cómo funciona:

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

Gelatina , 13, bytes

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

TryItOnline! o prueba de 0 a 15

¿Cómo?

,þ%µỊṀ€€ị⁾# 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 bytes

15 bytes de código, +1 para -nbandera.

(Y_Xa-2WR'#s)My

Funciona para entrada> = 2. ¡ Pruébelo en línea!

Explicación de la versión ungolfed

Primero, definimos una función yque toma un argumento de cadena, lo repite a-2veces (donde aes la primera entrada de línea de comando) y ajusta el resultado #.

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

A continuación, aplicamos esta función dos veces, una vez normalmente, luego otra vez con map, para obtener el cuadrado como una lista de cadenas:

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

Para entrada de 4, (y s)resultados en "# #"y y M (y s)en ["####"; "# #"; "# #"; "####"]. Este último valor se imprime, con el -nindicador que hace que se separe de la nueva línea.

Trucos de golf

Para pasar de la versión no golfista a la golfista:

• Eliminar espacios.
• Yes un operador, lo que significa que podemos usarlo en una expresión. En lugar de Y...seguir (ys), simplemente podemos hacer (Y...s).
• El problema es que tenemos que tirar de la función antes de volver a hacer referencia a ella como y; así yM(Y_Xa-2WR'#s)que no funcionará Solución: intercambie los operandos del Moperador ap. Mientras uno de ellos sea una función y el otro sea un tipo iterable, no importa en qué orden entren.

Raqueta 113 bytes

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

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

Pruebas:

(f 5)

Salida:

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

SpecBAS - 57 bytes

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

?es la abreviatura de PRINT, #13es el retorno de carro que se puede agregar al final de una cadena sin necesidad +de unirlos.

El apóstrofe mueve el cursor de impresión una línea hacia abajo.

Atascado, 29 27 Bytes

Bastante largo para un lenguaje de "golf", pero he olvidado cómo funciona mucho: P

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

Explicación:

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 bytes

Golfizado:

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));}

Sin 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: optimización de rango de bucle.

Lithp , 117 bytes

Línea dividida en dos para facilitar la lectura:

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

Uso de la muestra:

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