Nhiều chủ đề quan trọng trong đại số trừu tượng liên quan đến một hàm nhị phân hoạt động trên một tập hợp. Một số tính chất của các chức năng như vậy đã được xác định trong quá trình điều tra các chủ đề đó.

Thách thức của bạn sẽ là xác định xem một hàm nhị phân nhất định trên một miền nhất định có sở hữu năm thuộc tính này hay không.

Tính chất

Khép kín

Một hàm nhị phân được đóng nếu mọi đầu ra có thể có trong miền.

Kết hợp

Hàm nhị phân là kết hợp nếu thứ tự mà hàm được áp dụng cho một loạt các đầu vào không ảnh hưởng đến kết quả. Đó là, $là kết hợp nếu (a $ b) $ cluôn luôn bằng a $ (b $ c). Lưu ý rằng vì giá trị (a $ b)được sử dụng làm đầu vào, các hàm kết hợp phải được đóng lại.

Giao hoán

Hàm nhị phân là giao hoán nếu hoán đổi thứ tự của các yếu tố đầu vào không làm thay đổi kết quả. Nói cách khác, nếu a $ bluôn luôn bằng nhau b $ a.

Danh tính

Hàm nhị phân có thành phần nhận dạng nếu tồn tại một số phần tử etrong miền sao a $ e = a = e $ acho tất cả atrong miền.

Vô tư

Hàm nhị phân là idempotent nếu áp dụng nó cho hai đầu vào giống hệt nhau sẽ cho số đó làm đầu ra. Nói cách khác, nếu a $ a = acho tất cả atrong miền.

Đầu vào

Bạn sẽ được cung cấp một hàm dưới dạng ma trận và miền của hàm sẽ là các số 0 ... n-1, trong đó nđộ dài cạnh của ma trận.

Giá trị (a $ b)được mã hóa trong ma trận dưới dạng phần tử thứ acủa hàng bthứ. Nếu ma trận đầu vào là Q, thì a $ b=Q[a][b]

Ví dụ: hàm lũy thừa ( **trong Python) trên miền [0, 1, 2]được mã hóa thành:

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

Các miền trái và phải giống nhau, vì vậy ma trận sẽ luôn là hình vuông.

Bạn có thể sử dụng bất kỳ định dạng ma trận thuận tiện nào làm đầu vào, chẳng hạn như danh sách danh sách, danh sách đơn theo thứ tự chính hàng hoặc cột, đối tượng ma trận gốc của ngôn ngữ của bạn, v.v. Tuy nhiên, bạn không thể lấy hàm trực tiếp làm đầu vào.

Để đơn giản, tất cả các mục ma trận sẽ là số nguyên. Bạn có thể cho rằng chúng phù hợp với kiểu số nguyên của ngôn ngữ của bạn.

Đầu ra

Bạn có thể chỉ ra thuộc tính nào ở trên giữ bất kỳ định dạng nào bạn chọn, bao gồm danh sách booleans, chuỗi có ký tự khác nhau cho mỗi thuộc tính, v.v. Tuy nhiên, phải có một đầu ra riêng biệt, duy nhất cho mỗi trong số 24 tập hợp con có thể của các thuộc tính. Đầu ra này phải dễ đọc với con người.

Ví dụ

Hàm tối đa trên miền n = 4:

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

Hàm này có các thuộc tính của đóng, kết hợp, giao hoán, nhận dạng và idempotence.

Hàm số mũ trên miền n = 3:

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

Hàm này không có thuộc tính nào ở trên.

Hàm bổ sung trên miền n = 3:

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

Hàm này có các đặc tính của tính giao hoán và bản sắc.

Bộ kết hợp K trên miền n = 3:

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

Hàm này có các thuộc tính của đóng, kết hợp và idempotence.

Hàm khác biệt tuyệt đối trên miền n = 3:

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

Hàm này có các thuộc tính của đóng, giao hoán và nhận dạng.

Hàm trung bình, làm tròn theo hướng chẵn, trên miền n = 3:

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

