З огляду на ціле число n ≥ 1, виведіть 2D-представлення ^† знаку відсотка ширини n . Конструкція йде наступним чином:

1. Створіть матрицю n за n (або список списків), заповнену нулями.
2. Вставте їх у верхній лівий і нижній правий кути.
3. Розмістіть їх по діагоналі знизу вліво вгорі праворуч.

Для введення n = 4 ця конструкція виглядатиме так:

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

Це кодовий гольф , тому виграє найкоротша програма в байтах.

^† Я використовую матрицю 1s і 0s, але також прийнятно використовувати рядок будь-яких символів і пробілів, які не є пробілами. Отже, приклад вище може виглядати так:

#  #
  # 
 #  
#  #

або

#     #
    #
  # 
#     #

Тестові справи

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

Заключна примітка

Додавання пояснення буде дуже вдячним.

Желе , 6 байт

²Rm’Ṭs

Спробуйте в Інтернеті!

Як це працює

²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 байти

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

V , 15 байт

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

Спробуйте в Інтернеті!

Пояснення

Àé<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 байт

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

Спробуйте в Інтернеті!

GNU APL, 17 15 байт

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

Це один дивний день ... GNU насправді переміг Dyalog APL ... woah.

TIO не підтримує GNU APL ...

Пояснення (вхід є ⍵):

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 байт

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

Спробуйте в Інтернеті!

Виходи, як

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

Python 2 , 48 байт

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

Спробуйте в Інтернеті!

Виходи, як

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

Python 3 , 48 байт

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

Спробуйте в Інтернеті!

Зовсім інший підхід до підстановки рядків у Python 3. Виходи:

1001
0010
0100
1001

Желе , 9 байт

=þ¹UF1Q¦s

Спробуйте в Інтернеті!

Як це працює

=þ¹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 байт

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

Спробуйте в Інтернеті!

Здійснення цієї роботи для введення 1 додало 6 байт.

Дивлячись на тестовий зразок 4, ми бачимо вихід

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

Це в основному 1 0 0 повторюється по всій матриці. Іншими словами, 1 0 0 сформовано в матриці 4 на 4. Отже, у цьому рішенні ми спочатку генеруємо цей вектор за допомогою 1 та кінцевих 0, 1=⍳⍵-1а потім формуємо його за допомогою ⍵ ⍵⍴. Але це борки для введення 1, тому нам потрібно створити умовний і набрати 6 байт ...

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

Хаскелл , 55 байт

Спочатку мій підхід полягав у рекурсивному генеруванні транспонованої матриці ідентичності, але потім фіксація першого та останнього рядка вимагала деяких потворних / тривалих відмінностей у випадку. Тому я шукав інший спосіб генерувати матрицю ідентичності, саме так я і знайшов цю ідею.

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

Спробуйте в Інтернеті!

Пояснення

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

генерує цю матрицю (для n=4):

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

Як ви бачите, лівий верхній елемент - це 2(загалом), всі елементи діагоналі є 5(загалом n+1), а нижній правий - 8загалом 2*n. Тому все, що нам потрібно зробити, - це перевірити, чи x+yє елементом [2,n+1,2*n].

R , 54 42 байти

-12 байт завдяки Ярко Дуббелдам

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

повертає матрицю; читає зі стдін. створює матрицю ідентичності diag(n), перевертає її зверху вниз [,n:1], встановлює верхній лівий і нижній правий на 1, а потім пише на консоль ( '') з шириною n.

Спробуйте в Інтернеті!

MATL , 7 байт

