Dado un número entero n ≥ 1, genera una representación 2D ^† de un signo de porcentaje de ancho n . La construcción es la siguiente:

1. Cree una matriz n por n (o lista de listas) llena de ceros.
2. Inserte unos en las esquinas superior izquierda e inferior derecha.
3. Coloca unos en la diagonal desde la esquina inferior izquierda hasta la esquina superior derecha.

Para la entrada n = 4, esta construcción se vería así:

1. 4x4 matrix of 0s
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
2. 1s in TL and BR corners
1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 1
3. 1s across BL-TR diagonal
1 0 0 1
0 0 1 0
0 1 0 0
1 0 0 1

Este es un código de golf , por lo que gana el programa más corto en bytes.

^† Uso una matriz de 1s y 0s, pero también es aceptable usar una cadena de caracteres y espacios que no sean espacios en blanco. Entonces, el ejemplo anterior podría verse así:

#  #
  # 
 #  
#  #

o

#     #
    #
  # 
#     #

Casos de prueba

n
output

1
1

2
1 1
1 1

3
1 0 1
0 1 0
1 0 1

4
1 0 0 1
0 0 1 0
0 1 0 0
1 0 0 1

10
1 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 0 1

Nota final

Agregar una explicación sería muy apreciado.

Jalea , 6 bytes

²Rm’Ṭs

Pruébalo en línea!

Cómo funciona

²Rm’Ṭs  Main link. Argument: n

²       Square; yield n².
 R      Range; yield [1, ..., n²].
   ’    Decrement; yield n-1.
  m     Modular; yield every (n-1)-th element of the range, staring with the first.
    Ṭ   Untruth; yield a Boolean array with 1's at the specified indices.
     s  Split the resulting array into chunks of length n, creating a matrix.

JavaScript (ES6), 52 bytes

n=>[...Array(n)].map((_,y,a)=>a.map(_=>y++%~-n<1|0))

V , 15 bytes

Àé ÀÄ|r#L.|ò.kl

Pruébalo en línea!

Explicación

Àé<space>        " Argument times insert a space
ÀÄ               " Argument times duplicate this line
                 " This gives an arg-by-arg matrix of spaces
                 "  and brings the cursor to the end of the first line
|r#              " Go to the beginning of this line and replace the first character with #
L.               " Go to the end of this matrix (bottom-right corner) and replace that character with a #
|                " Go to the beginning of the last line
ò                " Recursively do:
 .               "  Repeat the last action, r#, replace the character under the cursor with #
 kl              "  Go 1 up and 1 right

Python 2 , 58 57 bytes

n=input()
x='#'.ljust(n-1)*3
exec'print x[:n];x=x[1:];'*n

Pruébalo en línea!

GNU APL, 17 15 bytes

{1=⍵∨⍵⍵⍴1=⍳⍵-1}

Este es un día extraño ... GNU realmente venció a Dyalog APL ... woah.

TIO no es compatible con GNU APL ...

Explicación (la entrada es ⍵):

1=⍳⍵-1 - 1 followed by ⍵-2 0's
⍵⍵⍴    - fit into a square
⍵∨     - gcd ⍵ (0 gcd n = n)
1=     - test each element for equality with 1

Python 2 , 46 bytes

lambda n:zip(*[iter(`10L**n`[:-3]*-~n+'1')]*n)

Pruébalo en línea!

Salidas como

[('1', '0', '0', '1'), ('0', '0', '1', '0'), ('0', '1', '0', '0'), ('1', '0', '0', '1')]

Python 2 , 48 bytes

lambda n:zip(*[iter([1]+(n*[0]+[1])[2:]*-~n)]*n)

Pruébalo en línea!

Salidas como

[(1, 0, 0, 1), (0, 0, 1, 0), (0, 1, 0, 0), (1, 0, 0, 1)]

Python 3 , 48 bytes

lambda n:('%d'*n+'\n')*n%(1,*(*[0]*n,1)[2:]*-~n)

