24

ได้รับจำนวนเต็มn ≥ 1 เอาท์พุทเป็นตัวแทน 2D ^†ของเครื่องหมายเปอร์เซ็นต์ของความกว้างn การก่อสร้างจะเป็นดังนี้:

สร้างnโดยnเมทริกซ์ (หรือรายการของรายการ) ที่เต็มไปด้วยเลขศูนย์
แทรกที่มุมบนซ้ายและมุมขวาล่าง
วางคนในแนวทแยงมุมจากซ้ายล่างไปขวาบน

สำหรับอินพุต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

หมายเหตุสุดท้าย

การเพิ่มคำอธิบายจะได้รับการชื่นชมอย่างมาก

code-golf ascii-art

— Conor O'Brien
แหล่งที่มา

โซลูชันของเราสามารถจัดทำดัชนี 0 ได้หรือไม่

— Kritixi Lithos

5

@ Cowquack ฉันจะบอกว่าไม่ คุณได้รับความกว้างไม่ใช่ดัชนี

— Conor O'Brien

เราสามารถแสดงรายการของรายการได้หรือไม่?

— xnor

@xnor ใช่; รายการของรายการและเมทริกซ์มีความหมายเหมือนกันในโพสต์ของฉัน ฉันจะเพิ่มคำถามนั้น

— Conor O'Brien

โปรดทราบว่านี่เป็น'1'+'0'*(n-2)ช่องว่างที่แทรกไว้

— CalculatorFeline

8

เยลลี่ 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.

— เดนนิส
แหล่งที่มา

นอกจากนี้²Ḷ%’¬sหรือ+þ%’=2

— ETHproductions

²Ḷọ’sใกล้มาก ...

— เดนนิส

ถ้ามีเพียง 1 ไบต์ "x คือหารด้วย y" ลิงก์ ...

— ETHproductions

@ETHproductions มีḍ@แต่นั่นเป็นสองไบต์

— Erik the Outgolfer

และฉันคิดว่าฉันฉลาดด้วย⁼þµ+1¦Ṫṁ³UG... จนกระทั่งมี²ปัญหาบางอย่างเกิดขึ้นกับเดนนิส

— Erik the Outgolfer

11

JavaScript (ES6), 52 ไบต์

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

— ETHproductions
แหล่งที่มา

7

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

— Kritixi Lithos
แหล่งที่มา

6

Python 2 , 58 57 ไบต์

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

ลองออนไลน์!

— คัน
แหล่งที่มา

5

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

— Zachary
แหล่งที่มา

Ninja'd?

— Kritixi Lithos

ที่นั่น ...

— Zacharý

ไม่สามารถเชื่อได้ว่าจริง ๆ แล้วฉันต้องแยก GNU APL เก่าออกของฉันว้าว

— Zacharý

และรับสิ่งนั้น !!

— Zacharý

Ooh, ฉันจะใช้แรงบันดาลใจจาก1=⍵∨และใช้มันในการแก้ปัญหาของฉัน

— Kritixi Lithos

5

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 ผลลัพธ์เช่น:

— XNOR
แหล่งที่มา

ทำ10L 10ไม่ได้เหรอ

— Zacharý

@ Zacharýฉันพึ่งจะเป็นLจุดสิ้นสุดเสมอดังนั้นฉันจึงสามารถตัดตัวอักษรจำนวนเดียวกันออกจากส่วนท้ายของตัวเลขขนาดใหญ่และตัวละครขนาดเล็ก

— xnor

โอ้ขอโทษฉันคิดว่าคุณใช้มันเป็นตัวเลขเท่านั้น ฉันไม่เคยรู้10และ10Lแตกต่าง

— Zacharý

4

เยลลี่ขนาด 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.

— เดนนิส
แหล่งที่มา

4

APL (Dyalog)ขนาด 18 ไบต์

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

ลองออนไลน์!

ทำให้งานนี้สำหรับอินพุต 1 ได้เพิ่ม 6 ไบต์

