बाइनरी फ़ंक्शंस के गुण

Question

अमूर्त बीजगणित में कई महत्वपूर्ण विषयों में एक सेट पर एक बाइनरी फ़ंक्शन अभिनय होता है। ऐसे कार्यों के गुणों की संख्या को ऐसे विषयों की जांच में परिभाषित किया गया है।

आपकी चुनौती यह निर्धारित करने की होगी कि किसी दिए गए डोमेन पर दिए गए बाइनरी फ़ंक्शन में इनमें से पांच गुण हैं।

गुण

समापन

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

संबद्धता

एक बाइनरी फ़ंक्शन साहचर्य है यदि वह क्रम जिसमें फ़ंक्शन को इनपुट की एक श्रृंखला पर लागू किया जाता है, परिणाम को प्रभावित नहीं करता है। $यदि (a $ b) $ cहमेशा समान होता है, तो यह सहयोगी है a $ (b $ c)। ध्यान दें कि चूंकि मूल्य (a $ b)का उपयोग इनपुट के रूप में किया जाता है, इसलिए सहयोगी कार्य बंद होना चाहिए।

commutativity

एक बाइनरी फ़ंक्शन सराहनीय है यदि इनपुट के क्रम को स्वैप करने से परिणाम नहीं बदलता है। दूसरे शब्दों में, यदि a $ bहमेशा बराबर होता है b $ a।

पहचान

बाइनरी फ़ंक्शन में एक पहचान तत्व होता है यदि eडोमेन में कुछ तत्व मौजूद होता है जैसे कि डोमेन में a $ e = a = e $ aसभी aके लिए।

Idempotence

एक द्विआधारी कार्य दो प्रकार के इनपुट के लिए इसे लागू करने के लिए उत्पादन के रूप में उस नंबर देता है, तो बेरोजगार है। दूसरे शब्दों में, यदि डोमेन में a $ a = aसभी aके लिए।

इनपुट

आपको मैट्रिक्स के रूप में एक फ़ंक्शन दिया जाएगा, और फ़ंक्शन का डोमेन नंबर होगा 0 ... n-1, जहां nमैट्रिक्स की साइड लंबाई है।

मूल्य (a $ b)मैट्रिक्स में एन्कोडिंग है क्योंकि aवें पंक्ति के bवें तत्व के रूप में। यदि इनपुट मैट्रिक्स है Q, तो a $ b=Q[a][b]

उदाहरण के लिए, **डोमेन पर प्रतिरूपण फ़ंक्शन ( पायथन में) [0, 1, 2]निम्नानुसार एन्कोडेड है:

[[1, 0, 0]
 [1, 1, 1]
 [1, 2, 4]]

बाएँ और दाएँ डोमेन समान हैं, इसलिए मैट्रिक्स हमेशा चौकोर होगा।

आप इनपुट के रूप में किसी भी सुविधाजनक मैट्रिक्स प्रारूप का उपयोग कर सकते हैं, जैसे सूचियों की एक सूची, पंक्ति में एक सूची- या स्तंभ- प्रमुख क्रम, आपकी भाषा की मूल मैट्रिक्स ऑब्जेक्ट, आदि। हालाँकि, आप सीधे इनपुट के रूप में एक फ़ंक्शन नहीं ले सकते।

सादगी के लिए, मैट्रिक्स प्रविष्टियां सभी पूर्णांक होंगी। आप मान सकते हैं कि वे आपकी भाषा के मूल पूर्णांक प्रकार में फिट हैं।

उत्पादन

आप यह संकेत दे सकते हैं कि आपके द्वारा चुने गए किसी भी प्रारूप में उपरोक्त गुण कौन से हैं, जिसमें बूलियन्स की एक सूची शामिल है, प्रत्येक संपत्ति के लिए एक अलग चरित्र के साथ एक स्ट्रिंग, आदि, हालांकि, 24 संभावित सबसेट में से प्रत्येक के लिए एक अलग, अद्वितीय आउटपुट होना चाहिए। गुणों की। यह आउटपुट आसानी से मानव-पठनीय होना चाहिए।

उदाहरण

डोमेन n = 4 पर अधिकतम कार्य:

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

इस फ़ंक्शन में क्लोजर, एसोसिएटिविटी, कम्यूटेटिविटी, आइडेंटिटी और आइडम्पोटेंस के गुण होते हैं।

डोमेन n = 3 पर घातांक फ़ंक्शन