Pruébalo en línea!

Un enfoque de sustitución de cadenas bastante diferente en Python 3. Resultados como:

1001
0010
0100
1001

Jalea , 9 bytes

=þ¹UF1Q¦s

Pruébalo en línea!

Cómo funciona

=þ¹UF1Q¦s  Main link. Argument: n

  ¹        Identity; yield n.
=þ         Equals table; compare each i in [1, ..., n] with each j in [1, ..., n].
           This yields the n×n identity matrix.
   U       Upend; reverse each row.
    F      Flatten the matrix.
       ¦   Sparse application:
      Q        Unique; yield the unique elements of the constructed array, i.e.,
               [1] if n = 1 and [0, 1] if n > 1.
     1         Yield 1.
           This replaces the elements at indices 0 (last) and 1 (first) with 1.
        s  Split the resulting array into chunks of length n.

APL (Dyalog) , 18 bytes

{⍵=1:⍵⋄⍵ ⍵⍴1=⍳⍵-1}

Pruébalo en línea!

Hacer que esto funcione para la entrada 1 ha agregado 6 bytes.

Mirando el caso de prueba 4, vemos que la salida es

1 0 0 1
0 0 1 0
0 1 0 0
1 0 0 1

Esto es básicamente 1 0 0 repetido en toda la matriz. En otras palabras, 1 0 0 en forma de matriz de 4 por 4. Entonces, en esta solución, primero generamos este vector con 1 y ceros finales usando 1=⍳⍵-1y luego le damos forma ⍵ ⍵⍴. Pero esto funciona para la entrada 1, por lo que debemos crear un condicional y ganar 6 bytes ...

{⍵=1:⍵⋄⍵ ⍵⍴1=⍳⍵-1}    The right argument is ⍵
 ⍵=1:⍵                 If ⍵ is 1 return itself