ดูที่ testcase 4 เราเห็นผลลัพธ์คือ

โดยทั่วไปแล้วนี่คือ 1 0 0 ซ้ำตลอดเมทริกซ์ กล่าวอีกนัยหนึ่ง 1 0 0 มีรูปร่างเป็นเมทริกซ์ 4 คูณ 4 ดังนั้นในการแก้ปัญหานี้เราสร้างเวกเตอร์นี้กับที่ 1 และต่อท้าย 0s ใช้แล้วรูปร่างมันใช้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

— Kritixi Lithos
แหล่งที่มา

4

Haskell , 55 ไบต์

ในตอนแรกวิธีการของฉันคือการสร้างเมทริกซ์เอกลักษณ์แบบ transposed ซ้ำ แต่จากนั้นการแก้ไขบรรทัดแรกและบรรทัดสุดท้ายนั้นต้องการความแตกต่างของกรณีที่น่าเกลียด ดังนั้นผมจึงมองหาวิธีการสร้างเมทริกซ์เอกลักษณ์อีกซึ่งเป็นวิธีการที่ฉันพบนี้ความคิด

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]

— ბიმო
แหล่งที่มา

4

R , 54 42 ไบต์

-12 ไบต์ขอบคุณ Jarko Dubbeldam

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

ส่งกลับเมทริกซ์ อ่านจาก stdin สร้างเมทริกซ์เอกลักษณ์diag(n)พลิกมันบนลงล่าง[,n:1]ชุดด้านบนซ้ายและขวาด้านล่างไป1แล้วเขียนไปยังคอนโซล ( '') nมีความกว้าง

ลองออนไลน์!

— จูเซปเป้
แหล่งที่มา

คุณได้รับอนุญาตให้ส่งออกเมทริกซ์เพื่อให้คุณสามารถบันทึกไม่กี่ไบต์โดยเปลี่ยนเป็นฟังก์ชั่น ( pryr::f)

— JAD

@JarkoDubbeldam ฉันทำได้ แต่แล้วฉันคิดว่าฉันต้องเปลี่ยนภาษาเป็นR+pryrดังนั้นฉันจึงพิจารณาว่าเป็นภาษาอื่น คุณสามารถส่งได้ฟรี! จากนั้นคุณสามารถใช้ความคิดจากคำตอบของนักต้มตุ๋นวัวซึ่งฉันคิดว่าจะสั้นกว่านี้ในบริบทนั้น (ซับ 1)

— Giuseppe

อืมฉันไม่แน่ใจว่าจะวาดเส้นตรงไหนเพื่อความซื่อสัตย์ คุณพิจารณาห้องสมุดที่ใช้ภาษาอื่นหรือไม่?

— JAD

1

นอกจากนี้การใช้function(n)อาจจะสั้นกว่าด้วย

— JAD

1

ซึ่งสั้นกว่าการใช้งานแบบออนไลน์ที่คุณอ้างอิง:function(n)matrix(rep(c(1,rep(0,n-2)),n+1),n,n)

— JAD

4

MATL , 7 ไบต์

