आपको एक दो-आयामी सरणी और एक नंबर दिया जाएगा और आपको यह पता लगाने के लिए कहा जाएगा कि दिया गया मैट्रिक्स Toeplitz है या नहीं।

इनपुट प्रारूप:

आपको एक फ़ंक्शन दिया जाएगा जो two-dimensionalमैट्रिक्स को तर्क के रूप में ले जाएगा ।

आउटपुट स्वरूप:

1फ़ंक्शन से लौटें यदि मैट्रिक्स टोलपिट्ज़ है , तो वापस लौटें -1।

प्रतिबंध:

3 < n,m < 10,000,000

स्तंभों की संख्या होगी जहां nपंक्तियों mकी संख्या है।

नमूना परीक्षण मामला:

Sample Input :
4 
5
6 7 8 9 2
4 6 7 8 9
1 4 6 7 8
0 1 4 6 7 

Sample Output : 
1

स्कोरिंग

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

— मार्टिन एंडर
स्रोत

8

यह एक अच्छी चुनौती है, लेकिन हम यहां laxer I / O आवश्यकताओं को प्राथमिकता देते हैं। मेरा सुझाव है कि डिफ़ॉल्ट के रूप में दोनों कार्यक्रमों और कार्यों की अनुमति दें । और ट्रू / फाल्स या 1/0 को आउटपुट के रूप में अनुमति देने के लिए, या शायद किसी भी दो लगातार अलग-अलग आउटपुट के रूप में निर्णय समस्याओं के लिए पसंद किया जाता है।

— xnor

15

इसके अलावा, टोप्लेट्ज़ की एक परिभाषा अच्छी होगी, क्योंकि गैर-टोलपिट्ज़ वाले सहित अधिक परीक्षण मामले होंगे। कोड जोड़ने के बारे में आपका क्या मतलब है यह निश्चित नहीं है।

— xnor

5

मुझे लगता है कि आपको n, m का अधिकतम मूल्य कम करना होगा । अन्यथा इस चुनौती का मुख्य भाग 1 टेराबाइट मैट्रिक्स को संसाधित करने का तरीका खोजना है।

— स्टीवी ग्रिफिन

1

क्या मैट्रिक्स तत्व हमेशा गैर-नकारात्मक पूर्णांक होंगे?

— मार्टिन एंडर

7

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