⋄                      Otherwise
 ⍳⍵-1                   Create a range 1 .. ⍵-1
 1=                     Equals 1; 1 0 0 {⍵-2 0's} ...
 ⍵ ⍵⍴                   Shape in a ⍵-by-⍵ matrix

Haskell , 55 bytes

Al principio, mi enfoque consistía en generar recursivamente la matriz de identidad transpuesta, pero luego arreglar la primera y última línea requería algunas distinciones de casos feos / largos. Así que busqué otra forma de generar la matriz de identidad, que es cómo encontré esta idea.

f n=[[sum[1|x+y`elem`[2,n+1,2*n]]|y<-[1..n]]|x<-[1..n]]

Pruébalo en línea!

Explicación

[[x+y|y<-[1..n]]|x<-[1..n]]

genera esta matriz (para n=4):

[2,3,4,5]
[3,4,5,6]
[4,5,6,7]
[5,6,7,8]

Como puede ver, el elemento superior izquierdo es 2(en general), todos los elementos diagonales son 5(en general n+1) y el elemento inferior derecho es 8(en general 2*n). Entonces, todo lo que tenemos que hacer es verificar si x+yes un elemento de [2,n+1,2*n].

R , 54 42 bytes

-12 bytes gracias a Jarko Dubbeldam

n=scan();m=diag(n)[,n:1];m[1,1]=m[n,n]=1;m

devuelve una matriz; lee de stdin. crea una matriz de identidad diag(n), la voltea de arriba a abajo [,n:1], establece la parte superior izquierda e inferior derecha 1y luego escribe en console ( '') con ancho n.

Pruébalo en línea!

MATL , 7 bytes

XyPl5L(

¡Pruébalo en MATL Online!

Explicación

Crear matriz de identidad ( Xy), voltear verticalmente ( P), escribir ( () valor 1 (l ) en la primera y última entrada ( 5L), que están en la parte superior izquierda y en la parte inferior derecha.

Dyalog APL, 12 11 10 bytes

,⍨⍴×,2↓⊢↑×

Pruébalo en línea

-1 byte gracias a lstefano.

¿Cómo?

,⍨⍴×,2↓⊢↑×
       ⊢↑× - argument-length extension of the sign of the argument (1)
     2↓    - Drop the first two elements
   ×,      - Prepend a one
,⍨⍴        - Shape into a square array with dimensions of input x input

C # (.NET Core) , 121 91 88 bytes

-30 bytes porque la vieja forma era estúpida.

-3 bytes moviéndose alrededor de la inicialización variable

n=>{int i=0,k=n-1;int[,]b=new int[n,n];b[0,0]=b[k,k]=1;for(;i<n;)b[i++,k--]=1;return b;}

Pruébalo en línea!

Los bucles iteran hacia abajo en la matriz para completar los 1. Devuelve una matriz de 1 y 0.

05AB1E , 14 11 7 bytes

n<ÝI<Öô

Pruébalo en línea!

Explicación

n<Ý      # push range [0 ... n^2-1]
   I<Ö   # check each for equality to 0 when modulus with n-1 is taken
      ô  # split in pieces of size n

Carbón , 14 12 7 bytes

^{-5 bytes gracias a Neil !}

↗Ｎ⸿/‖Ｏ↘

Pruébalo en línea!

C ++, 144 bytes

#include<string>
#define S std::string
S p(int n){S r;for(int i=0;i<n;++i){r+=S(n,32);r[r.size()-1-i]=35;r+=10;}r[0]=r[r.size()-2]=35;return r;}

Aprovecha la diferencia de un byte entre '#' y 35

Mathematica, 72 bytes

(s=Table[0,#,#];s[[1,1]]=s[[#,#]]=1;Table[s[[#+1-i,i]]=1,{i,#}];Grid@s)&

entrada

[5]

salida

1 0 0 0 1
0 0 0 1 0
0 0 1 0 0
0 1 0 0 0
1 0 0 0 1

Python 2 , 86 62 bytes

n=input();a=('1'+'0'*(n-2))*2+'1'
exec'print a[:n];a=a[1:];'*n

Pruébalo en línea!

-24 bytes: ¡Gracias a una idea de Rod!

PowerShell , 67 bytes

param($n)0..--$n|%{-join(("1"+"0"*(($n-1),0)[!$n])*3)[$_..($_+$n)]}

Pruébalo en línea!

Toma entradas $ny bucles desde 0hasta --$n(es decir, $npre-decrementado). Cada iteración, construimos una cadena de 1seguido de $n-1 0s, luego multiplicamos los 3tiempos de salida (por ejemplo, 100010001000para la entrada de 5). Luego lo indexamos en forma rotativa a partir de 0a 0 + $n. Esos caracteres se -joineditan en una cadena, que se deja en la tubería. La salida es implícita.

(Nota: esto requiere 9 bytes adicionales para manejar el caso especial de n=1. A continuación se muestra el código de 58 bytes si estamos garantizados n>1)

param($n)0..--$n|%{-join(("1"+"0"*($n-1))*3)[$_..($_+$n)]}

Dyalog APL v16, 23 bytes

{(1@(1 1)(⍵ ⍵))⌽∘.=⍨⍳⍵}

Pruébalo en línea!

Explicación:

{(1@(1 1)(⍵ ⍵))⌽∘.=⍨⍳⍵} -(input ⍵) 
                ∘.=⍨⍳⍵  - identity matrix with size ⍵×⍵
               ⌽        - flip that
 (1@(1 1)(⍵ ⍵))         - place 1 into the corners using the v16 operator @ (At)

Lua, 117 bytes

m=arg[1]+0 for y=m,1,-1 do s=""for x=1,m do s=s..((x==1 and y==m or x==m and y==1 or x==y)and"#"or" ")end print(s)end

Intentalo

El código es bastante simple. Establece m en el primer argumento, luego agrega 0 para convertirlo en un número, luego itera hacia atrás para la coordenada Y, avanza a través de la coordenada X y pondrá un # si x == y si son las otras esquinas.

Este programa nunca usa la palabra clave "if".

Octava, 37 bytes

@(n)sparse([1 n:-1:1 n],[1 1:n n],!0)

Pruébalo en línea!

Genera una matriz dispersa que representa el signo de porcentaje.

Japt , 12 bytes

²ovUÉ hT1 òU

Devuelve una matriz / matriz 2D.

Pruébalo en línea! utilizando la-Q bandera para mostrar la salida con formato de matriz.

Explicación

²ovUÉ hT1 òU

Implícito: U= entero de entrada

²o

Square U( ²), crea la matriz [0, U*U)( o) y asigna cada elemento por ...

vUÉ

1si es divisible ( v) por U-1( UÉ), de lo contrario 0.

hT1

Establezca el elemento ( h) en el índice 0 ( T) en 1.

òU

Divida la matriz en rodajas ( ò) de longitud U.

PHP, 53 bytes

for(;$i<$l*$l;)echo($i++%($l-1)?0:1).($i%$l?'':"\n");

La longitud del lado de la matriz es $l. Este código tiene un aviso PHP e incluso un aviso PHP para la división por 0 cuando $l=0, ¡pero hace el trabajo!

Python 2 , 93 bytes

n=input()
a='1'+'0'*(n-2)+'1'
print a
for i in range(1,n-1):print str(10**i).zfill(n)
print a

Pruébalo en línea!

Ruby, 47 bytes

->n{([1]+[0]*(n-2)).cycle.each_slice(n).take n}

Devuelve una matriz de matrices.

El código es bastante sencillo.

• Crea una n-1matriz con 1el primer elemento y el resto con 0s (p [1, 0, 0, 0]. Ej. )
• Lo repite
• Toma nrodajas de nelementos

Pruébalo en línea!

J, 14 bytes

-]\*:$1,0$~-&2 

Sin golf:

- ]\ (*: $ (1,0 $~ -&2))

Pruébalo en línea!

Python 3, 97 bytes

def f(n):
    m=[[0+(j==n-i-1)for j in range(n)]for i in range(n)]
    m[0][0]=1
    m[-1]=m[0]
    return m

Explicación

m=[[0+(j==n-i-1)for j in range(n)]for i in range(n)]

Esta es una comprensión de la lista, 0+(j==n-i-1)es una forma más corta de convertir j==n-i-1a int (en oposición a la intfunción) y luego m[-1]=m[0]es más corta que hacer la esquina inferior derecha 1, ya que las filas superior e inferior son idénticas.

Adelante, 273 (sin comentarios) 170 (golf-ish)

: % 2 base ! cr dup 1- 1 swap lshift 1 or . cr 2 over 2 - dup 0< 0= if
0 ?do 2dup s>d rot <# 0 ?do # loop #> type cr 2*  loop
1 or . else drop drop then cr drop decimal ;

(273 versión para aclarar la versión comentada:)

: newbase
 base @ swap base ! ;
: 0u.r
 swap s>d rot <# 0 ?do # loop #> type ;
: frame
 1- 1 swap lshift 1 or ;
: %
 2 newbase swap
 cr dup frame . cr
 2 over 2 -
 dup 0< 0= if
  0 ?do
   2dup swap 0u.r cr
   2* 
  loop
  1 or .
 else
  drop drop
 then
cr
drop base ! ;

(Tenga en cuenta que, dado que el espacio en blanco es el delimitador principal en Forth, eliminar cada retorno de carro no haría ninguna diferencia. La sangría, por supuesto, lo hace).

(Comentado:)

( Uses bit array, max 64 width on AMD64 with gforth. )

( Could shave an extra thirty or so bytes by not restoring )
( the numeric base, )
( and a few more by pulling frame and 0u.r into the definition. )

: newbase ( n -- oldbase )  ( swap base with n )
 base @ swap base ! ;

: 0u.r ( u width -- )  ( unsigned numeric output, no leading zero suppression )
 swap s>d rot <# 0 ?do # loop #> type ;

: frame ( n -- f )  ( frame )
 1- 1 swap lshift 1 or ;

: %  ( n -- )  ( Make the % sign )
 2 newbase swap ( Use binary output. )
 cr dup frame . cr ( Frame the first line. )
 2 over 2 -
 dup 0< 0= if ( Are we already done? )
  0 ?do ( Loop doesn't do the first or last. )
   2dup swap 0u.r cr ( Zero fill, right justify. )
   2* 
  loop
  1 or . ( Put the second frame out. )
 else
  drop drop
 then
cr
drop base ! ;

(Ejemplos de ejecución:)

1 % 
1 

 ok
2 % 
11 
11 
 ok
3 % 
101 
010
101 
 ok
10 % 
1000000001 
0000000010
0000000100
0000001000
0000010000
0000100000
0001000000
0010000000
0100000000
1000000001 
 ok
40 % 
1000000000000000000000000000000000000001 
0000000000000000000000000000000000000010
0000000000000000000000000000000000000100
0000000000000000000000000000000000001000
0000000000000000000000000000000000010000
0000000000000000000000000000000000100000
0000000000000000000000000000000001000000
0000000000000000000000000000000010000000
0000000000000000000000000000000100000000
0000000000000000000000000000001000000000
0000000000000000000000000000010000000000
0000000000000000000000000000100000000000
0000000000000000000000000001000000000000
0000000000000000000000000010000000000000
0000000000000000000000000100000000000000
0000000000000000000000001000000000000000
0000000000000000000000010000000000000000
0000000000000000000000100000000000000000
0000000000000000000001000000000000000000
0000000000000000000010000000000000000000
0000000000000000000100000000000000000000
0000000000000000001000000000000000000000
0000000000000000010000000000000000000000
0000000000000000100000000000000000000000
0000000000000001000000000000000000000000
0000000000000010000000000000000000000000
0000000000000100000000000000000000000000
0000000000001000000000000000000000000000
0000000000010000000000000000000000000000
0000000000100000000000000000000000000000
0000000001000000000000000000000000000000
0000000010000000000000000000000000000000
0000000100000000000000000000000000000000
0000001000000000000000000000000000000000
0000010000000000000000000000000000000000
0000100000000000000000000000000000000000
0001000000000000000000000000000000000000
0010000000000000000000000000000000000000
0100000000000000000000000000000000000000
1000000000000000000000000000000000000001 
 ok

(Nota final: funciona a uno menos que el ancho de bits del intérprete Forth. Ejecuté lo anterior en gforth, AMD64. Un antiguo Forth de 16 bits solo tendría 15 bits de ancho y necesitaría un poco de modificación).

C # (.NET Core) , 65 bytes

w=>{var l=new int[w*w];for(int i=0;i<w*w;i+=w-1)l[i]=1;return l;}

Pruébalo en línea!

El algoritmo es significativamente diferente de la otra respuesta de C #, así que decidí publicarlo por separado en lugar de como una mejora. Inspirado por la respuesta Jelly mejor calificada en realidad, estaba haciendo algo un poco menos compacto antes. La salida es una matriz lineal, por lo que requeriría algo de lógica para envolverla en un 2D fuera del método tal como está. Una versión alternativa requiere 6 bytes adicionales para salir como una verdadera matriz 2D:

w=>{var l=new int[w,w];for(int i=0;i<w*w;i+=w-1)l[i/w,i%w]=1;return l;}

También tengo una versión interesante no competitiva.

using System.Linq;w=>new int[w*w].Select((_,i)=>i%(w-1)<1)

Esto termina con casi la salida correcta, lo que resulta en un IEnumerable<bool>verdadero / falso en lugar de 1/0, y es una estructura lineal en lugar de 2D, y aunque no es necesario para esa línea exacta de código, using System.Collections.Generices necesario hacer algo útil con el salida. Como dije, está muy cerca de ser válido pero no del todo.