43

चुनौती बहुत सरल है। एक पूर्णांक इनपुट को देखते हुए n, n x nपहचान मैट्रिक्स को आउटपुट करता है। पहचान मैट्रिक्स वह है जो 1ऊपर बाईं ओर से नीचे दाईं ओर फैली हुई है। आप एक प्रोग्राम या एक फ़ंक्शन लिखेंगे जो आपके द्वारा बनाए गए पहचान मैट्रिक्स को वापस करेगा या आउटपुट करेगा। आपका आउटपुट 2D सरणी हो सकता है, या रिक्त स्थान / टैब और newlines द्वारा अलग किए गए नंबर हो सकते हैं।

उदाहरण इनपुट और आउटपुट

1: [[1]]
2: [[1, 0], [0, 1]]
3: [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
4: [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
5: [[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]]

1
===
1

2
===
1 0
0 1

3
===
1 0 0
0 1 0
0 0 1

etc.

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

code-golf math matrix linear-algebra binary-matrix code-challenge polyglot code-golf restricted-source programming-puzzle expression-building apl code-challenge image-processing compression code-golf puzzle-solver code-golf grid code-golf number number-theory code-golf array-manipulation sorting code-golf string balanced-string code-golf puzzle-solver code-golf string decision-problem code-golf path-finding puzzle-solver graph-theory code-golf string encode networking code-golf code-golf string chemistry code-golf date code-golf decision-problem graph-theory code-golf ascii-art graph-theory code-golf string

— Seadrus
स्रोत

1

एक पूर्णांक इनपुट n को देखते हुए ... - मेरा मानना है कि आप एक प्राकृतिक संख्या का मतलब है?

— जोनाथन फ्रेच

26

MATL, 2 बाइट्स

Xy

मेरे अष्टक उत्तर का अनुवाद।

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

बिना बिल-इन के साथ एक 4 बाइट संस्करण (लुइस मेंडो के लिए धन्यवाद):

:t!=
:     take input n and a generate row array [1,2,...n]
 t    duplicate
  !   zip
   =  thread compare over the result

— एक स्पैगेटो
स्रोत

7

यह बहुत ही कठिन कोड का अनुवाद करने के लिए मुश्किल रहा होगा: D

— दोष

11

@flawr आपको कोई पता नहीं है। यह वास्तव में मेरी उत्कृष्ट कृति है।

— एक स्पेगेटो

2

यह अस्पष्ट रूप से परिचित लगता है ... ;)

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

1

अब मैं देखता हूँ कि तुम क्यों पूछ रहे थे! :

— लुइस मेंडो

5

बिना निर्माण के::t!=

— लुइस मेंडो

20

टीआई-बेसिक, 2 बाइट्स

identity(Ans

मज़ेदार तथ्य: एक सूची प्राप्त करने सबसे छोटा रास्ता {N,N}है dim(identity(N।

यहाँ बिलियन के बिना सबसे छोटा तरीका है, 8 बाइट्स में:

randM(Ans,Ans)^0

randM(-9 और 9 समावेशी के बीच सभी पूर्णांक प्रविष्टियों के साथ एक यादृच्छिक मैट्रिक्स बनाता है (जो कि अजीब लगता है क्योंकि यह है)। हम फिर इस मैट्रिक्स को 0 वें पावर पर ले जाते हैं।

— lirtosiast
स्रोत

1

" यह अजीब लगता है क्योंकि यह विशिष्ट है " TI-BASIC अजीब है। O_O

— दरवाज़े

अरे हाँ। TI-बेसिक। +1

— बीरकुडा 13

सूची {N,N}, उम, पाने के लिए सबसे छोटा तरीका नहीं है {N,N}?

— साइओस

1

@Cyoce नहीं; dim(और identity(हर एक बाइट है क्योंकि TI-BASIC टोकन है।

— lirtosiast

19

जूलिया, 9 3 बाइट्स

eye

यह केवल एक अंतर्निहित फ़ंक्शन है जो पूर्णांक को स्वीकार करता है nऔर एक nxn Array{Float64,2}(यानी 2 डी सरणी) देता है। जैसे बुलाओ eye(n)।

ध्यान दें कि इस फॉर्म की प्रस्तुतियाँ इस नीति के अनुसार स्वीकार्य हैं ।

— एलेक्स ए।
स्रोत

मैंने देखा तुमने वहॉं क्या किया है! अच्छा है!

— इस्माइल मिगुएल

यह Math.JS

— ATaco

16

एपीएल, 5 बाइट्स

∘.=⍨⍳

यह एक मोनैडिक फ़ंक्शन ट्रेन है जो दाईं ओर पूर्णांक को स्वीकार करती है और पहचान मैट्रिक्स को वापस करती है।

इसे यहाँ आज़माएँ

— एलेक्स ए।
स्रोत

14

ऑक्टेव, 10 4 बाइट्स

@eye

एक अनाम फ़ंक्शन देता है जो एक नंबर लेता है nऔर पहचान मैट्रिक्स लौटाता है।

— एक स्पैगेटो
स्रोत

@eyeकाफी है।

— 31

@flawr धन्यवाद, मुझे पता था कि ऐसा करने का एक तरीका था लेकिन मैं हमेशा भूल जाता हूं: P

— एक

eyeएक बहुत / कुछ संख्यात्मक भाषाओं में पहचान मैट्रिक्स का उत्पादन करता है।

— दोष

क्या करता @है?

— साइओस

@Cyoce @"फ़ंक्शन हैंडल ऑपरेटर" है, यह lambdaएक विशेष फ़ंक्शन के संदर्भ के रूप में भी काम करता है , इसलिए, उदाहरण के लिए, @(x)x.^2स्क्वेरिंग फ़ंक्शन है और @sqrtस्क्वायर रूट फ़ंक्शन का संदर्भ है। आप इसके बारे में और अधिक यहाँ

— Giuseppe

12

आर, 4 बाइट्स

diag

जब मैट्रिक्स दिया जाता है, तो मैट्रिक्स diagका विकर्ण लौटाता है। हालाँकि, जब एक पूर्णांक दिया जाता है n, diag(n)तो पहचान मैट्रिक्स लौटाता है।

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

— एलेक्स ए।
स्रोत

11

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

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

एक अनाम फ़ंक्शन, जैसे आउटपुट का उत्पादन करता है [(1, 0, 0), (0, 1, 0), (0, 0, 1)],

सबसे पहले, सूची बनाता है ([1]+[0]*n)*n, जो n=3की तरह दिखता है

[1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0]

जिप / इटेर ट्रिक का उपयोग करता zip(*[iter(_)]*nहै जो समूहों के समूह बनाता nहै

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

ध्यान दें कि 1हर बार बाद में एक सूचकांक आता है, जिससे पहचान मैट्रिक्स होती है। लेकिन, एक अतिरिक्त ऑल-जीरो पंक्ति है, जिसे हटा दिया जाता है [:n]।

— XNOR
स्रोत

1

लानत है कि ज़िप / iter चाल सरल है

— देखिए 20

10

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

R=€R

एक अंतर्निहित का उपयोग नहीं करता है। इसे ऑनलाइन आज़माएं!

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

R=€R    Main link. Input: n

R       Range; yield [1, ..., n].
   R    Range; yield [1, ..., n].
 =€     Compare each.
        This compares each element of the left list with the right list, so it
        yields [1 = [1, ..., n], ..., n = [1, ..., n]], where comparison is
        performed on the integers.

— डेनिस
स्रोत

25

यह कोड अस्वीकार्य रूप से लंबा है।

— 18

5

@flawr दो बार सबसे छोटी लंबाई। यह वास्तव में एक असामान्य मुठभेड़ है।

— रेनर पी।

1

@flawr हाँ, और J से छोटा नहीं है । असफल!

— Adám

2

जेली के आधुनिक संस्करणों में, =þदो बाइट्स हैं, और लंबे उत्तरों का मजाक उड़ाते हैं।

— लिन

@ लियोन अभी भी सबसे छोटा वनस के रूप में दोगुना है।

— अड्म

10

जे, 4 बाइट्स

=@i.

यह एक फ़ंक्शन है जो पूर्णांक लेता है और मैट्रिक्स लौटाता है।

— मारीनस
स्रोत

मुझे लगता है कि आप इसे 3 में कर सकते हैं:=i.

— सैम इलियट

@SamElliott जो काम नहीं करता है। उदाहरण के लिए, (=i.) 10=>0 0 0 0 0 0 0 0 0 0

— साइयो जूल

9

हास्केल, 43 37 बाइट्स

f n=[[0^abs(x-y)|y<-[1..n]]|x<-[1..n]]

बहुत सीधा है, हालांकि मुझे लगता है कि कोई भी बेहतर कर सकता है (एक भाषा के बिना जो पहले से ही इस फ़ंक्शन को बनाया गया है, जैसा कि कई लोग कर चुके हैं)।

संपादित करें: droppedrjan जोहान्सन के लिए कुछ बाइट्स धन्यवाद

— शेरिडन ग्रांट
स्रोत

7

आप के fromEnumरूप में धोखा दे सकते हैं sum[1|x==y]।

— xnor

बहुत यकीन है कि आप अंतरिक्ष में हटा सकते हैंfromEnum (y==x)

— साइओस

@xnor एक बाइट इससे छोटी है 0^abs(x-y):।

— अर्जन जोहानसन

1

@xnor ओह, आपने 0^(x-y)^2अपने आप को एक अन्य उत्तर में इस्तेमाल किया , और भी छोटा।

— अर्जन जोहान्सन

@ CommentrjanJohansen हाँ, आपकी टिप्पणी देखकर अच्छा समय था :)

— xnor

8

पायथ, 7 बाइट्स

XRm0Q1Q

इसे ऑनलाइन आज़माएँ: प्रदर्शन

शून्य का एक मैट्रिक्स बनाना और विकर्ण तत्वों को लोगों के साथ बदलना।

— Jakube
स्रोत

आप फाइनल को हटाकर एक बाइट बचा सकते हैंQ

— जिम

1

@ जिम धन्यवाद, लेकिन यह वास्तव में अनुमति नहीं दी जाएगी। चुनौती पोस्ट किए जाने के बाद यह सुविधा (अंत में अनुमानित क्यू) लागू की गई थी।

— जक्यूब

7

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

@Neil से एक साफ चाल के लिए 10 बाइट्स का धन्यवाद

x=>[...Array(x)].map((_,y,x)=>x.map((_,z)=>+(y==z)))

@ Cᴏɴᴏʀ O'B a की तुलना में एक अलग दृष्टिकोण की कोशिश कर रहा है। संभवतः सुधार किया जा सकता है।

— ETHproductions
स्रोत

इससे पहले कि मैं यह जानने के लिए नीचे स्क्रॉल करता कि मैंने इसे पीटा था, यह ठीक वैसा ही था जैसा मैंने लिखा था।

— नील

तो, आपकी चुनौती के जवाब में, मैं आपको x=>[...Array(x)].map((_,y,x)=>x.map((_,z)=>+(y==z)))10 बाइट्स की बचत के लिए स्पष्ट (हिंडाइट में) देता हूं ।

— नील

@ नील बहुत धन्यवाद! मैं उल्लेख करता हूँ कि यह उत्तर में आपकी चाल है।

— ETHproductions

x=>[...Array(x)].map((_,y,x)=>x.map(_=>+!y--))

— l4m2

7

रेटिना , २५

अतिरिक्त गोल्फिंग के लिए @randomra और @Martin को श्रेय।

\B.
 0
+`(.*) 0$
$0¶0 $1

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

ध्यान दें कि यह इनपुट एक यूनरी के रूप में लेता है। यदि यह स्वीकार्य नहीं है, तो दशमलव इनपुट इस प्रकार दिया जा सकता है:

रेटिना, ३४

.+
$0$*1
\B.
 0
+`(.*) 0$
$0¶0 $1

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

— डिजिटल आघात
स्रोत

3

... रुकें। रेटिना रीगेक्स से अधिक के लिए एक भाषा के रूप में शक्तिशाली हो रही है।

— ETHproductions

@ETHproductions हाँ, हालांकि यह बहुत सभी रेगेक्स प्रतिस्थापन का जवाब है। केवल विशेष बात $*0n 0s के साथ एक नंबर n को बदलने का उपयोग है ।

— डिजिटल ट्रामा

6

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

(#)=replicate
f n=map(\x->x#0++[1]++(n-x-1)#0)[0..n-1]

fइनपुट n के लिए पहचान मैट्रिक्स लौटाता है। सबसे दूर से।

— ThreeFx
स्रोत

आप mapकॉल के बजाय सूची समझ का उपयोग करके मुट्ठी भर बाइट्स बचा सकते हैं।

— MathematicalOrchid

6

लूआ, 77 75 65 बाइट्स

x,v=z.rep,io.read()for a=1,v do print(x(0,a-1)..'1'..x(0,v-a))end

ठीक है, मुझे यकीन नहीं है कि दो अवधि की अवधि के साथ लुआ इसके लिए सबसे अच्छी भाषा है ... लेकिन हे, इस पर एक शॉट है। मैं देखूंगा कि क्या कोई सुधार किया जाना है।

संपादित करें:

मुझे दुर्घटना के बारे में कुछ पता चला जो मुझे अजीब लगता है, लेकिन, यह काम करता है।

लुआ में, हर कोई जानता है कि आपके पास चर को कार्य सौंपने की क्षमता है। यह अधिक उपयोगी कोडगॉल्फ विशेषताओं में से एक है।

इसके बजाय इसका मतलब है:

string.sub("50", 1, 1) -- = 5
string.sub("50", 2, 2) -- = 0
string.sub("40", 1, 1) -- = 4
string.sub("40", 2, 2) -- = 0

तुम यह केर सकते हो:

s = string.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0

लेकिन रुकिए, लुआ कुछ राशि OOP की अनुमति देता है। तो आप संभावित रूप से भी कर सकते हैं:

z=""
s = z.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0

जो काम करेगा और पात्रों को काटेगा।

अब यहाँ अजीब हिस्सा आता है। आपको किसी भी बिंदु पर स्ट्रिंग निर्दिष्ट करने की आवश्यकता नहीं है। बस कर:

s = z.sub
s("50", 1, 1) -- = 5
s("50", 2, 2) -- = 0
s("40", 1, 1) -- = 4
s("40", 2, 2) -- = 0

काम करेगा।

तो आप नेत्रहीन अंतर देख सकते हैं, इस के गोल्फ के परिणामों पर एक नज़र डालें:

String.sub (88 वर्ण) का उपयोग करना

string.sub("50", 1, 1)string.sub("50", 2, 2)string.sub("40", 1, 1)string.sub("40", 2, 2)

एक चर के लिए string.sub असाइन करना (65 वर्ण)

s=string.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)

एक OOP दृष्टिकोण (64 वर्ण) का उपयोग करके string.sub असाइन करना

z=""s=z.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)

एक .. nil दृष्टिकोण का उपयोग कर string.sub असाइन करना? (60 अक्षर)

s=z.sub s("50", 1, 1)s("50", 2, 2)s("40", 1, 1)s("40", 2, 2)

अगर किसी को पता है कि यह क्यों काम करता है, तो मुझे दिलचस्पी होगी।

— Skyl3r
स्रोत

"Z.rep" लाइन खदान पर टूट रही है। मैं शर्त लगा रहा हूँ कि कहीं az = '' होना चाहिए? Z = '' z.rep का एक छोटा संस्करण बस ('') .rep होगा। आप इनपुट पढ़ने के लिए भी cmdline ... का उपयोग कर सकते हैं, और बायटेकाउंट को 57 तक नीचे कर सकते हैं: z = '0'for i = 1, ... do Print (z: rep (i-1) .. 1 ..z: प्रतिनिधि (...- i)) अंत

— thenumbernine

मैंने पाया कि कोई व्यक्ति ("") .rep से पहले सुझाव दे रहा था, लेकिन मैं काम करने में असमर्थ था। यह हमेशा त्रुटि करेगा। शायद मेरे दुभाषिया यहाँ समस्या है। मैं इस कमांड लाइन इनपुट पर कोई भी दस्तावेज खोजने के लिए संघर्ष कर रहा हूं, क्या आप जानते हैं कि यह कहां मिल सकता है?

— Skyl3r

6

पायथन 3, 48

Sp3000 के लिए 1 बाइट धन्यवाद सहेजा गया।

मुझे चुनौतियां पसंद हैं जिन्हें मैं एक पंक्ति में हल कर सकता हूं। बहुत सरल, 1 और 0 से बाहर की रेखा का निर्माण इंट की लंबाई के बराबर है। एक 2d सरणी के रूप में आउटपुट। यदि आप इसके बाद भाग को लपेटते हैं '\n'.join(), तो यह बहुत अच्छा लगेगा।

lambda x:[[0]*i+[1]+[0]*(x+~i)for i in range(x)]

— मॉर्गन थ्राप्प
स्रोत

2

x-i-1 -> x+~i

— 213 पर Sp3000

5

C, 59 या 59 56 या 56

समान लंबाई के दो संस्करण।

अनातोली से सुझाव के कारण 3 बाइट्स बचाए गए: (n+1)->~n

शून्य iसे Iterates n*n-1। एक 1 प्रिंट करता है अगर i% (n + 1) शून्य है, अन्यथा 0. फिर एक नई रेखा प्रिंट करता है अगर i%n= 0 अन्यथा एक स्थान।

i;f(n){for(i=n*n;i--;)printf(i%n?"%d ":"%d\n",!(i%~n));}

i;f(n){for(i=n*n;i--;)printf("%d%c",!(i%~n),i%n?32:10);}

— स्तर नदी सेंट
स्रोत

1

n+1बहुत सुस्त है। ~nइसके बजाय का उपयोग करें !

— अनातोलीग

धन्यवाद! मुझे यह देखना चाहिए था, क्योंकि यह मुझे तब मिला जब मैंने आज एनबीजेड की चुनौती को देखा।

— लेवल रिवर सेंट

मैं सी। से बहुत परिचित नहीं हूँ। क्या करता i;है?

— साइओस

@ कैओस i;सिर्फ वेरिएबल की घोषणा करता है i। सी में आपको हमेशा इसका उपयोग करने से पहले एक वैरिएबल घोषित करना होगा, यह दर्शाता है कि टाइप करने के लिए कंपाइलर जानता है कि कितनी मेमोरी आवंटित करनी है। जीसीसी संकलक के साथ, यदि आप एक प्रकार निर्दिष्ट नहीं करते हैं तो यह माना जाता है int।

— लेवल रिवर सेंट

1

आप दूसरे से 1 बाइट ले सकते हैं, क्योंकि टैब को अनुमति दी जाती है, आप 32 को प्रतिस्थापित कर सकते हैं, 9. के साथ

— बीजन

5

माता, 4 बाइट्स

I(3)

उत्पादन

[symmetric]
       1   2   3
    +-------------+
  1 |  1          |
  2 |  0   1      |
  3 |  0   0   1  |
    +-------------+

माता मैट्रिक्स प्रोग्रामिंग भाषा है जो स्टैटा सांख्यिकीय पैकेज के भीतर उपलब्ध है। I (n) आकार n * n का एक पहचान मैट्रिक्स बनाता है

— Guest0101
स्रोत

5

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है। यह एक अच्छा जवाब है; (ab) निर्मित बिल का उपयोग गोल्फिंग के लिए बहुत अच्छा है। मैंने देखा कि आपका उत्तर वास्तव में 1 बाइट है: Iऔर अन्य 3 बाइट्स केवल फ़ंक्शन को बुला रहे हैं। यह आपके जवाब को इस चुनौती पर सबसे कम में से एक बना देगा! :-)

— wizzwizz4

5

K6 , 1 बाइट

= ठीक यही है

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

— एडम
स्रोत

4

पायथ, 8 बाइट्स

mmsqdkQQ

इसे यहाँ आज़माएँ ।

— lirtosiast
स्रोत

1

मुझे कहना होगा, यह बहुत असामान्य है कि पाइथ का उत्तर सबसे छोटे उत्तर से चार गुना अधिक है ...

— ETHproductions

मानव संसाधन विकास मंत्री यह सबसे अच्छा मुझे लगता है कि लगता है 100% मान्य प्राप्त करने में सक्षम था, लेकिन मैं मिला qRRQQजो काम करने लगता है, सिवाय इसके कि आप प्राप्त Trueऔर Falseके बजाय 1और 0, लेकिन इस afaik फिक्सिंग के लिए तीन बाइट्स उपयोग करने की आवश्यकता sMMहै जो मदद नहीं करता है ...

— फ्राईमईएग्गमैन

@FryAmTheEggman मैं भी qRRQQ मिला। मैंने कई अन्य कार्यक्रमों की कोशिश की है, और उनमें से कोई भी छोटा नहीं था।

— २१:१६

4

NumPy के साथ पायथन 3.5 - 57 49 30 बाइट्स

import numpy
numpy.identity

NumPy.identity एक पूर्णांक, n में लेता है, और n पहचान मैट्रिक्स द्वारा लौटता है। यह उत्तर इस नीति के माध्यम से स्वीकार्य है ।

— linkian209
स्रोत

4

वास्तव में मेरा मानना import numpy\nnumpy.identityहै कि यह एक वैध जवाब है ।

— FryAmTheEggman

टिप के लिए धन्यवाद @ MorganThrapp! और @FryAmTheEggman, आपका मतलब है कि मेरा जवाब सिर्फ import numpy\nnumpy.identity()30 बाइट्स हो सकता है?

— linkian209

मैं \ Nnumpy योग्य द्वारा बहुत भ्रमित हो गया ... यह भी मान्य होगा, @FryAmTheEggman, नहीं? from numpy import identity। 26 बाइट्स।

— ओगाडे

इसके अलावा, मेरे जवाब को कुछ इसी तरह देखें

— ओगडे

@ ओगडे मुझे नहीं लगता कि यह सही है, आपके द्वारा दी गई लाइन किसी फ़ंक्शन का मूल्यांकन नहीं करती है। आपको करने की आवश्यकता होगी from numpy import identidy\nidentity(किस मामले *में विशिष्ट

— बिल्टिन के

4

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

IdentityMatrix का उपयोग किए बिना

Table[Boole[i==j],{i,1,#},{j,1,#}]&

— एक सीमन्स
स्रोत

4

जावास्क्रिप्ट, 40

f=
n=>'0'.repeat(n).replace(/./g,"$`1$'\n")

I.oninput=_=>O.innerHTML=f(+I.value)
I.oninput()

<input id=I value=5>
<pre id=O>

स्निपेट का विस्तार करें

— वाशिंगटन गाइड्स
स्रोत

4

जाप, 14 12 10 बाइट्स

Uo £Z®¥X|0

इसे ऑनलाइन टेस्ट करें! नोट: इस संस्करण में आउटपुट प्रिंट करने के लिए कुछ अतिरिक्त बाइट्स हैं।

Uo £Z®¥X|0    // Implicit: U = input integer
Uo £          // Create the range [0..U). Map each item X and the full array Z to:
    Z®        //  Take the full array Z, and map each item Z to:
      ¥X|0    //   (X == Z) converted to a number. 1 for equal, 0 for non-equal.
              // Implicit: output result of last expression

— ETHproductions
स्रोत

4

ब्रेन-फ्लैक , 206 170 162 बाइट्स

(([{}])){({}<>(())<><(({})<{({}()(<>)<>)}{}>)>)}{}(({}<><(())>)){({}()<({[()]<({}()<({}<>((((()()()()){}){}){})((()()()()){}){})<>>)>}{})>)<>((()()()()()){})<>}<>

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

— गेहूं का जादूगर
स्रोत

3

के, 7 बाइट्स

t=\:t:!

दो वैक्टर वाले समानता क्रॉस उत्पाद को लें [0, n)।

कार्रवाई में:

— JohnE
स्रोत

3

जावा, 60 बाइट्स

n->{int[][]i=new int[n][n];for(;n-->0;)i[n][n]=1;return i;};

एक 2D सरणी बनाता है और उन तत्वों को प्रतिस्थापित करता है जहां पंक्ति और स्तंभ समान हैं 1।

— टीएनटी
स्रोत

आपको जावा लैम्ब्डा उत्तरों के लिए अनुगामी अर्धविराम को बाइट-काउंट में जोड़ने की आवश्यकता नहीं है।

— केविन क्रूज़सेन

3

सीजेएम, 7 बाइट्स

{,_ff=}

यह एक कोड ब्लॉक है जो स्टैक से एक पूर्णांक बनाता है और बदले में 2 डी सरणी को धक्का देता है।

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

— डेनिस
स्रोत

3

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

IdentityMatrix

परीक्षण का मामला

IdentityMatrix[4]
(* {{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}} *)

— njpipeorgan
स्रोत

3

पर्ल, 39 33 बाइट्स

/$/,say map$`==$_|0,@%for@%=1..<>

6 बाइट्स बचाने के लिए टोन हास्पेल का धन्यवाद

-Eपेरलुन के साथ चलना:

$ echo 3 | perl -E'@%=1..<>;$a=$_,say map{$a==$_|0}@%for@%'
100
010
001

— andlrc
स्रोत

थोड़ा और गोल्फिंग: /$/,say map$`==$_|0,@%for@%=1..<>या उससे भी बेहतर //,say map$'==$_|0,@%for@%=1..<>लेकिन इस तरह कि आप इसे अब सिंगल कोट्स में नहीं डाल सकते

— टन हास्पेल

@ टोनहोस्ट वाह वाह मस्त, धन्यवाद। बाद printमें कहने के बजाय इसके उपयोग की आवश्यकता होगी , क्योंकि -Eकमांड लाइन पर केवल मुफ्त है।

— andlrc

पहचान मैट्रिक्स का निर्माण

MATL, 2 बाइट्स

टीआई-बेसिक, 2 बाइट्स

जूलिया, 9 3 बाइट्स

एपीएल, 5 बाइट्स

ऑक्टेव, 10 4 बाइट्स

आर, 4 बाइट्स

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

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

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

जे, 4 बाइट्स

पायथ, 7 बाइट्स

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

रेटिना , २५

रेटिना, ३४

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

लूआ, 77 75 65 बाइट्स

पायथन 3, 48

C, 59 या 59 56 या 56

माता, 4 बाइट्स

K6 , 1 बाइट

पायथ, 8 बाइट्स

NumPy के साथ पायथन 3.5 - 57 49 30 बाइट्स

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

जावास्क्रिप्ट, 40

जाप, 14 12 10 बाइट्स

ब्रेन-फ्लैक , 206 170 162 बाइट्स

के, 7 बाइट्स

जावा, 60 बाइट्स

सीजेएम, 7 बाइट्स

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

पर्ल, 39 33 बाइट्स