XyPl5L(

ลองที่MATL Online!

คำอธิบาย

สร้างเมทริกซ์เอกลักษณ์ ( Xy) พลิกในแนวตั้ง ( P) เขียน ( () ค่า 1 ( l) ไปที่รายการแรกและสุดท้าย ( 5L) ซึ่งอยู่ด้านบนซ้ายและขวาล่าง

— หลุยส์เมนโด
แหล่งที่มา

4

Dyalog 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

— Zachary
แหล่งที่มา

ฉันไม่คิดว่ามันจะสามารถเล่นกอล์ฟได้อีกต่อไป ...

— Zacharý

สามารถ: ,⍨⍴×,2↓⊢↑×(10 ไบต์) ฉันถูกล่อลวงให้เพิ่ม: อย่าใช้การสื่อสารมากเกินไป ... :-P

— lstefano

ลองออนไลน์กับ arg 5 - ลองออนไลน์กับ arg 1

— lstefano

คุณต้องล้อเล่นฉันว้าว นิสัยดีของ signum

— Zacharý

3

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

— jkelm
แหล่งที่มา

ประกาศbเป็นvarบันทึกไบต์

— TheLethalCoder

3

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

— Emigna
แหล่งที่มา

3

Charcoal , 14 12 7 ไบต์

^{-5 ไบต์ขอบคุณNeil !}

↗Ｎ⸿/‖Ｏ↘

ลองออนไลน์!

— notjagan
แหล่งที่มา

ฉันไม่คิดว่ามันจะสั้นไปกว่านี้อีกแล้ว ...

— Erik the Outgolfer

1

ก่อนอื่นฉันจะตัดมันＮν◨/ν←↙ν‖Ｏ↘แต่แล้วฉันก็มาด้วย↗Ｎ⸿/‖Ｏ↘!

— Neil

@Neil ว้าวฉันไม่ได้รู้ว่าสิ่งที่⸿ทำ มันถูกรีเซ็ตเป็นตำแหน่งดั้งเดิมหรือไม่?

— notjagan

ไม่⸿เป็นเหมือน¶ในการที่จะเลื่อนลงแถว แต่มันก็ไปที่คอลัมน์ศูนย์ (วัดจากＪ) มากกว่าคอลัมน์ที่จุดเริ่มต้นของสตริงดังนั้นสำหรับตัวอย่างเป็นเช่นเดียวกับＪ⁵¦⁵⸿ Ｊ⁰¦⁶

— Neil

3

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

— HatsuPointerKun
แหล่งที่มา

อยู่ที่ไหนไม่ว่ารหัสของคุณใช้ประโยชน์จากความแตกต่างระหว่างหนึ่งไบต์'#'และ35?

— Zacharý

@ Zacharýดูเหมือนว่าจะอยู่ใน IDE ของฉัน x)

— HatsuPointerKun

2

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 1 0 0 0
1 0 0 0 1

— J42161217
แหล่งที่มา

1

ปัญหาไม่ได้ขอให้คุณพิมพ์ / แสดงผลดังนั้นคุณสามารถแทนที่Grid@sด้วยsเพื่อบันทึก 5 ไบต์

— Mark S.

2

Python 2 , 86 62 ไบต์

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

ลองออนไลน์!

-24 ไบท์: ขอบคุณไอเดียจาก Rod!

— Koishore Roy
แหล่งที่มา

2

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เอ็ดเป็นสตริงซึ่งเหลืออยู่บนไพพ์ไลน์ เอาท์พุทเป็นนัย

(NB - ต้องใช้ 9 ไบต์เพิ่มเติมเพื่อจัดการกรณีพิเศษn=1ด้านล่างคือรหัส 58- ไบต์หากเรารับประกันn>1)

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

— AdmBorkBork
แหล่งที่มา

2

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)

— Zachary
แหล่งที่มา

2

Lua, 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 coord ไปข้างหน้าผ่าน X coord และจะใส่ # if x == y หรือเป็นมุมอื่น ๆ

โปรแกรมนี้จะไม่ใช้คำหลัก "ถ้า"

— AI221
แหล่งที่มา

2

อ็อกเทฟ 37 ไบต์

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

ลองออนไลน์!

สร้างเมทริกซ์กระจัดกระจายคิดเป็นเปอร์เซ็นต์เครื่องหมาย

— rahnema1
แหล่งที่มา

2

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ที่มีความยาว

— Justin Mariner
แหล่งที่มา

ผมไม่คิดว่าคุณจริงต้องhT1เป็น0เป็นเทคนิคที่หารด้วยอยู่แล้วสำหรับทุกคนU Uนอกจากนั้นงานที่ดี :-)

— ETHproductions

@ETHproductions 1ที่ถูกเพิ่มเข้ามาในการจัดการกับการป้อนข้อมูลของ หากไม่มีมันก็จะส่งกลับ[[0]]เพราะเห็นได้ชัดว่าศูนย์ไม่หารด้วยศูนย์

