Для целого числа n ≥ 1 выведите двумерное представление ^† знака процента ширины n . Конструкция идет следующим образом:

1. Создание п по п матрицу (или список списков), заполненную нулями.
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

Это код-гольф , поэтому выигрывает самая короткая программа в байтах.

^† Я использую матрицу из 1 и 0, но также допустимо использовать строку любого непробельного символа и пробелов. Итак, приведенный выше пример может выглядеть так:

#  #
  # 
 #  
#  #

или

#     #
    #
  # 
#     #

Контрольные примеры

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 ... воу.

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а затем формируем его, используя ⍵ ⍵⍴. Но это borks для ввода 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

Haskell , 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, а затем записывает в console ( '') с шириной n.

Попробуйте онлайн!

MATL , 7 байт

XyPl5L(

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

объяснение

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

Dyalog APL, 12 11 10 байт

,⍨⍴×,2↓⊢↑×

Попробуйте онлайн

-1 байт благодаря Исефано.

Как?

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

Mathematica, 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 байта: благодаря идее от Рода!

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

Square 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первым элементом, а остальные заполнены0 s (например,[1, 0, 0, 0] )
• Это повторяет
• Требуются nкусочки nэлементов

Попробуйте онлайн!

J, 14 байт

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

Ungolfed:

- ]\ (*: $ (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функции), а затем 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>true / false вместо 1/0, и это линейная, а не двумерная структура, и хотя она не нужна для этой точной строки кода, using System.Collections.Genericнеобходимо сделать что-нибудь полезное с выход. Как я уже сказал, это очень близко к действительности, но не совсем.