30

एक सकारात्मक पूर्णांक n, आउटपुट N-डिमेंटल आइडेंटिटी "मैट्रिक्स" को देखते हुए , जो कि वह N^Nसरणी है 1जहां सूचकांकों के सभी घटक समान और 0अन्यथा हैं। N^Nइसका मतलब है N-by-N-by-N-by -...

1 -> [1]

2 -> [[1,0],[0,1]]

3 -> [[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,1,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,1]]]

4 -> [[[[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,1,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]],[[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]]]]

उदाहरण के लिए, यदि aहै 4आयामी पहचान "मैट्रिक्स", तो साथ ही प्रविष्टियों 1होगा a[0][0][0][0], a[1][1][1][1], a[2][2][2][2], और a[3][3][3][3]।

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

— लीक नन
स्रोत

1

संबंधित , संबंधित ।

— लीक नयन

11

यहाँ आता है MATL जवाब के साथ एक तुम्हारे लिए यह कर ...

— caird coinheringaahing

16

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

@(n)accumarray((x=1:n)'+!x,1)

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

— rahnema1
स्रोत

9

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

×=¥þ’¡`Ṡ

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

ऊह, ऐसा लग रहा है जैसे मैं अपनी भाषा में फिर से @Dennis के साथ हो रहा हूँ :-)

यह एक 1-तर्क फ़ंक्शन है (क्योंकि नेस्टेड सूचियों के लिए जेली का डिफ़ॉल्ट आउटपुट प्रारूप थोड़ा अस्पष्ट है, जिसका अर्थ है कि यह यकीनन एक पूर्ण कार्यक्रम के रूप में कल्पना को पूरा नहीं करता है)।

व्याख्या

×=¥þ’¡`Ṡ
     ¡    Repeatedly apply the following operation,
    ’     {input-1} times in total:
   þ        For each element of the current value {perhaps made into a range}
      `     and of {the range from 1 to the} {input}:
 =            Compare corresponding elements, giving 0 for equal or 1 for unequal
× ¥           then multiply by one of the elements
       Ṡ  then replace each element with its sign

इसे समझने के लिए, यह मध्यवर्ती चरणों को देखने में मदद करता है। 3 के इनपुट के लिए, हमें निम्नलिखित मध्यवर्ती चरण मिलते हैं:

[1,2,3](इनपुट, एक सीमा में बना है þ)
[[1,0,0],[0,2,0],[0,0,3]](के साथ एक तालिका बनाएं [1,2,3], पाने के लिए समानता की तुलना करें [[1,0,0],[0,1,0],[0,0,1]], फिर हमारे द्वारा तुलना किए गए मूल्यों में से एक को गुणा करें)
[[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,2,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,3]]] (फिर से वही विचार)
[[[1,0,0],[0,0,0],[0,0,0]],[[0,0,0],[0,1,0],[0,0,0]],[[0,0,0],[0,0,0],[0,0,1]]](प्रत्येक तत्व को इसके संकेत के साथ बदलें Ṡ)

इस तथ्य पर ध्यान दें कि इनपुट 1-आयामी शुरू होता है इसका मतलब है कि इनपुट-डायमेंशनल सूची का निर्माण करने के लिए (इनपुट -1) आयामों को जोड़ने के लिए हमें (इनपुट -1) बार लूप करना होगा।

मज़ेदार तथ्य: इस कार्यक्रम लगातार पांच तेज गेंदबाजों में शामिल है, ¥þ’¡`। (एक क्विक "लिंक" का एक संशोधक है, या बिलिन, इसका व्यवहार संशोधित करने या इसे किसी अन्य लिंक के साथ संयोजित करने के लिए उपयोग किया जाता है।)

+!, सिर्फ इसलिए कि आपने जेली में डेनिस को हराया।

— ज़ाचरी

7

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

Array[Boole@*Equal,#~Table~#]&

— ngenisis
स्रोत

1

@FryAmTheEggman दूसरा तर्क के रूप में एक पूर्णांक पैरामीटर Tableहाल ही में जोड़ा गया है। गणित को अभी भी वहाँ एक एकल सूची की आवश्यकता है: tio.run/##y00sychMLv7/P83WsagosTLaKT8/…

— मार्टिन

1

@FryAmTheEggman लगता है कि आपको इसे Array[Boole@*Equal,#~Table~{#}]&मैथिक्स पर काम करने के लिए बदलने की आवश्यकता है । गणितज्ञ के पुराने संस्करण दूसरे तर्क के रूप में एक पूर्णांक का समर्थन नहीं करते हैं Table, और मुझे लगता है कि मैथिक्स बंद है।

— नवजात

1

@MartinEnder चुटकी, प्रहार, तुम मुझे एक कोक :)

— ngenisis देना है

6

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

1=≢∘∪¨⍳⍴⍨⎕

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

1= [] 1 के बराबर है

≢ रेखावृत्त

∘ का

∪ अद्वितीय तत्व

¨ प्रत्येक में

⍳ एक सरणी में सूचकांकों के आयामों के साथ

⍴⍨ आत्म आकृति बदलें ( एन की प्रतियां एन ) की

⎕ इनपुट ( एन ) [?]

— एडम
स्रोत

5

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

ðṗE€ṁ+þ’¡

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

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

कार्य को सीधे प्राप्त करना कठिन प्रतीत होता है (मुझे कोई रास्ता नहीं मिला है), लेकिन समान संख्याओं और एक ही आकार के सरणियों के संदूषण काफी आसान है।

ðश्रृंखला को डायडिक बनाता है, और पूर्णांक इनपुट n श्रृंखला के लिए बाएँ और दाएँ तर्क के रूप में कार्य करता है। इसके बजाय एक मौद्रिक श्रृंखला का उपयोग करना संभव है, लेकिन डायडिक लोगों के लिए पार्सिंग नियम यहां तीन बाइट्स बचाते हैं (दो के लिए आरोप लगाते हुए)ð )।

कार्तीय शक्ति परमाणु ṗ, छोड़ दिया और सही तर्क के साथ के बराबर n , लंबाई के सभी वैक्टर की सरणी का निर्माण n के तत्वों से मिलकर बनता है [1, ..., n] , कोषगत अनुसार क्रमबद्ध।

जब n = 3 , यह पैदावार

[[1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 2, 1], [1, 2, 2], [1, 2, 3], [1, 3, 1], [1, 3, 2], [1, 3, 3], [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 2, 1], [2, 2, 2], [2, 2, 3], [2, 3, 1], [2, 3, 2], [2, 3, 3], [3, 1, 1], [3, 1, 2], [3, 1, 3], [3, 2, 1], [3, 2, 2], [3, 2, 3], [3, 3, 1], [3, 3, 2], [3, 3, 3]]

बराबर प्रत्येक Quicklink E€समानता के लिए सभी का निर्माण किया वैक्टर के तत्वों का परीक्षण करती है।

जब n = 3 , हम प्राप्त करते हैं

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

जो समतल सरणी में 3-आयामी पहचान मैट्रिक्स के तत्व हैं।

डाइएडिक क्विकलिंक +þ’¡को बाएं तर्क और दाएं तर्क n के साथ कहा जाता है । क्विक डीक्रिमेंट ¡एटम कहता है ’, जो n-1 की पैदावार करता है , फिर ऐड टेबल क्विकलिंक +þ n-1 बार कॉल करता है।

प्रारंभ में, +þदोनों के तर्क n हैं । प्रत्येक कॉल के बाद, सही तर्क को बाईं ओर से बदल दिया जाता है, और बाएं को कॉल के रिटर्न मान से बदल दिया जाता है।

तालिका त्वरित कॉल ऐड परमाणु +अपनी बाईं तर्क के प्रत्येक तत्व और उसके सही तर्क के प्रत्येक तत्व, वापसी मान की एक तालिका / मैट्रिक्स के निर्माण के लिए। प्रारंभिक पूर्णांक तर्क n को पर्वतमाला [1, ... n] में पदोन्नत किया जाता है ।

जब n = 3 , पदोन्नति के बाद लेकिन पहले पुनरावृत्ति से पहले, दोनों तर्क हैं

[1, 2, 3]

इस सरणी में प्रत्येक पूर्णांक को इस सरणी में प्रत्येक पूर्णांक में जोड़ते हैं

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

अगले आह्वान में, हम इनमें से प्रत्येक सरणियों को पूर्णांक में [1, 2, 3] में जोड़ते हैं । जोड़ सदिश करता है (किसी पूर्णांक को किसी सरणी में जोड़ना इसे प्रत्येक तत्व में जोड़ता है), इसलिए हम प्राप्त करते हैं

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

इस सरणी में 3-आयामी पहचान मैट्रिक्स के समान आकार है, लेकिन सही तत्व नहीं हैं।

अंत में, मोल्ड परमाणु ṁपरिणाम के पूर्णांक प्रविष्टियों को दाईं ओर रखता है और उन्हें बाईं ओर के परिणाम में तत्वों के साथ बदल देता है।

— डेनिस
स्रोत

4

पायथन , 70 बाइट्स

f=lambda n,l=[]:[f(n,l+[i])for i in(len(l)<n)*range(n)]or+(l==l[:1]*n)

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

एक पुनरावर्ती समाधान। मैट्रिक्स को एक आयाम की एक सूची के रूप में सोचना एक आयाम को छोटा करता है, यह पेड़ को नीचे जाने के लिए उस सूची पर पुनरावृत्त करता है। इसमें चुने गए सूचकांकों को याद किया गया है l, और जब nसूचकांकों को चुना गया है, तो हम एक 1या इसके 0आधार पर असाइन करते हैं कि क्या वे सभी समान हैं।

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

n=input();r=0
exec'r=eval(`[r]*n`);'*n+('n-=1;r'+'[n]'*n+'=1;')*n
print r

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

पूरी तरह से शून्य के मैट्रिक्स बनाने और फिर विकर्णों को असाइन करने की विधि पर एक सुधार ।

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

n=input()
t=tuple(range(n))
print eval('['*n+'+(i0'+'==i%d'*n%t+')'+'for i%d in t]'*n%t)

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

evalएक नेस्टेड सूची और स्ट्रिंग-प्रारूप प्रतिस्थापन के साथ कुछ बकवास । मूल्यांकन की जाने वाली स्ट्रिंग इस प्रकार है:

[[[+(i0==i0==i1==i2)for i0 in t]for i1 in t]for i2 in t]

— XNOR
स्रोत

4

पायथन 2 + न्यूमपी , 80 72 70 बाइट्स

अब शीर्ष पायथन जवाब के साथ बंधे!

from numpy import*
n=input()
a=zeros((n,)*n)
a[[range(n)]*n]=1
print a

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

_{8 बाइट्स को एंड्रास डीक के लिए धन्यवाद, और 2 को आधिकारिक रूप से सहेजा गया}

— mbomb007
स्रोत

2

फैंसी अनुक्रमण का उपयोग करें: a[[range(n)]*n]=1अपने निष्पादन के बजाय।

— एंड्रास डेक

( fill_diagonal(a,1)इस उद्देश्य के लिए वास्तव में है , लेकिन यह एक बाइट लंबी है)

— एंड्रास डीक

1

सुंदर आउटपुट के लिए +1। और, मुझे वैरिएबल का उपयोग दिखाई नहीं दे रहा है i, जिससे 2 बाइट बचनी चाहिए।

— आधिकारिक

3

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

रॉड को ~~कुछ और~~ भी मदद के लिए धन्यवाद जो इसे काम कर रहा है और 6 बाइट्स से मुंडा हुआ है! -3 बाइट्स xnor के लिए धन्यवाद।

n=input()
r=eval(`eval('['*n+'0'+']*n'*n)`)
for i in range(n):exec'r'+`[i]`*n+'=1'
print r

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

— totallyhuman
स्रोत

1

def/returnसे बेहतर कभी नहीं है input/print(सबसे अच्छे परिदृश्य में यह बराबर है), आप 93 बाइट्स को कम करने ()में भी कमी कर सकते हैं('[%d]'%i)

— रॉड

1

'[%d]'%iके स्ट्रिंग प्रतिनिधि होने के लिए होता है [i]।

— xnor

2

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

f=(n,d=n-1,i)=>[...Array(n)].map((_,j)=>d?f(n,d-1,j-i?n:j):j-i?0:1)

स्पष्टीकरण: iइसका उपयोग इस बात पर नज़र रखने के लिए किया जाता है कि सेल मुख्य विकर्ण पर है या नहीं। प्रारंभ में यह अपरिभाषित है, इसलिए पहली पुनरावर्ती कॉल पर हम हमेशा पहला आयाम पास करते हैं, जबकि बाद में पुनरावर्ती कॉल पर हम केवल इसे पास करते हैं यदि वर्तमान आयाम सूचकांक सभी पिछले आयामों के बराबर है, अन्यथा हम एक सूचकांक पास करते हैं nजो सभी को इंगित करता है पुनरावर्ती कोशिकाएं शून्य होनी चाहिए।

— नील
स्रोत

2

ब्रेनफक , 61 बाइट्स

>,[->+>+<<]>[-<<+>>]>-[->+.-<<<<[->+>+<<]>[-<+>]>[->>.<<]>]+.

Ungolfed

कोण कोष्ठक के बाद की संख्या से संकेत मिलता है कि सेल सिर पर है।

>,                   read n to 1
[->+>+<<]            move 1 to 2 and 3
>2[-<<+>>]>3         move 2 to 0 
                     (tape: n 0 0 n 0)
-[                   while cell 3 {
    -                  dec 3
    >4+.-<3            print \x1
    <<<0[->+>+<<]      move 0 to 1 and 2
    >1[-<+>]>2         move 1 to 0
                       (tape: 0 0 n rows_left 0)
    [                  while cell 2 {
        -                dec 2
        >>4.<<           print \x0
    ]>3                }
]                    }
+.                   print \x1

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

इनपुट एक बाइनरी नंबर है। आउटपुट एक मैट्रिक्स है जिसे पंक्ति-प्रमुख क्रम में संग्रहीत किया जाता है।

— रे
स्रोत

पहले से ही उत्तर में कुछ अलग आउटपुट प्रारूप हैं, इसलिए मैं मान रहा हूं कि एकमात्र आवश्यकता "कुछ मानक मैट्रिक्स प्रतिनिधित्व" है। यदि इसे किसी विशेष प्रारूप में होना चाहिए, तो मैं तदनुसार कोड को संशोधित करूंगा।

— रे

मुझे लगता है कि इस विशेष मामले में पंक्ति-प्रमुख बिल्कुल कॉलम-प्रमुख की तरह दिखेगा

— ऑक्टोपस

@ ऑक्टोपस वास्तव में, प्रोग्राम यह निर्धारित करता है कि यह पंक्ति-प्रमुख या स्तंभ-प्रमुख क्रम में होना चाहिए या नहीं, यह उस भाषा पर आधारित है, जिस पर ब्रेनफॉक दुभाषिया लिखा गया है। खदान C में लिखा गया है, इसलिए यह स्वाभाविक रूप से मैट्रिक्स को पंक्ति-प्रमुख क्रम में आउटपुट करता है। हालाँकि, यदि आप फोरट्रान या MATLAB में लिखे गए दुभाषिया का उपयोग करते हैं, तो यह पता लगाएगा कि स्वचालित रूप से स्तंभ के प्रमुख क्रम पर स्विच हो जाएगा। (यदि आपने खुद ब्रेनफक में लिखे गए एक दुभाषिए का इस्तेमाल किया है, तो यह आपके टेक्स्ट एडिटर में लिखी गई भाषा के आधार पर अस्पष्टता को हल करता है।) :-)