XyPl5L(

Спробуйте в MATL Online!

Пояснення

Створіть матрицю ідентичності ( Xy), переверніть вертикально ( P), запишіть ( () значення 1 ( l) до першого та останнього записів ( 5L), які знаходяться вгорі ліворуч і праворуч знизу.

Діалог APL, 12 11 10 байт

,⍨⍴×,2↓⊢↑×

Спробуйте в Інтернеті

-1 байт завдяки lstefano.

Як?

,⍨⍴×,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 байт

-30 байт, тому що старий спосіб був дурним.

-3 байти шляхом переміщення по ініціалізації змінної

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

Спробуйте в Інтернеті!

Петлі повторюють масив вниз для заповнення 1-х. Повертає масив 1-х та 0-х.

05AB1E , 14 11 7 байт

n<ÝI<Öô

Спробуйте в Інтернеті!

Пояснення

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

Вугілля деревне , 14 12 7 байт

^{-5 байт завдяки Нілу !}

↗Ｎ⸿/‖Ｏ↘

Спробуйте в Інтернеті!

C ++, 144 байти

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

Скористається різницею в один байт між "#" і 35

Математика, 72 байти

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

вхід

[5]

вихід

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 байт

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

Спробуйте в Інтернеті!

-24 байти: Завдяки ідеї від Rod!

PowerShell , 67 байт

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

Спробуйте в Інтернеті!

Приймає вхідні $nі петлі від 0до --$n(тобто, $nпопередньо декрементируется). Кожну ітерацію ми побудуємо рядок з 1наступним $n-1 0s, а потім помножимо цей 3раз (наприклад, 100010001000для введення 5). Потім ми індексуємо це на обертовій основі, починаючи з 0до 0 + $n. Ці символи -joinперетворені в рядок, який залишається на конвеєрі. Вихід неявний.

(Примітка. Для обробки спеціального випадку потрібні додаткові 9 байт n=1. Нижче наведено 58-байтовий код, якщо ми гарантовані n>1)

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

Dyalog APL v16, 23 байти

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

Спробуйте в Інтернеті!

Пояснення:

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

Луа, 117 байт

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

Спробуй це

Код досить простий. Він встановлює m перший аргумент, потім додає 0, щоб перетворити його в число, потім повторює назад для координати Y, вперед через координату X і поставить #, якщо x == y, або якщо це інші кути.

Ця програма ніколи не використовує ключове слово "якщо".

Октава, 37 байт

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

Спробуйте в Інтернеті!

Створює розріджену матрицю, що представляє знак відсотка.

Japt , 12 байт

²ovUÉ hT1 òU

Повертає 2D масив / матрицю.

Спробуйте в Інтернеті! за допомогою-Q прапор, щоб показати вихід у форматі масиву.

Пояснення

²ovUÉ hT1 òU

Неявне: U= вхідне ціле число

²o

Квадрат U( ²), створити масив [0, U*U)( o) та зіставити кожен елемент по ...

vUÉ

1якщо він ділиться ( v) на U-1( UÉ), інше 0.

hT1

Встановіть елемент ( h) в індексі 0 ( T) на 1.

òU

Масив розділіть на фрагменти ( ò) довжини U.

PHP, 53 байти

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

Довжина сторони матриці дорівнює $l. У цьому коді є повідомлення про PHP і навіть попередження PHP про поділ на 0 коли $l=0, але це робить роботу!

Python 2 , 93 байт

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

Спробуйте в Інтернеті!

Рубін, 47 байт

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

Він повертає масив масивів.

Код досить простий.

• Він створює n-1масив 1як перший елемент, а решту заповнюється 0s (наприклад,[1, 0, 0, 0] )
• Це повторює
• Потрібні nшматочки nелементів

Спробуйте в Інтернеті!

J, 14 байт

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

Безголівки:

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

Спробуйте в Інтернеті!

Python 3, 97 байт

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

Пояснення

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

Це розуміння списку, 0+(j==n-i-1)це коротший спосіб перетворення j==n-i-1до int (на відміну від intфункції), а потім m[-1]=m[0]коротший, ніж створення нижнього правого 1, так як верхній і нижній рядки однакові.

По-четверте, 273 (без коментарів) 170 (гольф-іш)

: % 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 версія для уточнення коментованої версії:)

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

(Зверніть увагу, оскільки пробіл є основним роздільником у Forth, видалення кожного повернення каретки не має значення. Відступ, звичайно, має значення.)

(Прокоментував:)

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

(Приклади виконання:)

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

(Підсумкове зауваження: працює на один менший, ніж ширина біта інтерпретатора Forth. Я запустив вище на gforth, AMD64. Стародавній 16-розрядний Forth хотів би лише до 15 біт шириною і потребував трохи модифікації.)

C # (.NET Core) , 65 байт

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

Спробуйте в Інтернеті!

Алгоритм значно відрізняється від інших відповідей на C #, тому я вирішив опублікувати його окремо, а не як покращення. Натхненний найвищою оцінкою на відповідь Jelly, я раніше робив щось трохи менш компактне. Вихід є лінійним масивом, тому знадобиться певна логіка, щоб обернути його у 2D поза методом як є. Альтернативна версія вимагає 6 додаткових байтів, щоб вивести справжній 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;}

У мене також є цікава неконкуруюча версія.

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

Це закінчується майже правильним висновком, в результаті виходить IEnumerable<bool>істинний / хибний замість 1/0, і це лінійна, а не 2D структура, і хоча вона не потрібна для цього точного рядка коду, using System.Collections.Genericнеобхідно робити все корисне з вихід. Як я вже казав, це дуже близько до дійсності, але не зовсім.