Quandle Quandary एपिसोड I: परिमित क्वैंडल्स की पहचान

Question

एक प्रोग्राम लिखें जो निर्धारित करेगा कि क्या दिया गया मैट्रिक्स एक क्वैंडल का प्रतिनिधित्व करता है। एक क्वैंडल एक एकल (गैर-कम्यूटेटिव, गैर-एसोसिएटिव) ऑपरेशन से सुसज्जित एक सेट है, जो निम्नलिखित स्वयंसिद्धों का पालन करता है:

• ऑपरेशन बंद हो गया है, जिसका अर्थ है कि a◃b = cहमेशा सेट का एक तत्व अगर aऔर सेट के तत्व bहैं।
• ऑपरेशन सही-स्व-वितरण है (a◃b)◃c = (a◃c)◃(b◃c):।
• ऑपरेशन सही-विभाज्य है: किसी भी चुने हुए जोड़े के लिए aऔर b, ऐसा एक अनूठा cहैc◃a = b
• ऑपरेशन निष्कलंक है: a◃a = a

एक परिमित क्वैंडल को एक वर्ग मैट्रिक्स के रूप में दर्शाया जा सकता है। नीचे एक आदेश -5 उदाहरण ( स्रोत ) का एक उदाहरण है ।

0 0 1 1 1
1 1 0 0 0
3 4 2 4 3
4 2 4 3 2
2 3 3 2 4

N-th पंक्ति और m-th कॉलम (0-अनुक्रमित) पर स्थित मान n◃m का मान है। उदाहरण के लिए, इस quandle में, 4◃1 = 3। इस मैट्रिक्स से क्वैंडल के कुछ गुण आसानी से देखे जा सकते हैं:

• यह बंद है क्योंकि इस 5x5 मैट्रिक्स में केवल 0-4 ही दिखाई देते हैं।
• यह वैचारिक है क्योंकि मैट्रिक्स विकर्ण 0 1 2 3 4 है
• यह सही-विभाज्य है क्योंकि किसी भी कॉलम में कोई डुप्लिकेट मान नहीं है। (पंक्तियाँ कर सकते हैं, और आमतौर पर होगा)

सही-स्व-वितरण की संपत्ति का परीक्षण करना कठिन है। एक शॉर्टकट हो सकता है, लेकिन सबसे सरल तरीका यह सत्यापित करने के लिए तीन अनुक्रमितों के प्रत्येक संभावित संयोजन पर पुनरावृति करना है m[m[a][b]][c] = m[m[a][c]][m[b][c]]।

इनपुट

इनपुट 0-इंडेक्सिंग या 1-इंडेक्स (आपकी पसंद) का उपयोग करके एक वर्ग मैट्रिक्स की पंक्तियों की सूची होगी। प्रत्येक प्रविष्टि से एक भी अंकीय संख्या होगी 0करने के लिए 8(या 1के माध्यम से 9)। मैं इनपुट प्रारूप पर लचीला रहूंगा। कुछ स्वीकार्य स्वरूपों में शामिल हैं:

• जैसे मैट्रिक या सूची, के लिए अपनी भाषा के सबसे प्राकृतिक स्वरूपण [[0 0 0][2 1 1][1 2 2]]या (0,0,0,2,1,1,1,2,2)।
• व्हॉट्सएप, न्यूलाइन्स, कॉमा, आदि द्वारा सीमांकित मूल्यों की सूची।
• एक एकल स्ट्रिंग, जिसमें सभी मान एक साथ सम्‍मिलित हैं, जैसे कि 000211122।

आपको इनपुट के रूप में मैट्रिक्स का पारगमन लेने की भी अनुमति है (स्तंभों के साथ पंक्तियों को स्वैप करना)। बस अपने उत्तर में यह बताना सुनिश्चित करें।

उत्पादन

एक एकल सत्य / फाल्सी मूल्य मैट्रिक्स की स्थिति को एक प्रश्न के रूप में दर्शाता है।

Quandles के उदाहरण

0

0 0
1 1

0 0 0
2 1 1
1 2 2

