Étant donné un entier n ≥ 1, produire une représentation 2D ^† d'un signe de pourcentage de largeur n . La construction se déroule comme suit:

1. Créez une matrice n par n (ou une liste de listes) remplie de zéros.
2. Insérez-les dans les coins supérieur gauche et inférieur droit.
3. Placez-les sur la diagonale du coin inférieur gauche au coin supérieur droit.

Pour l'entrée n = 4, cette construction ressemblerait à:

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

Il s'agit d'un code-golf , donc le programme le plus court en octets l'emporte.

^† J'utilise une matrice de 1 et de 0, mais il est également acceptable d'utiliser une chaîne de caractères et d'espaces non blancs. Ainsi, l'exemple ci-dessus pourrait ressembler à:

#  #
  # 
 #  
#  #

ou

#     #
    #
  # 
#     #

Cas de test

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

Note finale

L'ajout d'une explication serait grandement apprécié.

Gelée , 6 octets

²Rm’Ṭs

Essayez-le en ligne!

Comment ça marche

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

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

V , 15 octets

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

GNU APL, 17 15 octets

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

C'est un jour étrange ... GNU a en fait battu Dyalog APL ... woah.

TIO ne prend pas en charge GNU APL ...

Explication (l'entrée est ⍵):

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 octets

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

Essayez-le en ligne!

Sorties comme

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

Python 2 , 48 octets

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

Essayez-le en ligne!

Sorties comme

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

Python 3 , 48 octets

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

Essayez-le en ligne!

Une approche de substitution de chaîne assez différente dans Python 3. Des sorties comme:

1001
0010
0100
1001

Gelée , 9 octets

=þ¹UF1Q¦s

Essayez-le en ligne!

Comment ça marche

=þ¹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 octets

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

Essayez-le en ligne!

Faire cela pour l'entrée 1 a ajouté 6 octets.

En regardant le testcase 4, nous voyons que la sortie est

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

Il s'agit essentiellement de 1 0 0 répété dans toute la matrice. En d'autres termes, 1 0 0 façonné dans une matrice 4 x 4. Donc, dans cette solution, nous générons d'abord ce vecteur avec 1 et les 0 de fin en utilisant 1=⍳⍵-1, puis le formons en utilisant ⍵ ⍵⍴. Mais cela fonctionne pour l'entrée 1, nous devons donc créer un conditionnel et gagner 6 octets ...

{⍵=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 octets

Au début, mon approche consistait à générer de manière récursive la matrice d'identité transposée, mais la correction de la première et de la dernière ligne nécessitait des distinctions de cas laides / longues. J'ai donc cherché une autre façon de générer la matrice d'identité et c'est ainsi que j'ai trouvé cette idée.

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

Essayez-le en ligne!

Explication

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

génère cette matrice (pour n=4):

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

Comme vous pouvez le voir, l'élément supérieur gauche est 2(en général), tous les éléments diagonaux sont 5(en général n+1) et l'élément inférieur droit est 8(en général 2*n). Donc, tout ce que nous devons faire est de vérifier si x+yest un élément de [2,n+1,2*n].

R , 54 42 octets

-12 octets grâce à Jarko Dubbeldam

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

renvoie une matrice; lit de stdin. crée une matrice d'identité diag(n), la retourne de haut en bas [,n:1], définit le haut à gauche et le bas à droite 1, puis écrit dans console ( '') avec width n.

Essayez-le en ligne!

MATL , 7 octets

XyPl5L(

Essayez-le sur MATL Online!

Explication

Créez une matrice d'identité ( Xy), retournez verticalement ( P), écrivez ( () la valeur 1 ( l) aux première et dernière entrées ( 5L), qui sont en haut à gauche et en bas à droite.

Dyalog APL, 12 11 10 octets

,⍨⍴×,2↓⊢↑×

Essayez-le en ligne

-1 octet grâce à lstefano.

Comment?

,⍨⍴×,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 octets

-30 octets parce que l'ancienne façon était stupide.

-3 octets en se déplaçant autour de l'initialisation 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;}

Essayez-le en ligne!

Les boucles parcourent le tableau pour remplir les 1. Renvoie un tableau de 1 et de 0.

05AB1E , 14 11 7 octets

n<ÝI<Öô

Essayez-le en ligne!

Explication

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

Fusain , 14 12 7 octets

^{-5 octets grâce à Neil !}

↗Ｎ⸿/‖Ｏ↘

Essayez-le en ligne!

C ++, 144 octets

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

Il tire parti de la différence d'un octet entre '#' et 35

Mathematica, 72 octets

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

contribution

[5]

sortie

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 octets

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

Essayez-le en ligne!

-24 octets: Merci à une idée de Rod!

PowerShell , 67 octets

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

Essayez-le en ligne!

Prend l'entrée $net les boucles de 0à --$n(c'est $n-à- dire pré-décrémentées). À chaque itération, nous construisons une chaîne de s 1suivie de $n-1 0s, puis multiplions celle-ci 3(par exemple, 100010001000pour l'entrée de 5). Ensuite, nous l'indexons sur une base rotative à partir de 0à 0 + $n. Ces caractères sont -joinédités dans une chaîne, qui est laissée sur le pipeline. La sortie est implicite.

(NB - Cela nécessite 9 octets supplémentaires pour gérer le cas spécial de n=1. Ci-dessous, le code de 58 octets si nous sommes garantis n>1)

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

Dyalog APL v16, 23 octets

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

Essayez-le en ligne!

Explication:

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

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

Essayez-le

Le code est assez simple. Il définit m au premier argument, puis y ajoute 0 pour le convertir en nombre, puis itère en arrière pour la coordonnée Y, en avant à travers la coordonnée X et mettra un # si x == y ou si ce sont les autres coins.

Ce programme n'utilise jamais le mot-clé "si".

Octave, 37 octets

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

Essayez-le en ligne!

Génère une matrice clairsemée représentant le signe de pourcentage.

Japt , 12 octets

²ovUÉ hT1 òU

Renvoie un tableau / matrice 2D.

Essayez-le en ligne! en utilisant l' -Qindicateur pour afficher la sortie au format tableau.

Explication

²ovUÉ hT1 òU

Implicite: U= entier en entrée

²o

Carré U( ²), créez le tableau [0, U*U)( o) et mappez chaque élément en ...

vUÉ

1s'il est divisible ( v) par U-1( UÉ), sinon 0.

hT1

Définissez l'élément ( h) à l'index 0 ( T) sur 1.

òU

Divisez le tableau en tranches ( ò) de longueur U.

PHP, 53 octets

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

La longueur du côté de la matrice est $l. Ce code a un avis PHP et même un avertissement PHP pour la division par 0 quand $l=0, mais fait le travail!

Python 2 , 93 octets

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

Essayez-le en ligne!

Rubis, 47 octets

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

Il renvoie un tableau de tableaux.

Le code est assez simple.

• Il crée un n-1tableau avec 1comme premier élément et le reste rempli de 0s (par exemple [1, 0, 0, 0])
• Il le répète
• Il prend des ntranches d' néléments

Essayez-le en ligne!

J, 14 octets

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

Non golfé:

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

Essayez-le en ligne!

Python 3, 97 octets

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

Explication

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

Ceci est une compréhension de liste, le 0+(j==n-i-1)est un moyen plus court de se convertir j==n-i-1en un int (par opposition à une intfonction), puis m[-1]=m[0]est plus court que de faire en bas à droite 1, car les lignes du haut et du bas sont identiques.

Forth, 273 (sans commentaires) 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 ;

(Version 273 pour clarifier la version commentée:)

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

(Notez que, comme l'espace est le principal délimiteur dans Forth, la suppression de chaque retour chariot ne ferait aucune différence. L'indentation, bien sûr, le fait.)

(Commenté:)

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

(Exemples d'exécution:)

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

(Remarque finale: fonctionne à un de moins que la largeur de bits de l'interpréteur Forth. J'ai exécuté ce qui précède sur gforth, AMD64. Un ancien Forth 16 bits n'irait qu'à 15 bits de large et aurait besoin d'un peu de modification.)

C # (.NET Core) , 65 octets

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

Essayez-le en ligne!

L'algorithme est nettement distinct de l'autre réponse C #, j'ai donc décidé de le publier séparément plutôt que comme une amélioration. Inspiré par la réponse Jelly la mieux notée, je faisais quelque chose d'un peu moins compact avant. La sortie est un tableau linéaire, il faudrait donc une certaine logique pour l'envelopper dans un 2D en dehors de la méthode telle quelle. Une version alternative nécessite 6 octets supplémentaires pour sortir en tant que véritable tableau 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;}

J'ai également une version non concurrente intéressante.

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

Cela se termine avec presque la bonne sortie, résultant en un IEnumerable<bool>avec vrai / faux au lieu de 1/0, et c'est une structure linéaire plutôt que 2D, et bien qu'elle ne soit pas nécessaire pour cette ligne de code exacte, elle using System.Collections.Genericest nécessaire pour faire quelque chose d'utile avec le sortie. Comme je l'ai dit, c'est très proche d'être valide mais pas tout à fait.