Dado um número inteiro n ≥ 1, produza uma representação 2D ^† de um sinal de porcentagem da largura n . A construção é a seguinte:

1. Criar um n por n matriz (ou lista de listas) preenchido com zeros.
2. Insira os nos cantos superior esquerdo e inferior direito.
3. Coloque os na diagonal do canto inferior esquerdo para o canto superior direito.

Para entrada n = 4, essa construção seria semelhante a:

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 é um código de golfe , portanto o programa mais curto em bytes vence.

^† Uso uma matriz de 1s e 0s, mas também é aceitável usar uma sequência de caracteres e espaços que não sejam espaços em branco. Portanto, o exemplo acima pode ter a seguinte aparência:

#  #
  # 
 #  
#  #

ou

#     #
    #
  # 
#     #

Casos de teste

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

Adicionar uma explicação seria muito apreciado.

Gelatina , 6 bytes

²Rm’Ṭs

Experimente online!

Como 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

Experimente online!

Explicação

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

Experimente online!

APL GNU, 17 15 bytes

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

Este é um dia estranho ... O GNU venceu o Dyalog APL ... uau.

O TIO não suporta GNU APL ...

Explicação (a entrada é ⍵):

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)

Experimente online!

Saídas 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)

Experimente online!

Saídas 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)

Experimente online!

Uma abordagem de substituição de cadeia bastante diferente no Python 3. Resultados como:

1001
0010
0100
1001

Geléia , 9 bytes

=þ¹UF1Q¦s

Experimente online!

Como 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}

Experimente online!

Fazer esse trabalho para a entrada 1 adicionou 6 bytes.

Olhando para o testcase 4, vemos que a saída é

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

Isso é basicamente 1 0 0 repetido em toda a matriz. Em outras palavras, 1 0 0 moldado em uma matriz 4 por 4. Portanto, nesta solução, primeiro geramos esse vetor com 1 e arrastando 0s usando 1=⍳⍵-1e depois modelando-o usando ⍵ ⍵⍴. Mas isso atrapalha na entrada 1, então precisamos criar um condicional e ganhar 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

Inicialmente, minha abordagem foi gerar recursivamente a matriz de identidade transposta, mas a correção da primeira e da última linha exigia algumas distinções feias / longas de casos. Então, procurei outra maneira de gerar a matriz de identidade, e foi assim que encontrei essa ideia.

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

Experimente online!

Explicação

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

gera esta matriz (para n=4):

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

Como você pode ver, o elemento superior esquerdo é 2(em geral), todos os elementos diagonais são 5(em geral n+1) e o elemento inferior direito é 8(em geral 2*n). Então, tudo o que precisamos fazer é verificar se x+yé um elemento do [2,n+1,2*n].

R , 54 bytes 42

-12 bytes graças a Jarko Dubbeldam

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

retorna uma matriz; lê de stdin. cria uma matriz de identidade diag(n), vira-a de cima para baixo [,n:1], define a parte superior esquerda e a direita para 1e depois grava no console ( '') com largura n.

Experimente online!

MATL , 7 bytes