0 0 1 1
1 1 0 0
3 3 2 2
2 2 3 3

0 3 4 1 2
2 1 0 4 3
3 4 2 0 1
4 2 1 3 0
1 0 3 2 4

गैर-quandles के उदाहरण

बंद नहीं

1

0 0 0
2 1 1
1 9 2

स्व-वितरण नहीं

0 0 1 0
1 1 0 1
2 3 2 2
3 2 3 3

(3◃1)◃2 = 2◃2 = 2
(3◃2)◃(1◃2) = 3◃0 = 3

सही-विभाज्य नहीं

0 2 3 4 1
0 1 2 3 4
3 4 2 2 2
3 3 3 3 3
4 1 1 1 4

0 1 2 3
3 1 2 0
3 1 2 3
0 1 2 3

उदासीन नहीं

1 1 1 1
3 3 3 3
2 2 2 2
0 0 0 0

2 1 0 4 3
3 4 2 0 1
4 2 1 3 0
1 0 3 2 4
0 3 4 1 2

Comments

शब्द "मैट्रिक्स" भ्रामक है, क्योंकि यह रैखिक बीजगणित के साथ कुछ नहीं करना है। "टेबल" बेहतर होगा (या शायद "केली टेबल", लेकिन मुझे लगता है कि कड़ाई से केवल एक समूह के लिए उपयुक्त है)।

— पीटर टेलर

Answer 1

पायथन 2 , 104 103 102 बाइट्स

t=input();e=enumerate
[0%(a==A[a]in B>C[B[a]]==t[C[b]][C[a]])for(a,A)in e(t)for(b,B)in e(t)for C in t]

इनपुट ट्रांसपोज़्ड है। आउटपुट एक्ज़िट कोड के माध्यम से है, इसलिए 0 (सफलता) सत्य है और 1 (विफलता) मिथ्या है।

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

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

e(t)इनपुट मैट्रिक्स t की गणना की गई पंक्तियों को लौटाता है - जो एक ऑपरेटर ◃ - (इंडेक्स, पंक्ति) जोड़े का प्रतिनिधित्व करता है । for(a,A)in e(t), जैसे, इन पर iterates में सूचकांक भंडारण, एक और पंक्ति में ही एक है, तो Aके लिए एक शॉर्टकट हो जाता है t[a]।

पूर्व, for(b,B)in e(t)और for C in t, के बीच , हम कार्टेशियन पावर टी ^{3 में} सभी संभव ऑर्डर किए गए ट्यूपल्स (ए, बी, सी) पर पुनरावृति करते हैं ।

इनमें से प्रत्येक tuples के लिए, हम अभिव्यक्ति का मूल्यांकन करते हैं

0%(a==A[a]in B>C[B[a]]==t[C[b]][C[a]])

कोष्ठबद्ध बूलियन का मूल्य गलत है यदि और केवल यदि निम्न में से एक या अधिक व्यक्तिगत तुलना समान है।

• a==A[a]विफल हो जाएगा (कुछ मान के लिए ) iff ent बेकार नहीं है।

• A[a]in Bविफल हो जाएगा अगर B में A के सभी सूचकांक शामिल नहीं हैं ।

  चूँकि A के पास n सूचकांक हैं और B के पास n तत्व हैं, इसलिए गैर-विफलता का अर्थ है कि B के तत्व A के सूचक से मेल खाते हैं , इसलिए right बंद है और दाएं-विभाज्य है।

• B>C[B[a]] पायथन 2 है, चूंकि पायथन 2 पुनरावृत्तियों की तुलना में "छोटा" माना जाता है।

• C[B[a]]==t[C[b]][C[a]]कुछ मान के लिए विफल हो जाएगा अगर some सही-स्व-वितरण नहीं है।

यदि कोई भी तुलना झूठी है , तो अभिव्यक्ति ZeroDivisionError(0%...) फेंक देगी । इसके अलावा, अगर ◃ बंद नहीं है A[a]या C[b]यह भी एक फेंक सकता है IndexError । दोनों स्थितियों में, प्रोग्राम स्थिति कोड 1 (विफलता) से बाहर निकलता है ।

