24

एक पूर्णांक को देखते हुए n ≥ 1, उत्पादन एक 2D प्रतिनिधित्व ^† चौड़ाई का एक प्रतिशत चिह्न के एन । निर्माण निम्नानुसार है:

शून्य से भरे एन मैट्रिक्स (या सूचियों की सूची) द्वारा एक एन बनाएं ।
ऊपर-बाएँ और नीचे-दाएँ कोनों में डालें।
विकर्ण पर नीचे-बाएँ से ऊपरी-दाएं पर रखें।

इनपुट 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

यह एक कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।

^Matrix मैं 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

अंतिम नोट

स्पष्टीकरण जोड़कर बहुत सराहना की जाएगी।

code-golf ascii-art

— कोनोर ओ ब्रायन
स्रोत

क्या हमारे समाधान 0-अनुक्रमित हो सकते हैं?

— कृति लिथोस

5

@Cowsquack मैं नहीं कहूँगा। आप चौड़ाई प्राप्त कर रहे हैं, सूचकांक नहीं।

— कॉनर ओ'ब्रायन

क्या हम सूचियों की सूची तैयार कर सकते हैं?

— xnor

@ एक्सनॉर हाँ; सूचियों और मैट्रिक्स की सूची मेरे पोस्ट का पर्याय है। मैं इस प्रश्न से जोड़ता हूं

— कॉनर ओ'ब्रायन

ध्यान दें कि यह '1'+'0'*(n-2)व्हाट्सएप डाला के साथ है

— कैलक्यूलेटरफल

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 ḍ@लेकिन दो बाइट्स हैं।

— एरिक आउटगॉल्फ

और मुझे लगा कि मैं ⁼þµ+1¦Ṫṁ³UGतब तक चालाक था ... जब तक एक डेनिस- ²सॉलोमेस्टिंग समाधान नहीं निकला।

— एरिक आउटगॉल्फ

11

जावास्क्रिप्ट (ईएस 6), 52 बाइट्स

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

— ETHproductions
स्रोत

7

वी , 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

— क्रिकटी लिथोस
स्रोत

6

पायथन 2 , 58 57 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— छड़ी
स्रोत

5

जीएनयू एपीएल, 17 15 बाइट्स

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

यह एक अजीब दिन है ... जीएनयू ने वास्तव में दिल्लोग एपीएल ... वाह को हराया।

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

— जाकारी
स्रोत

Ninja'd?

— १५:२५ बजे कृति लिथोस

वहाँ ... वह ले लो।

— जकार्इ

विश्वास नहीं कर सकता कि मुझे वास्तव में अपने पुराने जीएनयू एपीएल को तोड़ना था, वाह।

— ज़ाचरी

और वो लो !!

— जकार्इ

ओह, मैं इससे प्रेरणा लेने जा रहा हूं 1=⍵∨और इसे अपने समाधान में लागू करने जा रहा हूं

— क्रिति लिथोस

5

पायथन 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')]

पायथन 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)]

पायथन 3 , 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

पायथन में एक बहुत अलग स्ट्रिंग-प्रतिस्थापन दृष्टिकोण 3. आउटपुट जैसे:

— XNOR
स्रोत

क्या आप नहीं बना सकते 10L 10?

— २०:३० पर जचारि

@ Zacharý मैं हमेशा वहाँ Lअंत में भरोसा कर रहा हूँ ताकि मैं बड़ी संख्या और छोटे लोगों के अंत से समान वर्णों को काट सकूँ ।

— क्नोर

ओह, क्षमा करें, मुझे गलती से लगा कि आप इसे केवल संख्या के रूप में उपयोग कर रहे हैं। मैं कभी नहीं जानता था 10और 10Lअलग थे।

— ज़ाचरी

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

एपीएल (डायलॉग) , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट 1 के लिए यह काम करते हुए 6 बाइट्स जोड़े गए हैं।

टेस्टकेस 4 को देखते हुए, हम देखते हैं कि आउटपुट है

यह मूल रूप से 1 1 0 मैट्रिक्स भर में दोहराया गया है। दूसरे शब्दों में, 4-बाय -4 मैट्रिक्स में 1 0 0 आकार। तो इस समाधान में, हम पहले इस वेक्टर को 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

— क्रिकटी लिथोस
स्रोत

4

हास्केल , 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]।

— ბიმო
स्रोत

4

आर , ५४ 42 बाइट्स

-12 बाइट्स जारको डबेलडैम के लिए धन्यवाद

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

मैट्रिक्स लौटाता है; स्टड से पढ़ता है। एक पहचान मैट्रिक्स बनाता है diag(n), इसे ऊपर से नीचे तक फ़्लिप [,n:1]करता है, ऊपर बाईं ओर और नीचे दाईं ओर सेट करता है 1, और फिर ''चौड़ाई पर कंसोल ( ) लिखता हैn ।

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत

आपको मैट्रिक्स को आउटपुट करने की अनुमति है, इसलिए आप इसे फ़ंक्शन ( pryr::f) में बदलकर कुछ बाइट्स बचा सकते हैं ।

— JAD

@JarkoDubbeldam मैं कर सकता था, लेकिन फिर मुझे लगता है कि मुझे भाषा बदलनी होगी, R+pryrइसलिए मैं इस पर विचार करूंगा कि एक अलग भाषा; आप इसे जमा करने के लिए स्वतंत्र हैं! फिर आप गायों के जवाब से विचार का उपयोग कर सकते हैं जो मुझे लगता है कि इस संदर्भ में (1-लाइनर) से भी छोटा होगा।

— ग्यूसेप

हम्म, मैं अनिश्चित हूं जहां ईमानदार होने के लिए रेखा खींचनी है। क्या आप इस बात पर विचार करेंगे कि किसी भी पुस्तकालय ने एक अलग भाषा का उपयोग किया है?

— 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 ऑनलाइन पर यह कोशिश करो !

व्याख्या

पहचान मैट्रिक्स ( Xy) बनाएं , लंबवत रूप से फ्लिप करें ( P), लिखें ( () मान 1 ( l) से पहली और आखिरी प्रविष्टियां ( 5L), जो ऊपर बाएं और नीचे दाएं हैं।

— लुइस मेंडो
स्रोत

4

डायलॉग एपीएल, 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

— जाकारी
स्रोत

मैं गंभीरता से नहीं लगता है कि यह अब और गोल्फ हो सकता है ... वाह।

— ज़ाचरी

यह कर सकते हैं: ,⍨⍴×,2↓⊢↑×(10 बाइट्स)। मुझे जोड़ने का प्रलोभन दिया जा रहा है: बहुत सारे आवागमन का उपयोग न करें ...

— --P

आर्ग 5 के साथ ऑनलाइन की कोशिश करो - आर्ग 1 के साथ ऑनलाइन की कोशिश करो

— lstefano

तुम मुझसे मजाक कर रहे हो, वाह। साइनम का अच्छा दुरुपयोग।

— ज़ाचारि १४'१

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।

— द लीथलकोडर

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

चारकोल , 14 12 7 बाइट्स

^{-5 बाइट्स नील को धन्यवाद !}

↗Ｎ⸿/‖Ｏ↘

इसे ऑनलाइन आज़माएं!

— notjagan
स्रोत

मुझे नहीं लगता कि यह कोई भी छोटा हो सकता है ...

— एरिक आउटगॉल्फ

1

खैर, पहले मैंने इसे ट्रिम किया Ｎν◨/ν←↙ν‖Ｏ↘, लेकिन फिर मैं साथ आ गया ↗Ｎ⸿/‖Ｏ↘!

— नील

@ नील वाह, मैं भी नहीं जानता कि क्या ⸿करता है। क्या यह मूल स्थिति पर रीसेट हो जाता है?

— नॉटजागन

नहीं, ⸿उस तरह ¶से यह एक पंक्ति से नीचे चला जाता है, लेकिन यह हमेशा Ｊस्ट्रिंग की शुरुआत में कॉलम के बजाय कॉलम शून्य (जैसा कि मापा जाता है ) पर जाता है , इसलिए उदाहरण Ｊ⁵¦⁵⸿के लिए समान है Ｊ⁰¦⁶।

— नील

3

सी ++, 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ý ऐसा लगता है कि यह मेरी IDE x में था)

— HatsuPointerKun

2

गणितज्ञ, 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 1 0 0
1 1 0 0 1
1 0 0 1 1

— J42161217
स्रोत

1

समस्या तो आप बदल सकते हैं, मुद्रित करने के लिए / इसे प्रदर्शित आप से पूछना नहीं है Grid@sके साथ sकरने के लिए 5 बचाने बाइट्स।

— मार्क एस।

2

पायथन 2 , 86 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-24 बाइट्स: रॉड से एक विचार के लिए धन्यवाद!

— कोइशोर रॉय
स्रोत

2

पॉवरशेल , 67 बाइट्स

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

इसे ऑनलाइन आज़माएं!

से इनपुट $nऔर लूप लेता 0है --$n(यानी, $nपूर्व-विघटित)। प्रत्येक पुनरावृत्ति, हम 1उसके बाद $n-1 0एस के एक तार का निर्माण करते हैं , फिर उस 3समय से गुणा करें (उदाहरण के लिए, 100010001000इनपुट के लिए 5)। फिर हम उस क्रम में एक घूर्णन आधार पर से शुरू 0करते हैं 0 + $n। उन पात्रों -joinको एक स्ट्रिंग में एड किया जाता है, जो पाइपलाइन पर छोड़ दिया जाता है। आउटपुट निहित है।