2Boole[#==ToeplitzMatrix[#&@@@#,#&@@#]]-1&

मैथेमेटिका में एक अंतर्निहित करने के लिए यह जांचने के लिए नहीं है कि कोई टोलप्लाय्ट मैट्रिक्स है, लेकिन इसमें एक निर्मित करने के लिए एक अंतर्निहित है। इसलिए हम इनपुट के पहले कॉलम ( #&@@@#) और पहली पंक्ति ( #&@@#) से एक उत्पन्न करते हैं और जांचते हैं कि क्या यह इनपुट के बराबर है। परिवर्तित करने के लिए True/ Falseकरने के लिए परिणाम 1/ -1उपयोग हम Boole(देने के लिए 1या 0) और फिर बस के साथ परिणाम को बदलने 2x-1।

— मार्टिन एंडर
स्रोत

6

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

मुझे लगता है कि मुझे 1,000,000x1,000,000 मैट्रिस को संभालने की जरूरत नहीं है क्योंकि यह चुनौती में कहती है। यह मैट्रिसेस के लिए काम करता है जो उपलब्ध मेमोरी (मेरे मामले में 1 टीबी से कम) से अधिक नहीं है।

@(x)x==toeplitz(x(:,1),x(1,:))

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

यह एक मैट्रिक्स xको इनपुट के रूप में लेता है और पहले कॉलम, और पहली पंक्ति के मूल्यों के आधार पर एक टोप्लेट्ज़ मैट्रिक्स बनाता है। यह तब समानता के लिए मेट्रिसेस के प्रत्येक तत्व की जांच करेगा। यदि सभी तत्व समान हैं तो इनपुट एक टोप्लेट्ज़ मैट्रिक्स है।

आउटपुट इनपुट के समान आयामों का एक मैट्रिक्स होगा। अगर आउटपुट में कोई शून्य है तो उसे मिथ्या माना जाएगा।

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

बस सख्त आउटपुट स्वरूप पर ध्यान दिया:

यह 41 बाइट्स के लिए काम करता है। इस संस्करण से एक बाइट या दो को गोल्फ करना संभव हो सकता है, लेकिन मुझे उम्मीद है कि आउटपुट नियमों को थोड़ा आराम दिया जाएगा।

@(x)2*(0||(x==toeplitz(x(:,1),x(1,:))))-1

— स्टीवी ग्रिफिन
स्रोत

5

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

ŒDE€Ạ

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

परिभाषा के बाद यहाँ ।

ŒDE€Ạ
ŒD     all diagonals
   €   for each diagonal ...
  E       all elements are equal
    Ạ  all diagonal return true

— लीक नन
स्रोत

5

05AB1E , 11 बाइट्स

Œ2ùvy`¦s¨QP

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

व्याख्या

Œ             # get all sublists of input
 2ù           # keep only those of length 2
   v          # for each such pair
    y`        # split to separate lists
      ¦       # remove the first element of the second list
       s¨     # remove the last element of the first list
         Q    # compare for equality
          P   # product of stack

— Emigna
स्रोत

4

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

f(a:b:t)|init a==tail b=f$b:t|1>0= -1
f _=1

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

— XNOR
स्रोत

डांग, यह फिर से overcomplicating। उत्सुकता से, मुझे लगता है कि सत्य / असत्य आउटपुट के साथ 39 बाइट्स तक नीचे आते हैं, इसलिए यदि टोप्लेट्ज़ = Falseको अनुमति दी गई थी तो मैं इसे एक बाइट से हरा सकता था।

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

3

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

l=Length;If[l@Flatten[Union/@Table[#~Diagonal~k,{k,-l@#+1,l@#[[1]]-1}]]==l@#+l@#[[1]]-1,1,-1]&

इनपुट

{{6, 7, 8, 9, 2}, {4, 6, 7, 8, 9}, {1, 4, 6, 7}, 8}, {0, 1, 4, 6, 7}।

एक और स्टीवी ग्रिफिन एल्गोरिथ्म पर आधारित है

मैथेमेटिका, 44 बाइट्स

If[#==#[[;;,1]]~ToeplitzMatrix~#[[1]],1,-1]&

— J42161217
स्रोत

2

क्या आपको परिभाषित करने की आवश्यकता है s? क्या आप #इसके बजाय सिर्फ उपयोग नहीं कर सकते ?

— एक पेड़ नहीं

हाँ! तुम सही हो!

— J42161217

3

जावा 7, 239 233 220 113 बाइट्स

int c(int[][]a){for(int i=a.length,j;i-->1;)for(j=a[0].length;j-->1;)if(a[i][j]!=a[i-1][j-1])return -1;return 1;}

@Nil के लिए एक अधिक कुशल एल्गोरिथ्म का उपयोग करने की एक टिप के बाद -107 बाइट्स ।

स्पष्टीकरण:

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

int c(int[][]a){                // Method with integer-matrix parameter and integer return-type
  for(int i=a.length,j;i-->1;)  //  Loop over the rows (excluding the first)
    for(j=a[0].length;j-->1;)   //   Loop over the columns (excluding the first)
      if(a[i][j]!=a[i-1][j-1])  //    If the current cell doesn't equal the one top-left of it:
        return -1;              //     Return -1
                                //   End of columns loop (implicit / single-line body)
                                //  End of rows loop (implicit / single-line body)
  return 1;                     //  Return 1
}                               // End of method

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

पहले कार्य में r & c क्या है?

— मिकी जैक

@MickeyJack पंक्तियाँ और स्तंभ ( r= nऔर c= mयदि आप इसे चुनौती से तुलना करते हैं)।

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

क्या आपको फ़ंक्शन के पैरामीटर के रूप में सरणी पास नहीं करनी चाहिए? इसके अलावा, इसके लिए बहुत अधिक कुशल एल्गोरिदम है, जो आपकी बाइट की गिनती को लगभग 50% तक काट देगा।

— नील

1

@ केविनक्रूजसेन बस यह जांचें कि पहली पंक्ति या कॉलम में सभी तत्व तिरछे हुए तत्व के बराबर नहीं हैं और इससे बचे हैं।

— नील

1

आह, तुम भी -->ऑपरेटर का उपयोग करने के लिए मिल गया !

— नील

3

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

t पूर्णांकों की सूचियों की सूची लेता है और पूर्णांक देता है।

t m=1-sum[2|or$zipWith((.init).(/=).tail)=<<tail$m]

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

यह सचाई / झूठे आउटपुट के साथ 39 या 38 बाइट्स हो सकता था।

उपयोग करने का विचार initएमिग्ना के 05AB1E उत्तर से प्रेरित था, जो एक समान विधि का उपयोग करता है; इससे पहले मैंने एक नेस्टेड ज़िपिंग का उपयोग किया था।

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

zipWith((.init).(/=).tail)=<<tailका एक बिंदु मुक्त रूप है \m->zipWith(\x y->tail x/=init y)(tail m)m।
यह प्रत्येक पंक्तियों की पंक्तियों को जोड़ता है, यह जाँचता है mकि पहले निकाले गए पहले तत्व को दूसरे से हटाए गए दूसरे तत्व से अलग है या नहीं।
orतो पंक्तियों के सभी जोड़े के लिए जाँच करता है को जोड़ती है।
1-sum[2|...] आउटपुट स्वरूप परिवर्तित करता है।

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

2

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

a=>a.some((b,i)=>i--&&b.some((c,j)=>c-a[i][j-1]))?-1:1

— नील
स्रोत

या अपनी स्वयं की चाल का उपयोग करना : a=>a.some(b=>b.some((v,i)=>d[i]-(d[i]=v),d=[,...d]),d=[])?-1:1(62 बाइट्स)

— अरनौल्ड

1

@Arnauld धन्यवाद, लेकिन यह पता चला है कि मैं समस्या पर फिर से सोच रहा था ...

— नील

2

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

->a,b,m{m.reduce{|x,y|x[0..-2]==y[1,b]?y:[]}.size<=>1}

यदि निर्दिष्ट रूप से लचीला इनपुट / आउटपुट स्वीकार किया जाता है, तो निश्चित रूप से अधिक गोल्फ हो सकता है।

स्पष्टीकरण:

मैट्रिक्स पर Iterate करें, और ऊपर की रेखा के साथ प्रत्येक पंक्ति की तुलना करें, एक से दाईं ओर स्थानांतरित। यदि वे अलग-अलग हैं, तो अगले पुनरावृत्ति के लिए एक खाली सरणी का उपयोग करें। अंत में, रिटर्न -1, अगर अंतिम सरणी खाली है, या 1 यदि यह कम से कम 2 तत्व है (चूंकि सबसे छोटा संभव मैट्रिक्स 3x3 है, यह सच है अगर सभी तुलनाएं सही हैं)

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

— जीबी
स्रोत

<=>परिणाम की गणना करने के लिए अच्छा उपयोग !

— नील

कैसे के बारे में |(*x,_),y|तो आप टुकड़ा करने की जरूरत नहीं है x?

— स्टीफन पोचमैन

1

PHP, 70 बाइट्स

<?=!preg_match('/\[([\d,]+?),\d+\],\[\d+,(?!\1)/',json_encode($_GET));

— user63956
स्रोत

1

अजगर, १०th

r=range
f=lambda x,n,m:all([len(set([x[i][j] for i in r(n) for j in r(m) if j-i==k]))==1 for k in r(1-n,m)])

n+mविकर्णों के लिए फ़िल्टर करते समय हर तत्व समय को छूने के बाद से यह बिल्कुल भी कुशल नहीं है । फिर जांचता है कि क्या प्रति विकर्ण एक से अधिक अद्वितीय तत्व हैं।

— DenDenDo
स्रोत

1

Axiom, 121 बाइट्स

f(m)==(r:=nrows(m);c:=ncols(m);for i in 1..r-1 repeat for j in 1..c-1 repeat if m(i,j)~=m(i+1,j+1)then return false;true)

मी को कुछ तत्व का एक मैट्रिक्स होना चाहिए जो अनुमति देता है ~ =; यह ungolf

f m ==
  r := nrows(m)
  c := ncols(m)
  for i in 1..(r - 1) repeat
    for j in 1..(c - 1) repeat
      if m(i,j)~=m(i + 1,j + 1)     then return(false)
  true

— RosLuP
स्रोत

1

रेटिना , 148 बाइट्स

m(1`\d+
$*#
1`#\n\d+\n
@
+`(#*)#@([^#\n]*(#*)\n)(.*)$
$1# $2$1@$4 #$3
@

+`##
# #
+(+s`^(\d+)\b(.*)^\1\b
$1$2#
s`.*^\d.*^\d.*
-1
)%`^[^- ]+ ?

\s+
1

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

एक एन × एम इनपुट मैट्रिक्स

6 7 8 9 2 0
4 6 7 8 9 2
1 4 6 7 8 9
0 1 4 6 7 8

इस तरह से विकर्णों को संरेखित करके पहले एक N × (N + M-1) मैट्रिक्स में परिवर्तित किया जाता है:

# # # 6 7 8 9 2 0
# # 4 6 7 8 9 2 #
# 1 4 6 7 8 9 # #
0 1 4 6 7 8 # # #

और फिर पहले कॉलम को बार-बार सिंगल यूनिक नंबर से चेक किया जाता है, और यदि ऐसा है तो हटा दिया जाता है। मैट्रिक्स Toeplitz है अगर आउटपुट रिक्त है।

— eush77
स्रोत

ओह, यह नकारात्मक संख्याओं के साथ काम नहीं करता है, इसे ठीक कर लें :)

— eush77

1

MATL , 11 बाइट्स

T&Xd"@Xz&=v

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

सीधी "एक टोप्लेट्ज़ मैट्रिक्स का निर्माण करें और इसके खिलाफ जांच करें" विधि, जो कि शीर्ष कुछ उत्तर का उपयोग करते हैं, किसी तरह मुझे उबाऊ लगा (और ऐसा लगता है कि वैसे भी 1 बाइट अधिक लंबा होगा)। इसलिए मैं "प्रत्येक विकर्ण की जांच करता हूं जिसमें केवल एक अद्वितीय मूल्य होता है" विधि है।

T&Xd - इनपुट के विकर्णों को निकालें और कॉलम के रूप में उनके साथ एक नया मैट्रिक्स बनाएं (आवश्यकतानुसार शून्य के साथ पैडिंग)

" - उस के कॉलम के माध्यम से पुनरावृति

@Xz - पुनरावृत्ति चर (वर्तमान स्तंभ) को धक्का दें, और उसमें से (पैडिंग) शून्य हटा दें

&=- प्रसारण समानता की जाँच करें - यह सभी 1s (सत्य) के साथ एक मैट्रिक्स बनाता है यदि शेष सभी मान एक दूसरे के बराबर हैं, अन्यथा मैट्रिक्स में कुछ 0 s होते हैं जो मिथ्या है

v - परिणामी मान एक साथ, एक अंतिम परिणाम वेक्टर बनाने के लिए जो या तो सत्य है (सभी 1s) या गलत (कुछ 0)

— sundar - मोनिका को बहाल करना
स्रोत

0

आर , 48 बाइट्स

pryr::f(all(x[-1,-1]==x[-nrow(x),-ncol(x)])*2-1)

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

— Nitrodon
स्रोत

0

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

#(if(=(+ %2 %3 -1)(count(set(for[Z[zipmap][i r](Z(range)%)[j v](Z(range)r)][(- i j)v]))))1 -1)

— NikoNyrh
स्रोत

जांचें कि क्या मैट्रिक्स एक टोप्लेट्ज मैट्रिक्स है

इनपुट प्रारूप:

आउटपुट स्वरूप:

प्रतिबंध:

नमूना परीक्षण मामला:

स्कोरिंग

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

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

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

05AB1E , 11 बाइट्स

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

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

मैथेमेटिका, 44 बाइट्स

जावा 7, 239 233 220 113 बाइट्स

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

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

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

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

स्पष्टीकरण:

PHP, 70 बाइट्स

अजगर, १०th

Axiom, 121 बाइट्स

रेटिना , 148 बाइट्स

MATL , 11 बाइट्स

आर , 48 बाइट्स

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