यदि सभी परीक्षण पास हो गए, तो प्रोग्राम स्टेटस कोड 0 (सफलता) के साथ सामान्य रूप से बाहर निकल जाएगा ।

Answer 2

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

यह उत्तर ट्रांसपोज़्ड इनपुट का उपयोग करता है ।

q m=and$(elem<$>v<*>m)++[a#a==a&&a#b#c==a#c#(b#c)|a<-v,b<-v,c<-v]where v=[0..length m-1];i#j=m!!j!!i

ऐसा लगता है कि मैं एक infix ऑपरेटर को बांधने के लिए एक पैटर्न गार्ड का उपयोग नहीं कर सकता, इसलिए मैं whereइस मामले में उपयोग कर रहा हूं ।

(पहले संस्करण में 108 बाइट्स थे, लेकिन बेवजह की चूक हो गई, निश्चित संस्करण 120 बाइट्स थे, बाद के संस्करणों में 108, 103 और 98 बाइट्स थे, लेकिन मुझे @nimi को धन्यवाद देना पड़ा कि वे सभी गलत थे: बेशक मुझे सही करने की जरूरत है- विभाज्यता परीक्षण (जिसका अर्थ है बंद होने से) किसी भी खतरनाक !!ऑपरेशन को करने से पहले , लेकिन मैं अभी भी अपने बाद के गोल्फिंग विचारों का सबसे अधिक उपयोग कर सकता हूं और एक और के साथ, यह 102 बाइट्स था, अब के ऑपरेंड ऑर्डर को बदलकर सुधार किया गया है #(जो कि वैसे भी क्षतिपूर्ति करने के लिए अच्छा है) पारगमन) बाईं ओर अपने सहयोगी का बेहतर उपयोग करने के लिए)

इस तरह का उपयोग करें:

*Main> q [[0,1,2,3],[0,1,3,2],[1,0,2,3],[0,1,2,3]]
False

Answer 3

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

def f(m):R=range(len(m));return all(m[i][i]==i<set(zip(*m)[i])==set(R)>m[m[j][k]][i]==m[m[j][i]][m[k][i]]for i in R for j in R for k in R)

m पूर्णांकों की सूची की एक सूची है।

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

Answer 4

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

a=>!(a.some((b,i)=>b[i]-i)|a.some(b=>[...new Set(b)].sort()+''!=[...b.keys()])||a.some((_,i)=>a.some((_,j)=>a.some((b,k)=>b[a[j][i]]-a[b[j]][b[i]]))))

पूर्णांक के स्तंभ सरणियों के एक सरणी के रूप में इनपुट लेता है।

Answer 5

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

(n_±m_:=#[[m,n]];#&@@Union[Sort/@#]==Range@l==Array[#±#&,l=Length@#]&&And@@Flatten@Array[±##2±#==(#2±#)±(#3±#)&,{l,l,l}])&

शुद्ध फ़ंक्शन, इनपुट के रूप में पूर्णांक (1-अनुक्रमित) का 2 डी सरणी ले रहा है, प्रश्न में सम्मेलन से उलट पंक्तियों और स्तंभों के साथ, और वापस Trueया False। पहली पंक्ति बाइनरी n_±m_इन्फिक्स ऑपरेशन को क्वैंडल ऑपरेशन को परिभाषित करती है ।

एक lएक्स lऐरे के लिए, बंद और राइट-डिविज़न हर पंक्ति के बराबर है (मेरे मामले में) कुछ क्रमपरिवर्तन किया जा रहा है {1, ..., l}, और idempotent मुख्य विकर्ण के बराबर है {1, ..., l}। तो #&@@Union[Sort/@#]==Range@l==Array[#±#&,l=Length@#]इन तीन स्थितियों के लिए पता लगाता है। ( Sort/@#यहाँ का उपयोग यही कारण है कि मैंने पंक्तियों और स्तंभों को स्वैप करना चुना।)

सही वितरण के लिए, हम वस्तुतः सभी संभावनाओं की जाँच करते हैं Array[±##2±#==(#2±#)±(#3±#)&,{l,l,l}])। (ध्यान दें कि ±##2±#स्वचालित रूप से फैलता है (#2±#3)±#, क्योंकि ##2तीन-चर शुद्ध फ़ंक्शन के दूसरे और तीसरे तर्कों के अनुक्रम का प्रतिनिधित्व किया जाता है।) फिर &&And@@Flatten@जाँचता है कि क्या प्रत्येक एकल परीक्षण पारित किया गया था। कुछ गैर-बंद quandles के लिए, त्रुटियों को फेंका जा सकता है जब यह एक मैट्रिक्स के एक हिस्से तक पहुंचने की कोशिश करता है जो मौजूद नहीं है, लेकिन सही उत्तर अभी भी वापस आ गया है।

Comments

±m__:=#[[m]];मुझे लगता है। और एक Diagonalअंतर्निहित है। और ±बायां-सहयोगी है इसलिए आप उपयोग कर सकते हैं #2±#±(#3±#), लेकिन अगर मैंने कोई गलती नहीं की है, तो इसे #करने #3और करने के लिए आश्वस्त होना कम है #±#2±#3==#±#3±±##2&। और यह भी संभव है कि पूरे Flatten@हिस्से को बदल दिया जाए(...&~Array~{l,l,l}<>"")

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

मुझे आश्चर्य है कि आप ले जाना है, तो l=Lengthमें Range@l, क्योंकि है कि एक पहले मूल्यांकन किया जाना चाहिए, इसलिए यदि आप समारोह को बार-बार उपयोग करते हैं, मुझे लगता है कि Rangeअभी भी हो जाता है पिछले l, नहीं?

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

Answer 6

सी ++ 14, 175 बाइट्स

अनाम लैम्ब्डा के रूप में, माना nजा रहा है std::vector<std::vector<int>>और संदर्भ पैरामीटर के माध्यम से वापस आ रहा है। ० असत्य है, बाकी सब सत्य है।

#define F(x);for(x=-1;++x<s;){
[](auto m,int&r){int s=r=m.size(),a,b,c F(a)auto A=m[a];r*=s==A.size()&&A[a]==a;int u=0 F(b)u|=1<<m[b][a];r*=A[b]<s F(c)r*=m[A[b]][c]==m[A[c]][m[b][c]];}}r*=!(u-(1<<s)+1);}}

अधूरा और उपयोग:

#include<vector>
#include<iostream>

auto f=
#define F(x);for(x=-1;++x<s;){
[](auto m,int&r){
 int s=r=m.size(),a,b,c
 F(a)
  auto A=m[a];               //shortcut for this row
  r*=s==A.size()&&A[a]==a;   //square and idempotet
  int u=0                    //bitset for uniqueness in col
  F(b)
   u|=1<<m[b][a];            //count this item
   r*=A[b]<s                 //closed
   F(c)
    r*=m[A[b]][c]==m[A[c]][m[b][c]];
   }
  }
  r*=!(u-(1<<s)+1);          //check right-divisibility
 }
}
;

int main(){
 int r;
 std::vector<std::vector<int>>
  A = {
   {0, 0, 1, 1},
   {1, 1, 0, 0},
   {3, 3, 2, 2},
   {2, 2, 3, 3},
  },
  B = {
   {0, 2, 3, 4, 1},
   {0, 1, 2, 3, 4},
   {3, 4, 2, 2, 2},
   {3, 3, 3, 3, 3},
   {4, 1, 1, 1, 4},
  };
 f(A,r);
 std::cout << r << "\n";
 f(B,r);
 std::cout << r << "\n";
}

Comments

सुझाएँ int a,b,c,u,s=r=m.size()Fबजाय int s=r=m.size(),a,b,c F, u=0;r*=s==A.size()&&a==A[a]Fबजाय r*=s==A.size()&&A[a]==a;int u=0 F, r*=s>A[b]Fके बजाय r*=A[b]<s Fऔर ~u+(1<<s)के बजायu-(1<<s)+1

— ceilingcat