(एनबी - इसके लिए विशेष मामले को संभालने के लिए अतिरिक्त 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)

— जाकारी
स्रोत

2

लूआ, 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 निर्देशांक के माध्यम से आगे जाता है और एक # if x == y या यदि यह अन्य कोनों को जोड़ देगा।

यह प्रोग्राम कभी भी "if" कीवर्ड का उपयोग नहीं करता है।

— AI221
स्रोत

2

ऑक्टेव, 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

प्रतिशत चिह्न का प्रतिनिधित्व करने वाला एक विरल मैट्रिक्स उत्पन्न करता है।

— rahnema1
स्रोत

2

जाप , 12 बाइट्स

²ovUÉ hT1 òU

एक 2 डी सरणी / मैट्रिक्स लौटाता है।

इसे ऑनलाइन आज़माएं! -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।

— जस्टिन मेरिनर
स्रोत

मुझे नहीं लगता कि वास्तव में आपको इसकी आवश्यकता है hT1, जैसा 0कि तकनीकी रूप से Uहर व्यक्ति के लिए पहले से ही विभाज्य है U। इसके अलावा, महान काम :-)

— ETHproductions

@ETHproductions जो एक इनपुट से निपटने के लिए जोड़ा गया था 1। इसके बिना, यह लौटता है[[0]] क्योंकि जाहिरा तौर पर शून्य शून्य से विभाज्य नहीं है।

— जस्टिन मेरिनर

आह, यह खतरे में है। मुझे नहीं पता कि मुझे इसे ठीक करना चाहिए या नहीं ...

— ETHproductions

2

PHP, 53 बाइट्स

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

मैट्रिक्स के किनारे की लंबाई है $l। इस कोड में एक PHP नोटिस और यहां तक कि 0 द्वारा विभाजन के लिए PHP चेतावनी है $l=0, लेकिन काम करता है!

— jstnthms
स्रोत

ऐसा लगता है कि आप इनपुट को पूर्वनिर्धारित चर (->) में संग्रहीत करने की अपेक्षा करते हैं$l ) । दुर्भाग्य से यह इनपुट लेने के हमारे स्वीकृत तरीकों में से एक नहीं है । लिंक किए गए मेटा पोस्ट में आपको विकल्प मिलेंगे, जैसे कमांड लाइन के तर्कों का उपयोग करना जैसा कि रिकडी के जवाब में देखा गया है ।

— नीमी

पूरा और गोल्फ: 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 बाइट्स प्रत्येक)

— टाइटस

की जरूरत है <?शुरुआत में।

— मनश्शेख्ज़त-रिनेटेट मोनिका

2

पायथन 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

इसे ऑनलाइन आज़माएं!

— रोहित-पांडे
स्रोत

अच्छी कोशिश, लेकिन n = 1 के लिए काम नहीं करता।

— मु 無

2

रूबी, 47 बाइट्स

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

यह एरे की एक सरणी देता है।

कोड बहुत सीधा है।

यह पहले तत्व के रूप में एक n-1सरणी बनाता है 1और शेष 0s (उदा [1, 0, 0, 0]) से भरा होता है
इसे दोहराता है
यह nn तत्वों के स्लाइस

इसे ऑनलाइन आज़माएं!

— एरिक डुमिनील
स्रोत

2

जे, 14 बाइट्स

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

Ungolfed:

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

इसे ऑनलाइन आज़माएं!

— जोनाह
स्रोत

भोजन के लिए विचार: एक 10 बाइट समाधान मौजूद है :)

— कॉनर ओ'ब्रायन

@ ConorO'Brien आपको धिक्कार है। यह पहले से ही 3 बजे यहाँ है: पी

— जोनाह

यहाँ एक ही है, और यहाँ हम हैं: D

— कॉनर ओ'ब्रायन

1

@ ConorO'Brien क्या यह था 0=<:|i.@,~?

— मील

@ मीलों हाँ, यह था :)

— कॉनर ओ'ब्रायन

2

पायथन 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)]

यह एक सूची बोध है, एक int (जो फ़ंक्शन के विपरीत है ) में 0+(j==n-i-1)बदलने के j==n-i-1लिए एक छोटा तरीका है intऔर फिर m[-1]=m[0]नीचे दाईं ओर 1 बनाने से छोटा है, क्योंकि शीर्ष और नीचे की पंक्तियाँ समान हैं।

— करण इलांगोवन
स्रोत

2

फोर्थ, 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 ! ;

(ध्यान दें कि, चूंकि व्हॉट्सएप फोर्थ में प्राइमरी सीमांकक है, हर गाड़ी के रिटर्न को हटाने से कोई फर्क नहीं पड़ेगा। इंडेंटेशन बेशक, करता है।)

(टिप्पणी की गई:)