— Justin Mariner

อ๊ะแล้วกัน ฉันไม่รู้ว่าควรแก้ไขหรือไม่แม้ว่า ...

— ETHproductions

2

PHP, 53 ไบต์

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

$lความยาวของด้านข้างของเมทริกซ์คือ รหัสนี้มีประกาศ PHP และแม้กระทั่งคำเตือน PHP สำหรับการหารด้วย 0 เมื่อ$l=0แต่จะทำงาน!

— jstnthms
แหล่งที่มา

ดูเหมือนว่าคุณคาดว่าอินพุตจะถูกเก็บไว้ในตัวแปรที่กำหนดไว้ล่วงหน้า (-> $l) แต่น่าเสียดายที่นี้คือไม่ได้เป็นหนึ่งในวิธีที่ได้รับการยอมรับของเราที่จะใช้การป้อนข้อมูล ในโพสต์เมตาที่เชื่อมโยงคุณจะพบทางเลือกอื่นเช่นการใช้อาร์กิวเมนต์บรรทัดคำสั่งตามที่เห็นในคำตอบของริคซิ

— nimi

แล้วเสร็จและเล่นกอล์ฟ: while($i**.5<$n=$argn)echo$i++%~-$n?0:1,"\n"[$i%$n];หรือwhile($i**.5<$n=$argn)echo+!($i++%~-$n),"\n"[$i%$n];(52 ไบต์ต่อคน)

— Titus

ความต้องการ<?ที่จุดเริ่มต้น

— manassehkatz-Reinstate Monica

2

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

ลองออนไลน์!

— Rohit-Pandey
แหล่งที่มา

ลองดี แต่ใช้ไม่ได้กับ n = 1

— mu 無

2

Ruby, 47 ไบต์

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

มันส่งกลับอาร์เรย์ของอาร์เรย์

รหัสค่อนข้างตรงไปตรงมา

มันสร้างn-1อาร์เรย์ด้วย1เป็นองค์ประกอบแรกและส่วนที่เหลือเต็มไปด้วย0s (เช่น[1, 0, 0, 0])
มันซ้ำมัน
มันต้องใช้nชิ้นส่วนของnองค์ประกอบ

ลองออนไลน์!

— Eric Duminil
แหล่งที่มา

2

J, 14 ไบต์

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

Ungolfed:

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

ลองออนไลน์!

— โยนาห์
แหล่งที่มา

อาหารสำหรับความคิด: การแก้ปัญหาที่มีอยู่ 10 ไบต์ :)

— Conor โอไบรอัน

@ ConorO'Brien ประณามคุณ มันผ่านมาแล้ว 3 โมงที่นี่: P

— Jonah

เหมือนกันที่นี่และที่นี่เรา: D

— Conor O'Brien

1

@ ConorO'Brien 0=<:|i.@,~ใช่ไหม?

— ไมล์

@miles ใช่มันเป็น :)

— Conor โอไบรอัน

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 เนื่องจากแถวด้านบนและด้านล่างเหมือนกัน

— Karan Elangovan
แหล่งที่มา

2

Forth, 273 (ไม่มีความคิดเห็น) 170 (golfed-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 เพื่อชี้แจงรุ่นที่แสดงความคิดเห็น :)

: 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 แล้ว Forth 16 บิตแบบโบราณจะไปที่ความกว้าง 15 บิตเท่านั้นและจำเป็นต้องปรับเปลี่ยนเล็กน้อย)

— Joel Rees
แหล่งที่มา

หากคุณต้องการให้รหัสที่ใส่ความเห็นไว้ในคำตอบของคุณนั้นใช้ได้ แต่คุณจำเป็นต้องมีรหัส golfed down ที่อื่นเช่นกัน

— Pavel

@ ฟีนิกซ์ขอบคุณ เสร็จสิ้น

— Joel Rees