XyPl5L(

Experimente no MATL Online!

Explicação

Crie uma matriz de identidade ( Xy), vire verticalmente ( P), escreva ( () o valor 1 ( l) para a primeira e a última entrada ( 5L), que são a parte superior esquerda e a parte inferior direita.

Dyalog APL, 12 11 10 bytes

,⍨⍴×,2↓⊢↑×

Experimente online

-1 byte graças a lstefano.

Quão?

,⍨⍴×,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 o jeito antigo era estúpido.

-3 bytes movendo-se pela inicialização da variável

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

Experimente online!

Loops itera a matriz para preencher os 1s. Retorna uma matriz de 1 e 0.

05AB1E , 14 11 7 bytes

n<ÝI<Öô

Experimente online!

Explicação

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

Carvão , 14 12 7 bytes

^{-5 bytes graças a Neil !}

↗Ｎ⸿/‖Ｏ↘

Experimente online!

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

Aproveita a diferença de um byte entre '#' e 35

Mathematica, 72 bytes

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

entrada

[5]

saída

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

Experimente online!

-24 bytes: Graças a uma ideia de Rod!

PowerShell , 67 bytes

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

Experimente online!

Leva a entrada $ne os loops de 0para --$n(isto é, $npré-decrementado). A cada iteração, construímos uma sequência de 1seguidos por $n-1 0s e multiplicamos esse 3tempo limite (por exemplo, 100010001000para entrada de 5). Em seguida, indexamos isso rotativamente a partir de 0para 0 + $n. Esses caracteres são -joineditados em uma string, que é deixada no pipeline. A saída está implícita.

(NB - Isso requer 9 bytes adicionais para lidar com o caso especial de n=1. Abaixo está o código de 58 bytes, se estamos garantidos n>1)

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

Dyalog APL v16, 23 bytes

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

Experimente online!

Explicação:

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

Tente

O código é bem simples. Ele define m para o primeiro argumento, depois adiciona 0 a ele para convertê-lo em um número, depois itera para trás para a coordenada Y, para a frente através da coordenada X e colocará um # se x == y ou se for os outros cantos.

Este programa nunca usa a palavra-chave "if".

Oitava, 37 bytes

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

Experimente online!

Gera uma matriz esparsa representando o sinal de porcentagem.

Japonês , 12 bytes

²ovUÉ hT1 òU

Retorna uma matriz / matriz 2D.

Experimente online! usando o -Qsinalizador para mostrar a saída formatada em matriz.

Explicação

²ovUÉ hT1 òU

Implícito: U= número inteiro de entrada

²o

Quadrado U( ²), crie a matriz [0, U*U)( o) e mapeie cada item ...

vUÉ

1se é divisível ( v) por U-1( UÉ), mais 0.

hT1

Defina o item ( h) no índice 0 ( T) para 1.

òU

Divida a matriz em fatias ( ò) de comprimento U.

PHP, 53 bytes

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

O comprimento do lado da matriz é $l. Este código tem um aviso do PHP e até um aviso do PHP para divisão por 0 quando $l=0, mas faz o trabalho!

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

Experimente online!

Ruby, 47 bytes

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

Retorna uma matriz de matrizes.

O código é bem direto.

• Ele cria uma n-1matriz com 1o primeiro elemento e o restante é preenchido com 0s (por exemplo [1, 0, 0, 0])
• Repete
• Leva nfatias de nelementos

Experimente online!

J, 14 bytes

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

Ungolfed:

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

Experimente online!

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

Explicação

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

Essa é uma compreensão da lista, 0+(j==n-i-1)é uma maneira mais curta de converter j==n-i-1para um int (em oposição à intfunção) e, em seguida, m[-1]=m[0]é mais curta do que tornar o canto inferior direito 1, pois as linhas superior e inferior são idênticas.

Quarto, 273 (sem comentários) 170 (golfe)

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

(Versão 273 para esclarecer a versão 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 ! ;

(Observe que, como o espaço em branco é o principal delimitador em Forth, remover todos os retornos de carro não faria diferença. O recuo, é claro, faz.)

(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 ! ;

(Exemplos de execução:)

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 com um tamanho abaixo da largura do interpretador Forth. Executei o procedimento acima no gforth, AMD64. Um antigo Forth de 16 bits teria apenas 15 bits de largura e precisaria de algumas modificações.)

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

Experimente online!

O algoritmo é significativamente diferente da outra resposta C #, então decidi publicá-lo separadamente, e não como uma melhoria. Inspirado pela resposta Jelly mais votada, na verdade, eu estava fazendo algo um pouco menos compacto antes. A saída é uma matriz linear, portanto, exigiria alguma lógica para envolvê-la em um 2D fora do método como está. Uma versão alternativa requer 6 bytes adicionais para produzir como uma matriz 2D verdadeira:

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

Eu também tenho uma versão interessante não competitiva.

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

Isso acaba com a saída quase correta, resultando em uma IEnumerable<bool>com true / false em vez de 1/0, e é uma estrutura linear em vez de 2D e, embora não seja necessária para essa linha exata de código, using System.Collections.Genericé necessário fazer algo útil com o saída. Como eu disse, está muito perto de ser válido, mas não completamente.