— रे

2

आर , 64 49 बाइट्स

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

x=array(0,rep(n<-scan(),n));x[seq(1,n^n,l=n)]=1;x

स्टड से पढ़ता है और एक सरणी देता है, मैट्रिसेस के रूप में छपाई करता है। seqएक दृश्य में समान रूप से स्थान दिया गया है से उत्पन्न 1करने के लिए n^nलंबाई के साथl=n है, जो चाल सूचकांक करने के लिए काफी अच्छी तरह से करता है, जहां 1s जाना।

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

पुराना संस्करण:

n=scan();x=rep(0,n^n);x=array(x,rep(n,n));x[matrix(1:n,n,n)]=1;x

स्टड nसे पढ़ता है; मैट्रिसेस के रूप में परिणामों को प्रिंट करते हुए एक सरणी देता है। जब तक मैंने डॉक्स नहीं पढ़ा तब तक मैं कुछ समय तक इससे जूझता रहा[ , जो दर्शाता है कि एक मैट्रिक्स को एक सरणी को अनुक्रमित करने के लिए इस्तेमाल किया जा सकता है, जहां मैट्रिक्स की प्रत्येक पंक्ति सूचकांकों के सेट का प्रतिनिधित्व करती है। साफ!

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

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

array(0, rep(n,n)काम करता है, इसलिए आपको नहीं करना है rep। इसके बाद आप भी ले जा सकते हैं nके माध्यम से array(0, rep(n<-scan(),n))।

— JAD

इसके अलावा, x[seq(1,n^n,l=n)]=11 बाइट छोटी है।

— JAD

@JarkoDubbeldam धन्यवाद! अच्छा है।

— ग्यूसेप

1

जे , 16 15 बाइट्स

i.@#~=i.*]#.#&1

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

— मील की दूरी पर
स्रोत

1

पायथन 3 + सुन्न, 81 77 बाइट्स

from numpy import*
f=lambda n:all([a==range(n)for a in indices((n,)*n)],0)+0

मुझे पूरी तरह से यकीन नहीं है कि उपरोक्त सभी दिशानिर्देश फिट बैठता है: यह दिए गए गुणों के साथ एक ndarray देता है। मुझे पता है कि अनाम फ़ंक्शन आमतौर पर ठीक होते हैं, लेकिन एक इंटरैक्टिव शेल वास्तव में प्रिंट करेगा

>>> f(2)
array([[1, 0],
       [0, 1]])

यदि सरणी फ़्लॉफ़ उपरोक्त को अमान्य बनाता है, तो मुझे print()7 अतिरिक्त बाइट्स जैसी किसी चीज़ के लिए फेंकना होगा ।

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

— एंड्रास डीक
स्रोत

1

अजगर, 14 बाइट्स

ucGQtQms!t{d^U

परीक्षण सूट

स्पष्टीकरण:, ^Uजो कि निहित है ^UQQ, जहां Qइनपुट है, श्रेणी के सभी संभावित क्यू तत्व सूचियों की गणना करता है 0 ... n-1।ms!t{d1 के बराबर सभी तत्वों वाले नक्शे, और शेष 0. यह चपटा आउटपुट देता है

ucGQtQ निम्नलिखित को कार्यान्वित करता है, Q - 1 बार: इनपुट को आकार Q की सूचियों में काटता है।

— isaacg
स्रोत

1

सी # (.NET कोर) , 166 बाइट्स

n=>{var c=new int[n];int i=0,d;for(;i<n;c[i++]=n);var m=System.Array.CreateInstance(typeof(int),c);for(i=0;i<n;i++){for(d=0;d<n;c[d++]=i);m.SetValue(1,c);};return m;}

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

पहले मुझे लगा कि यह C # ... ^ __ ^ U में लंबोदर एक्सप्रेशन के साथ नहीं किया जा सकता

— चार्ली
स्रोत

1

आम लिस्प, 147 133 बाइट्स

(defun i(n)(flet((m(x)(fill(make-list n)x)))(let((a(make-array(m n):initial-element 0)))(dotimes(i n)(incf(apply #'aref a(m i))))a)))

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

सामान्य सुपर-लम्बी लिस्प। 12 बाइट्स घटाकर @ceilingcat को धन्यवाद!

स्पष्टीकरण:

(defun i (n)
  (flet ((m (x) (fill (make-list n) x)))            ; function to build a list of n values x
    (let ((a (make-array (m n) :initial-element 0))); build the array with all 0
      (dotimes (i n)                                ; for i from 0 to n-1
        (incf (apply #'aref a (m i))))              ; add 1 to a[i]..[i] 
      a)))                                          ; return the array

— रेंज़ो
स्रोत

@ceilingcat, ops, गोल्फ संस्करण में एक बेवकूफ त्रुटि थी। सही किया, धन्यवाद!

— रेनजो

0

SOGL V0.12 , 22 बाइट्स

.^κ.H/ 0* 1.H≤Οčr.H{.n

यह कोशिश करो!
स्टैक पर आउटपुट छोड़ता है , कंसोल में देखा जा सकता है। यदि आउटपुट में संख्याओं को स्ट्रिंग्स होने की अनुमति दी गई थी, तो rहटाया जा सकता है।
एसओजीएल चुनौतियों में कैसे करता है, इसका एक मजेदार परीक्षण के रूप में यह पूरी तरह से इसके लिए नहीं किया गया था: पी

input: x
.^                      push  x^x
  κ                     subtract x    (x^x)-x
   .H/                  divide by x   ((x^x) - x)/x
       0*               get that many zeroes
          1             push "1"
           .H           push x-1
             ≤          pull the first item from the stack to the top
              Ο         encase (x-1 times the zeroes, separated, started and ended with 1s)
               č        chop to a char-array
                r       convert each character to a number
                 .H{    repeat x-1 times:
                    .n    in the top array, for each group of x contents, encase that in an array

— dzaima
स्रोत

0

क्लोजर, 92 बाइट्स

#(reduce(fn[v i](assoc-in v(repeat % i)1))(nth(iterate(fn[v](vec(repeat % v)))0)%)(range %))

अच्छा है कि Assoc-इन कार्यों में भी वैक्टर के साथ, न केवल हैश नक्शे के साथ।

— NikoNyrh
स्रोत

एन-आयामी पहचान "मैट्रिक्स"

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

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

व्याख्या

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

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

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

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

पायथन , 70 बाइट्स

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

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

पायथन 2 + न्यूमपी , 80 72 70 बाइट्स

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

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

ब्रेनफक , 61 बाइट्स

Ungolfed

आर , 64 49 बाइट्स

पुराना संस्करण:

जे , 16 15 बाइट्स

पायथन 3 + सुन्न, 81 77 बाइट्स

अजगर, 14 बाइट्स

सी # (.NET कोर) , 166 बाइट्स

आम लिस्प, 147 133 बाइट्स

SOGL V0.12 , 22 बाइट्स

क्लोजर, 92 बाइट्स