2

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 # อื่น ๆ ดังนั้นฉันตัดสินใจที่จะโพสต์แยกต่างหากแทนที่จะเป็นการปรับปรุง แรงบันดาลใจจากคำตอบของเยลลี่ที่ติดอันดับยอดนิยมจริงๆแล้วฉันทำอะไรที่กะทัดรัดน้อยกว่านี้มาก่อน เอาท์พุทเป็นอาร์เรย์แบบเชิงเส้นดังนั้นจะต้องใช้ตรรกะบางอย่างเพื่อห่อมันเป็น 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ก็จำเป็นต้องทำทุกอย่างที่เป็นประโยชน์กับ เอาท์พุต อย่างที่ฉันพูดมันใกล้เคียงกับความถูกต้อง แต่ไม่มาก

— Kamil Drakari
แหล่งที่มา

สำหรับครั้งที่สองที่ใช้ประกอบไปด้วยในการ?1:0ทำงานและฉันเชื่อว่าอาร์เรย์ของผลควรจะดี คอลเลกชันที่ใช้ยังไม่จำเป็นสำหรับรหัสนั้น

— TheLethalCoder

สำหรับตอนแรกการตั้งค่าw*wเป็นตัวแปรและย้ายการintประกาศออกจากลูปจะช่วยคุณได้ไหม?

— TheLethalCoder

@TheLethalCoder การแทนที่สองอินสแตนซ์ของw*wด้วยอักขระตัวเดียวบันทึก 4 ไบต์การย้ายint i=0ภายนอกลูปต้องใช้เครื่องหมายอัฒภาคซึ่งมีค่าใช้จ่าย 1 ไบต์และจากนั้นเพิ่ม,s=w*wลงในการประกาศต้นทุน 6 ไบต์ดังนั้นจริง ๆ แล้ว nets +3 ไบต์

— Kamil Drakari

คุณควรใช้จำนวนไบต์ของโซลูชันการแสดง 2D แบบเต็ม อาร์เรย์ที่ส่งคืนโดยโซลูชันที่สั้นกว่านั้นอย่างน้อยจะต้องมีตัวคั่นบางประเภทให้ถูกต้อง

— จา

สร้างเครื่องหมายเปอร์เซ็นต์

กรณีทดสอบ

หมายเหตุสุดท้าย

เยลลี่ 6 ไบต์

มันทำงานอย่างไร

JavaScript (ES6), 52 ไบต์

V , 15 ไบต์

คำอธิบาย

Python 2 , 58 57 ไบต์

GNU APL, 17 15 ไบต์

Python 2 , 46 ไบต์

Python 2 , 48 ไบต์

Python 3 , 48 ไบต์

เยลลี่ขนาด 9 ไบต์

มันทำงานอย่างไร

APL (Dyalog)ขนาด 18 ไบต์

Haskell , 55 ไบต์

คำอธิบาย

R , 54 42 ไบต์

MATL , 7 ไบต์

คำอธิบาย

Dyalog APL, 12 11 10 ไบต์

อย่างไร?

C # (. NET Core) , 121 91 88 ไบต์

05AB1E , 14 11 7 ไบต์

Charcoal , 14 12 7 ไบต์

C ++, 144 ไบต์

Mathematica ขนาด 72 ไบต์

Python 2 , 86 62 ไบต์

PowerShellขนาด 67 ไบต์

Dyalog APL v16, 23 ไบต์

Lua, 117 ไบต์

อ็อกเทฟ 37 ไบต์

Japt , 12 ไบต์

คำอธิบาย

PHP, 53 ไบต์

Python 2 , 93 ไบต์

Ruby, 47 ไบต์

J, 14 ไบต์

Python 3, 97 ไบต์

คำอธิบาย

Forth, 273 (ไม่มีความคิดเห็น) 170 (golfed-ish)

(รุ่น 273 เพื่อชี้แจงรุ่นที่แสดงความคิดเห็น :)

(ความเห็น:)

(ตัวอย่างการดำเนินการ:)

C # (. NET Core) 65 ไบต์