Hàm này có các thuộc tính của đóng, giao hoán, nhận dạng và idempotence.

Hàm đẳng thức trên miền n = 3:

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

Hàm này có các thuộc tính của đóng và giao hoán.

Thử thách

Đây là mã golf. Tiêu chuẩn áp dụng. Ít nhất là byte thắng.

Bình thường, 51 byte

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

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Điều này in ra một danh sách 5 giá trị boolean. Chúng chỉ ra các thuộc tính theo thứ tự:

[Idempotence, Commutativity, Identity, Closure, Associativity]

Đây là một định dạng đầu ra tốt hơn: Trình diễn hoặc Test Suite

Giải trình:

Ý chí:

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

Giao hoán:

CIQ   check if transpose(Q) is equal to Q

Danh tính:

}]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 ^

Khép kín:

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

Kết hợp:

&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

Haskell, 178 171 byte

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

Trả về một danh sách với năm booleans, theo thứ tự đóng, kết hợp, giao hoán, nhận dạng và idempotence.

Ví dụ sử dụng: f [[1, 0, 0],[0, 1, 0],[0, 0, 1]]-> [True,False,True,False,False].

Làm thế nào nó hoạt động:

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

Chỉnh sửa @xnor tìm thấy một số byte để lưu. Cảm ơn!

CJam, 95 byte

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*

In một phần sau của *AC1I. *là biểu tượng cho sự đóng cửa , Alà cho sự kết hợp , Clà để giao hoán , 1là cho bản sắc và Ilà cho idempotent .

Mảng đầu vào được đọc q~và lưu trữ trong A ( :A).

Khép kín

Ae_A,:Bf<:*'**

Nếu tất cả các :*phần tử ( ) trong ma trận ( Ae_) nhỏ f<hơn B = size (A) ( A,:B), hãy in a *( '**).

Kết hợp

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

Tạo tất cả các bộ ba trong miền ( B3m*). Chúng tôi in Anếu tất cả đều thỏa mãn một điều kiện ( {...}%:*'A*).

Điều kiện là, đối với một số bộ ba [i j k], gấp bên trái danh sách đó với A ( _{A==}*) và gấp bên trái của nó[k j i] ( \W%) với A ^op ( {Az==}*), phiên bản lật của A, bằng ( =).

Giao hoán

A phải bằng chuyển vị của nó : A_z=. Nếu vậy, chúng tôi in C( 'C=).

Danh tính

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.

Danh tính nhất thiết phải là duy nhất, vì vậy chúng tôi chỉ có thể in một 1.

Vô tư

Ae_B)%B,='I*

Kiểm tra nếu đường chéo bằng B,. Nếu vậy, in một I.

Matlab, 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)])

Một điều quan trọng cần lưu ý là không đóng ngụ ý không liên kết. Nhiều thuộc tính có thể dễ dàng được kiểm tra bằng cách sử dụng một số thuộc tính của ma trận:

• Khép kín : Tất cả các mục ma trận trong phạm vi nhất định?
• Kết hợp : Luôn luôn là một trong những khó khăn nhất để kiểm tra
• Giao hoán : Là ma trận đối xứng?
• Danh tính : Có chỉ số k sao cho hàng k-th và cột k-th chính xác là danh sách các chỉ số?
• Idempotence : Đường chéo có tương ứng với danh sách các chỉ số không?

Đầu vào thông qua ký hiệu standar Matlab: [a,b;c,d]hoặc [[a,b];[c,d]]hoặc [a b;c d]vv

Đầu ra là một vectơ của các số 0, 1 = true, 0 = false, cho mỗi thuộc tính theo thứ tự đã cho.

Mã đầy đủ:

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)]);

JavaScript (ES6) 165

Một hàm ẩn danh trả về một mảng với năm giá trị 0/1, theo thứ tự Đóng, Associativity, Commutativity, Nhận dạng và Idempotence.

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]

Ít chơi gôn

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
)

Kiểm tra

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>