( 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

(अंतिम नोट: फोर्थ दुभाषिया की बिट चौड़ाई से एक कम से कम काम करता है। मैंने ऊपर के भाग को gfor, AMD64 पर चलाया। एक प्राचीन 16-बिट फोर्थ केवल 15 बिट्स चौड़ा होगा, और थोड़ा संशोधन की आवश्यकता होगी।

— जोएल रीस
स्रोत

यदि आप चाहते हैं कि आपके उत्तर में टिप्पणी कोड ठीक है, लेकिन आपको कहीं न कहीं गोल्फ कोड की आवश्यकता है।

— पावेल

@Phoenix धन्यवाद। किया हुआ।

— जोएल रीस

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 # उत्तर से काफी अलग है, इसलिए मैंने इसे सुधार के बजाय अलग से पोस्ट करने का फैसला किया। वास्तव में टॉप रेटेड जेली जवाब से प्रेरित होकर, मैं पहले कुछ कम कॉम्पैक्ट कर रहा था। आउटपुट एक रैखिक सरणी है, इसलिए इसे विधि के बाहर 2 डी में लपेटने के लिए कुछ तर्क की आवश्यकता होगी जैसा कि है। एक वैकल्पिक संस्करण को एक सच्चे 2D सरणी के रूप में आउटपुट के लिए 6 अतिरिक्त बाइट्स की आवश्यकता होती है:

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लिए आवश्यक नहीं है, कुछ भी उपयोगी होने के लिए आवश्यक है उत्पादन। जैसा मैंने कहा, यह मान्य होने के बहुत करीब है, लेकिन काफी नहीं।

— कामिल दकरी
स्रोत

दूसरे ?1:0काम के रूप में एक टर्नरी का उपयोग करने के लिए और मेरा मानना है कि परिणाम की एक सरणी ठीक होनी चाहिए। उस कोड का उपयोग करना भी आवश्यक नहीं है।

— TheLethalCoder

पहले के लिए, w*wएक चर पर सेट करना और intघोषणा को लूप से बाहर ले जाना आपको कुछ भी बचा सकता है?

— TheLethalCoder

@LethalCoder के दो उदाहरणों को w*wएक एकल वर्ण चर के साथ प्रतिस्थापित करने से 4 बाइट्स की बचत होती है, int i=0लूप के बाहर जाने के लिए अर्धविराम की आवश्यकता होती है जिसकी लागत 1 बाइट होती है, और फिर ,s=w*wघोषणा में 6 बाइट्स की लागत होती है, इसलिए यह वास्तव में +3 बाइट्स को समाप्त करता है।

— कामिल दकरी

आपको पूर्ण 2D-प्रतिनिधित्व समाधान की बाइट गणना का उपयोग करना चाहिए। छोटे समाधान द्वारा लौटाए गए सरणी को कम से कम किसी प्रकार के सीमांकक को मान्य करने के लिए शामिल करने की आवश्यकता होगी।

— जकॉब

प्रतिशत चिह्न बनाएं

परीक्षण के मामलों

अंतिम नोट

जेली , 6 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट (ईएस 6), 52 बाइट्स

वी , 15 बाइट्स

व्याख्या

पायथन 2 , 58 57 बाइट्स

जीएनयू एपीएल, 17 15 बाइट्स

पायथन 2 , 46 बाइट्स

पायथन 2 , 48 बाइट्स

पायथन 3 , 48 बाइट्स

जेली , 9 बाइट्स

यह काम किस प्रकार करता है

एपीएल (डायलॉग) , 18 बाइट्स

हास्केल , 55 बाइट्स

व्याख्या

आर , ५४ 42 बाइट्स

MATL , 7 बाइट्स

व्याख्या

डायलॉग एपीएल, 12 11 10 बाइट्स

कैसे?

C # (.NET Core) , 121 91 88 बाइट्स

05AB1E , 14 11 7 बाइट्स

चारकोल , 14 12 7 बाइट्स

सी ++, 144 बाइट्स

गणितज्ञ, 72 बाइट्स

पायथन 2 , 86 62 बाइट्स

पॉवरशेल , 67 बाइट्स

Dyalog APL v16, 23 बाइट्स

लूआ, 117 बाइट्स

ऑक्टेव, 37 बाइट्स

जाप , 12 बाइट्स

व्याख्या

PHP, 53 बाइट्स

पायथन 2 , 93 बाइट्स

रूबी, 47 बाइट्स

जे, 14 बाइट्स

पायथन 3, 97 बाइट्स

व्याख्या

फोर्थ, 273 (बिना टिप्पणियों के) 170 (गोल्फ-ईश)

(273 संस्करण टिप्पणी संस्करण स्पष्ट करने के लिए:)

(टिप्पणी की गई:)

(निष्पादन उदाहरण:)

C # (.NET Core) , 65 बाइट्स