[[1, 0, 0]
 [1, 1, 1]
 [1, 2, 4]]

इस फ़ंक्शन में उपरोक्त गुणों में से कोई भी नहीं है।

डोमेन n = 3 पर अतिरिक्त कार्य:

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

इस फ़ंक्शन में कम्यूटिटी और पहचान के गुण हैं।

डोमेन n = 3 पर K कोम्बिनेटर:

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

इस फ़ंक्शन में क्लोजर, एसोसिएटिविटी और आइडम्पोटेंस के गुण हैं।

डोमेन n = 3 पर पूर्ण अंतर फ़ंक्शन:

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

इस फ़ंक्शन में क्लोजर, कम्यूटेटिविटी और पहचान के गुण हैं।

औसत फ़ंक्शन, यहां तक ​​कि डोमेन n = 3 पर भी गोल है:

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

इस फ़ंक्शन में क्लोजर, कम्यूटेटिविटी, पहचान और बेरोजगारी के गुण हैं।

डोमेन n = 3 पर समानता कार्य:

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

इस फ़ंक्शन में क्लोजर और कम्यूटेटिविटी के गुण हैं।

चुनौती

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

Answer 1

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

[qKUQ@VQKCIQ}]Km{@RdCBQKJ!-sQK&JqF.bsm@L@QdYN.p,sQK

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

यह 5 बूलियन मानों की सूची प्रिंट करता है। वे गुण को क्रम में दर्शाते हैं:

[Idempotence, Commutativity, Identity, Closure, Associativity]

यहां एक बेहतर आउटपुट प्रारूप है: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

Idempotence:

qKUQ@VQK
   Q       Q = input matrix
  UQ       [0, 1, ..., len(matrix)-1]
 K         assign to K
    @VQK   vectorized lookup of Q and K //gets the diagonal elements
qK         check, if this is equal to K

commutativity:

CIQ   check if transpose(Q) is equal to Q

पहचान:

}]Km{@RdCBQK
   m       K   map each d in K to:
        CBQ       the list [Q, transpose(Q)]
     @Rd          take the d-th element of each ^
    {             remove duplicates
}]K            check if [K] is in ^

बंद:

J!-sQK
   sQ    sum(Q) //all elements of Q
  -  K   remove the elements, that also appear in K
 !       ckeck, if the results in an empty list
J        store the result in J

संबद्धता:

&JqF.bsm@L@QdYN.p,sQK
               .p,sQK  all permutations of [sum(Q), K] //all 2 ;-)
    .b                 map each pair (N,Y) of ^ to:
       m      N           map each d of N to:
          @Qd                the row Q[d]
        @L   Y               map each element of Y to the corr. element in ^
      s                   unfold this 2-d list
  qF                   check if they result in identically lists
&J                     and J

Answer 2

हास्केल, 178 171 बाइट्स

import Data.List
f x=[c,c&&and[(m%n)%o==m%(n%o)|m<-b,n<-b,o<-b],x==t,all(elem b)[x,t],b==[i%i|i<-b]]where c=all(l>)(id=<<x);b=[0..l-1];a%b=x!!a!!b;l=length x;t=transpose x

पांच बूलियनों के साथ एक सूची लौटाता है, जो क्रम बंद होने, सहानुभूति, कम्यूटिटी, पहचान और बेरोजगारी के कारण होते हैं।

प्रयोग उदाहरण: f [[1, 0, 0],[0, 1, 0],[0, 0, 1]]-> [True,False,True,False,False]।

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

f x=[
  c,                         -- closure (see below)
  c&&and[(m%n)%o==m%(n%o)|   -- assoc: make sure it's closed, then check the
          m<-b,n<-b,o<-b],   --        assoc rule for all possible combinations
  x==t,                      -- comm: x must equal it's transposition
  all(elem b)[x,t],          -- identity: b must be a row and a column
  b==[i%i|i<-b]              -- idemp: element at (i,i) must equal i
  ]
  where                      -- some helper functions
  c=all(l>)(id=<<x);         -- closure: all elements of the input must be < l 
  b=[0..l-1];                -- a list with the numbers from 0 to l-1
  a%b=x!!a!!b;               -- % is an access function for index (a,b)
  l=length x;                -- l is the number of rows of the input matrix
  t=transpose x

@Xnor को संपादित करने के लिए कुछ बाइट्स बचाएं। धन्यवाद!

Comments

कैसे के बारे में c=all(l>)?

— xnor

इसके अलावा, [i%i|i<-b]==b।

— xnor

कोड-गोल्फ के लिए बहुत पठनीय - अच्छा!

— isaacg

Answer 3

CJam, 95 बाइट्स

q~:Ae_A,:Bf<:*'**B3m*{_{A==}*\W%{Az==}*=}%:*'A*A_z='C*B{aB*ee_Wf%+{A==}f*B,2*='1*}%Ae_B)%B,='I*

के एक बाद प्रिंट करता है *AC1I। *के लिए प्रतीक है बंद , Aके लिए है साहचर्य , Cके लिए है विनिमेय , 1के लिए है पहचान और Iके लिए है idempotent ।

---

इनपुट ऐरे को q~A ( :A) में पढ़ा और संग्रहीत किया जाता है ।

समापन

Ae_A,:Bf<:*'**

सभी (यदि :*) मैट्रिक्स (में तत्वों Ae_) में छोटे होते हैं f<बी = आकार (ए) (से A,:B), एक प्रिंट *( '**)।

संबद्धता

B3m*{_{A==}*\W%{Az==}*=}%:*'A*

डोमेन में सभी त्रिक उत्पन्न करें ( B3m*)। हम प्रिंट करते हैं Aयदि वे सभी एक शर्त को पूरा करते हैं ( {...}%:*'A*)।

हालत यह है कि, कुछ ट्रिपल के लिए [i j k], ए ( _{A==}*) और लेफ्ट-फोल्डिंग ए ( ^ओ ) के साथ लेफ्ट-फोल्डिंग के लिए [k j i]( ए\W% ) के साथ फ़्लिप किए गए संस्करण समान हैं ( )।{Az==}*A=

commutativity

A को इसके स्थानान्तरण के बराबर होना चाहिए A_z=:। यदि हां, तो हम प्रिंट करते हैं C( 'C=)।

पहचान

B{                         }%   For each element X in the domain (0..N-1):
  aB*                           Make N copies.
     ee                         [[0 X] [1 X] ...]
       _Wf%+                    [[0 X] [1 X] ... [X 0] [X 1] ...]
            {A==}f*             [A(0, X) A(1, X) ... A(X, 0) A(X, 1)]
                   B,2*=        This list should equal the domain list repeated twice.
                        '1*     If so, X is an identity: print a 1.

पहचान आवश्यक रूप से अद्वितीय है, इसलिए हम केवल एक प्रिंट कर सकते हैं 1।

idempotent

Ae_B)%B,='I*

जाँच करें कि क्या विकर्ण बराबर है B,। यदि ऐसा है, तो प्रिंट करें I।

Answer 4

मतलाब, 226

a=input('');n=size(a,1);v=1:n;c=all(0<=a(:)&a(:)<n);A=c;for i=v;for j=v(1:n*c);for k=v(1:n*c);A=A&a(a(i,j)+1,k)==a(i,a(j,k)+1);end;end;b(i)=all(a(i,:)==v-1 & a(:,i)'==v-1);end;disp([c,A,~norm(a-a'),any(b),all(diag(a)'==v-1)])

नोटिस करने के लिए एक महत्वपूर्ण बात यह है कि गैर-बंद का मतलब गैर-सहयोगी है। मैट्रिक्स के कुछ गुणों का उपयोग करके उनमें से कई गुणों को आसानी से जांचा जा सकता है:

• क्लोजर : दी गई रेंज में सभी सभी मैट्रिक्स प्रविष्टियाँ?
• संबद्धता : हमेशा की तरह जाँच करने के लिए सबसे कठिन
• कम्यूटेटिविटी : क्या मैट्रिक्स सममित है?
• पहचान : क्या कोई सूचकांक k ऐसा है कि k-th पंक्ति और k-th कॉलम वास्तव में सूचकांकों की सूची है?
• बेरोजगारी : क्या विकर्ण सूचकांकों की सूची के अनुरूप है?

स्टैंडर मतलब संकेतन के माध्यम से इनपुट: [a,b;c,d]या [[a,b];[c,d]]या [a b;c d]आदि

दिए गए क्रम में प्रत्येक गुण के लिए आउटपुट एक शून्य, 1 = सत्य, 0 = असत्य है।

पूर्ण कोड:

a=input('');
n=size(a,1);
v=1:n;
c=all(0<=a(:)&a(:)<n);               %check for closedness
A=c;
for i=v;
   for j=v(1:n*c); 
      for k=v(1:n*c);
          A=A&a(a(i,j)+1,k)==a(i,a(j,k)+1);   %check for associativity (only if closed)
      end;
   end;
   b(i)=all(a(i,:)==v-1 & a(:,i)'==v-1);      %check for commutativity
end
%closure, assoc, commut, identity, idempotence
disp([c,A,~norm(a-a'),any(b),all(diag(a)'==v-1)]);

Answer 5

जावास्क्रिप्ट (ईएस 6) 165

एक अनाम फ़ंक्शन एक सरणी को पांच 0/1 मानों के साथ लौटाता है, जो क्रम बंद करने, संबद्धता, कम्यूटेटिविटी, पहचान और आइडम्पोटेंस में हैं।

q=>q.map((p,i)=>(p.map((v,j)=>(w=q[j][i],v-w?h=C=0:v-j?h=0:0,q[v]?A&=!q[v].some((v,k)=>v-q[i][q[j][k]]):A=K=0),h=1,p[i]-i?P=0:0),h?I=1:0),A=P=K=C=1,I=0)&&[K,A,C,I,P]

कम गोल्फ वाला

f=q=>(
  // A associativity, P idempotence, K closure, C commuativity
  // assumed true until proved false
  A=P=K=C=1, 
  I=0, // Identity assumed false until an identity element is found
  q.map((p,i)=> (
      h=1, // assume current i is identity until proved false
      p[i]-i? P=0 :0, // not idempotent if q[i][i]!=i for any i
      p.map((v,j)=> (
          w=q[j][i], // and v is q[i][j]
          v-w // check if q[j][i] != q[i][j]
          ? h=C=0 // if so, not commutative and i is not identity element too
          : v-j // else, check again for identity
            ? h=0 // i is not identity element if v!=j or w!=j
            : 0,
          q[v] // check if q[i][j] in domain
            ? A&=!q[v].some((v,k)=>v-q[i][q[j][k]]) // loop for associativity check
            : A=K=0 // q[i][j] out of domain, not close and not associative
        )
      ),
      h ? I=1 : 0 // if i is the identity element the identity = true
    )
  ),
  [K,A,C,I,P] // return all as an array
)

परीक्षा

f=q=>
  q.map((p,i)=>(
    p.map((v,j)=>(
      w=q[j][i],
      v-w?h=C=0:v-j?h=0:0,
      q[v]?A&=!q[v].some((v,k)=>v-q[i][q[j][k]]):A=K=0
    ),h=1,p[i]-i?P=0:0),
    h?I=1:0
  ),A=P=K=C=1,I=0)
  &&[K,A,C,I,P]

// test

console.log=x=>O.textContent+=x+'\n';

T=[
 [
  [[0, 1, 2, 3],
   [1, 1, 2, 3],
   [2, 2, 2, 3],
   [3, 3, 3, 3]]
 ,[1,1,1,1,1]] // has the properties of closure, associativity, commutativity, identity and idempotence.
,[ // exponentiation function on domain n=3:
  [[1, 0, 0],
   [1, 1, 1],
   [1, 2, 4]]
 ,[0,0,0,0,0]] // has none of the above properties.
,[ // addition function on domain n=3:
  [[0, 1, 2],
   [1, 2, 3],
   [2, 3, 4]] 
 ,[0,0,1,1,0]] // has the properties of commutativity and identity.
,[ // K combinator on domain n=3:
  [[0, 0, 0],
   [1, 1, 1],
   [2, 2, 2]]
 ,[1,1,0,0,1]] // has the properties of closure, associativity and idempotence.
,[ // absolute difference function on domain n=3:
  [[0, 1, 2],
   [1, 0, 1],
   [2, 1, 0]]
 ,[1,0,1,1,0]] // has the properties of closure, commutativity and identity.
,[ // average function, rounding towards even, on domain n=3:
  [[0, 0, 1],
   [0, 1, 2],
   [1, 2, 2]]
 ,[1,0,1,1,1]] // has the properties of closure, commutativity, identity and idempotence.
,[ // equality function on domain n=3:
  [[1, 0, 0],
   [0, 1, 0],
   [0, 0, 1]]
 ,[1,0,1,0,0]] // has the properties of closure, commutativity,
]  

T.forEach(t=>{
  F=t[0],X=t[1]+'',R=f(F)+'',console.log(F.join`\n`+'\n'+R+' (expected '+X+') '+(X==R?'OK\n':'Fail\n'))
  })

<pre id=O></pre>