เขียนโปรแกรมที่กำหนดว่าตารางการคูณของแมกมาไฟต์ที่กำหนดนั้นแสดงถึงกลุ่มหรือไม่ magma เป็นชุดที่มีการดำเนินการแบบไบนารีที่ปิดนั่นหมายความว่า

• สำหรับทั้งหมด a, b ใน G, a * b กลับเป็น g (ปิด) อีกครั้ง

ให้ (G, *) เป็นแมกมา (G, *) เป็นกลุ่มถ้า

• สำหรับ a, b, c ใน G, (a * b) * c = a * (b * c) (ความเกี่ยวข้อง)
• มีองค์ประกอบ e ใน G เช่นนั้น e * a = a * e = a สำหรับ a ทั้งหมดใน G (การดำรงอยู่ขององค์ประกอบที่เป็นกลาง)
• สำหรับ a ทั้งหมดใน G จะมี ab ใน G เช่นนั้น a * b = b * a = e โดยที่ e คือองค์ประกอบที่เป็นกลาง (การดำรงอยู่ของ Inverse)

รายละเอียด

อินพุตเป็นสตริงของ n ^ 2-1 อักขระ (หนึ่งอักขระสำหรับแต่ละองค์ประกอบของ magma ที่อนุญาตคือ 0-9, az) และแสดงถึงการอ่านตารางทีละแถวโดยสรุปชื่อโอเปอเรเตอร์ คุณสามารถสันนิษฐานได้ว่าการป้อนข้อมูลหมายถึงแมกมาที่ถูกต้อง (นั่นหมายถึงองค์ประกอบแต่ละรายการจะต้องตรงกันหนึ่งครั้งในแถวส่วนหัว / โคลัม)

ตัวอย่าง: ที่นี่เรามีตาราง Z_4

+ | 0 1 2 3
-----------
0 | 0 1 2 3
1 | 1 2 3 0
2 | 2 3 0 1
3 | 3 0 1 2

012300123112302230133012สายป้อนจะ (หรือถ้าเราใช้สัญลักษณ์ก็อาจเป็นได้nezdnnezdeezdnzzdneddnez) โปรดทราบว่าลำดับขององค์ประกอบในแถวและคอลัมน์ไม่จำเป็นต้องเหมือนกันดังนั้นตาราง Z_4 อาจมีลักษณะดังนี้:

+ | 1 3 2 0
-----------
1 | 2 0 3 1
0 | 1 3 2 0
2 | 3 1 0 2
3 | 0 2 1 3

นอกจากนี้ยังหมายความว่าองค์ประกอบที่เป็นกลางไม่จำเป็นต้องอยู่ในคอลัมน์แรกหรือแถวแรก

หากเป็นกลุ่มโปรแกรมจะต้องส่งคืนอักขระที่แสดงถึงองค์ประกอบที่เป็นกลาง หากไม่จำเป็นต้องส่งคืนค่าเท็จ (แตกต่างจากค่า 0-9 az)

กรณีทดสอบ

สามารถสร้างกลุ่มที่ไม่ใช่กลุ่มได้อย่างง่ายดายโดยเพียงแค่เปลี่ยนตัวเลขหนึ่งหลักของสตริงหรือโดยการเปลี่ยนตารางที่กำหนดการดำเนินการที่ขัดแย้งกับหนึ่งในกลุ่มสัจพจน์

กลุ่ม

จิ๊บจ๊อย

* | x
-----
x | x

xxx

Neutral Element: x

H (กลุ่ม quaternion)

* | p t d k g b n m 
-------------------
m | b d t g k p m n 
p | m k g d t n p b 
n | p t d k g b n m 
b | n g k t d m b p 
t | g m n p b k t d 
d | k n m b p g d t 
k | t b p m n d k g 
g | d p b n m t g k 

ptdkgbnmmbdtgkpmnpmkgdtnpbnptdkgbnmbngktdmbptgmnpbktddknmbpgdtktbpmndkggdpbnmtgk

Neutral Element: n

D_4

* | y r s t u v w x
-------------------
u | u x w v y t s r
v | v u x w r y t s
w | w v u x s r y t
x | x w v u t s r y
y | y r s t u v w x
r | r s t y v w x u
s | s t y r w x u v
t | t y r s x u v w


yrstuvwxuuxwvytsrvvuxwrytswwvuxsrytxxwvutsryyyrstuvwxrrstyvwxusstyrwxuvttyrsxuvw

Neutral Element: y

Z_6 x Z_2

x | 0 1 2 3 5 7 8 9 a b 4 6
---------------------------
0 | 0 1 2 3 5 7 8 9 a b 4 6 
1 | 1 2 3 4 0 8 9 a b 6 5 7 
2 | 2 3 4 5 1 9 a b 6 7 0 8 
7 | 7 8 9 a 6 2 3 4 5 0 b 1 
8 | 8 9 a b 7 3 4 5 0 1 6 2 
9 | 9 a b 6 8 4 5 0 1 2 7 3 
a | a b 6 7 9 5 0 1 2 3 8 4 
b | b 6 7 8 a 0 1 2 3 4 9 5 
3 | 3 4 5 0 2 a b 6 7 8 1 9 
4 | 4 5 0 1 3 b 6 7 8 9 2 a 
5 | 5 0 1 2 4 6 7 8 9 a 3 b 
6 | 6 7 8 9 b 1 2 3 4 5 a 0 

01235789ab46001235789ab4611234089ab6572234519ab67087789a623450b1889ab7345016299ab684501273aab6795012384bb678a0123495334502ab67819445013b67892a5501246789a3b66789b12345a0

Neutral Element: 0

A_4

* | i a b c d e f g h j k l
---------------------------
i | i a b c d e f g h j k l
a | a b i e c d g h f l j k
b | b i a d e c h f g k l j
c | c f j i g k a d l b e h
d | d h k b f l i e j a c g
e | e g l a h j b c k i d f
f | f j c k i g d l a h b e
g | g l e j a h c k b f i d
h | h k d l b f e j i g a c
j | j c f g k i l a d e h b
k | k d h f l b j i e c g a
l | l e g h j a k b c d f i

iabcdefghjkliiabcdefghjklaabiecdghfljkbbiadechfgkljccfjigkadlbehddhkbfliejacgeeglahjbckidfffjckigdlahbegglejahckbfidhhkdlbfejigacjjcfgkiladehbkkdhflbjiecgalleghjakbcdfi

Neutral Element: i

ที่ไม่ใช่กลุ่ม

ลูป (การเชื่อมโยงกลุ่มที่ขาดหายไปหรือกลุ่มเสมือนที่มีองค์ประกอบเป็นกลาง)

* | 1 2 3 4 5
-------------
1 | 1 2 3 4 5 
2 | 2 4 1 5 3 
3 | 3 5 4 2 1 
4 | 4 1 5 3 2 
5 | 5 3 2 1 4

12345112345224153335421441532553214

Neutral Element: 1
(2*2)*3 = 4*3 = 5 != 2 = 2*1 = 2*(2*3)

IP-loop (จากhttp://www.quasigroups.eu/contents/download/2008/16_2.pdf )

* | 1 2 3 4 5 6 7
-----------------
1 | 1 2 3 4 5 6 7
2 | 2 3 1 6 7 5 4
3 | 3 1 2 7 6 4 5
4 | 4 7 6 5 1 2 3
5 | 5 6 7 1 4 3 2
6 | 6 4 5 3 2 7 1
7 | 7 5 4 2 3 1 6

123456711234567223167543312764544765123556714326645327177542316

Neutral Element: 1
2*(2*4) = 2*6 = 5 != 7 = 3*4 = (2*2)*4

Monoid (โดย Quincunx ขอบคุณ!)

Monoids เป็น Magmas ที่มีความสัมพันธ์และองค์ประกอบที่เป็นกลาง

* | 0 1 2 3
-----------
0 | 0 1 2 3
1 | 1 3 1 3
2 | 2 1 0 3
3 | 3 3 3 3

012300123113132210333333

Neutral Element: 0

อีก Monoid

(การคูณ mod 10 โดยไม่มี 5) เราไม่มี inverses และการเชื่อมโยงนั้นได้รับจากการคูณ modulo 10

* | 1 2 3 4 6 7 8 9
-------------------
1 | 1 2 3 4 6 7 8 9
2 | 2 4 6 8 2 4 6 8
3 | 3 6 9 2 8 1 4 7
4 | 4 8 2 6 4 8 2 6
6 | 6 2 8 4 6 2 8 4
7 | 7 4 1 8 2 9 6 3
8 | 8 6 4 2 8 6 4 2
9 | 9 8 7 6 4 3 2 1

Neutral Element: 1   12346789112346789224682468336928147448264826662846284774182963886428642998764321

อ็อกเทฟ, 298 290 270 265 ตัวอักษร

function e=g(s)
c=@sortrows;d=a=c(c(reshape(a=[0 s],b=numel(a)^.5,b)')');
for i=2:b a(a==a(i))=i-1;end;
a=a(2:b,2:b--);u=1:b;
e=(isscalar(e=find(all(a==u')))&&a(e,:)==u&&sum(t=a==e)==1&&t==t')*e;
for x=u for y=u for z=u e*=a(a(x,y),z)==a(x,a(y,z));end;end;end;e=d(e+1);

265:ลบการจัดการฟังก์ชั่นที่ไม่จำเป็นออก

270:หลังจากที่ทุกคนเช็คที่e==hสำหรับอีมักจะสร้างความพึงพอใจE · A =และเอชเสมอความพึงพอใจของใหม่· H = aไม่จำเป็น สิ่งนี้เป็นไปไม่ได้สำหรับพวกเขาที่จะแตกต่าง ( e · h =? )

รายละเอียดจากคำอธิบายสำหรับการแก้ปัญหาด้านล่างยังคงเกี่ยวข้อง

290:

function e=g(s)
c=@sortrows;d=a=c(c(reshape(a=[0 s],b=numel(a)^.5,b)')');
for i=2:b a(a==a(i))=i-1;end;
a=a(2:b,2:b--);u=1:b;
s=@isscalar;e=(s(e=find(all(a==u')))&&s(h=find(all(a'==u')'))&&sum(t=a==e)==1&&t==t')*e;
for x=u for y=u for z=u e*=a(a(x,y),z)==a(x,a(y,z));end;end;end;e=d(e+1);

บรรทัดแรก

c=@sortrows;d=a=c(c(reshape(a=[0 s],b=numel(a)^.5,b)')'); เพียงแค่เก็บข้อมูลลงในตาราง nxn (ที่มีอักขระศูนย์ที่สถานที่ของเครื่องหมายการดำเนินการ) จากนั้นเรียงลำดับคอลัมน์และแถวตามลำดับพจนานุกรมเพื่อให้แถวและคอลัมน์ได้รับลำดับเดียวกัน:

+ | z a t b                        + | a b t z
-----------                        -----------
z | t b a z         becomes        a | t a z b
b | z a t b      ============>     b | a b t z
t | a z b t                        t | z t b a
a | b t z a                        z | b z a t

ตอนนี้ฉันทำการแมป"a","b","t","z"มาตรฐาน1, 2, 3, 4อีกครั้งเพื่อที่ฉันจะสามารถจัดทำดัชนีตารางได้อย่างมีประสิทธิภาพ for i=2:b a(a==a(i))=i-1;end;นี้จะกระทำโดยสาย มันให้ผลผลิตตารางเช่น

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

ที่เราสามารถกำจัดแถวและคอลัมน์แรกด้วยa=a(2:b,2:b--);u=1:b;:

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

ตารางนี้มีคุณสมบัติที่กำหนด:

• หากองค์ประกอบที่เป็นกลางeมีอยู่หนึ่งแถว ( isscalar) และคอลัมน์หนึ่งมีค่าของเวกเตอร์แถวu=[1 2 3 ... number-of-elements]:

s=@isscalar;e=(s(e=find(all(a==u')))&&s(h=find(all(a'==u')'))&&...

• หากแต่ละองค์ประกอบaมีองค์ประกอบย้อนกลับเป็น 'สองสิ่งไว้: องค์ประกอบที่เป็นกลางeเกิดขึ้นเพียงครั้งเดียวในแต่ละคอลัมน์และเพียงครั้งเดียวในแต่ละแถว ( sum(t=a==e)==1) และเพื่อตอบสนอง' 'a = a · a'การเกิดขึ้นของeคือ สมมาตรในส่วนที่เกี่ยวกับการแปลt==t'

• a · b สามารถดึงข้อมูลได้โดยการt(a,b)ทำดัชนีอย่างง่าย จากนั้นเราตรวจสอบความสัมพันธ์ในวงน่าเบื่อ:

for x=u for y=u for z=u e*=a(a(x,y),z)==a(x,a(y,z));end;end;end;

ฟังก์ชั่นจะคืนค่าองค์ประกอบที่เป็นกลางตามที่ปรากฏในตารางต้นฉบับ ( e=d(e+1)) หรืออักขระศูนย์หากตารางไม่ได้อธิบายกลุ่ม

ทับทิม, 401 ... 272

f=->s{n=(s.size+1)**0.5
w=n.to_i-1
e=s[0,w].split''
s=s[w,n*n]
m={}
w.times{(1..w).each{|i|m[s[0]+e[i-1]]=s[i]}
s=s[n,n*n]}
s=e.find{|a|e.all?{|b|x=m[a+b]
x==m[b+a]&&x==b}}
e.all?{|a|t=!0
e.all?{|b|x=m[a+b]
t||=x==m[b+a]&&x==s
e.all?{|c|m[m[a+b]+c]==m[a+m[b+c]]}}&&t}&&s}

นี่เป็นโปรแกรมทับทิมครั้งแรกของฉัน! puts f[gets.chomp]นี้กำหนดฟังก์ชั่นแลมบ์ดาที่เราสามารถทดสอบโดยการทำ ฉันกลับfalseสำหรับค่าเท็จของฉัน ในช่วงครึ่งแรกของฟังก์ชั่นคือการแยกวิเคราะห์อินพุตลงในแผนที่จากนั้นครึ่งหลังจะตรวจสอบความเป็นไปได้

f=->s{
    n=((s.size+1)**0.5).to_i
    w=n-1
    e=s[0,w].split'' # create an array of elements of the potential group
    s=s[w,n*n]
    m={} # this map is what defines our operation
    w.times{
        (1..w).each{               # for each element in the row of the table
            |i|m[s[0]+e[i-1]]=s[i] # put the value into the map
        }
        s=s[n,n*n]
    }
    s=e.find{|a| # s is the identity
        e.all?{|b|
            x=m[a+b]
            x==m[b+a]&&x==b # is a the identity?
        }
    }
    e.all?{|a| # implicit return statement
        t = !0 # t = false
        e.all?{|b| # check for inverses
            x=m[a+b]
            t ||= x==m[b+a]&&x==s # t is now true if b was a's inverse
            e.all?{|c|
                m[m[a+b]+c]==m[a+m[b+c]] # check associativity
            }
        } && t
    }&&s
}

JavaScript (ES6) 285 243 278

เรียกใช้ส่วนย่อยเพื่อทดสอบ (เนื่องจาก ES6 ใช้ได้กับ Firefox เท่านั้น)

แก้ไข 2 แก้ไขข้อบกพร่อง ฉันผิดในการค้นหาองค์ประกอบที่เป็นกลางตรวจสอบเพียงวิธีเดียว (ต้องการกรณีทดสอบที่ดีกว่า !!!)

แก้ไขโดยใช้การเรียงสตริงที่ง่ายกว่าแทนที่จะเป็น double index (เช่น @Quincunx) ฉันไม่รู้ว่าฉันคิดอะไรอยู่ นอกจากนี้การตรวจสอบผกผันที่ง่ายขึ้นก็ยังควรใช้

F=t=>(
  e=t.slice(0,d=Math.sqrt(t.length)|0),
  t=t.slice(d).match('.'.repeat(d+1),'g'),
  t.map(r=>{
    for(v=r[i=0],
        j=e.search(v)+1, // column for current row  element
        r!=v+e|t.some(r=>r[j]!=r[0])?0:n=v; // find neutral
        c=r[++i];
       )h[v+e[i-1]]=c
  },h={},n=''),
  e=[...e],!e.some(a=>e.some(b=>(
    h[a+b]==n&&--d, // inverse
    e.some(c=>h[h[a+b]+c]!=h[a+h[b+c]]) // associativity
  )
  ))&&!d&&n
)

input { width: 400px; font-size:10px }

Click on textbox to test - Result : <span id=O></span><br>
<input value='...' onclick='O.innerHTML=F(this.value)'> (?)
<br>Groups<br>
<input value='nezdnnezdeezdnzzdneddnez' onclick='O.innerHTML=F(this.value)'> (n)<br>
<input value='ptdkgbnmmbdtgkpmnpmkgdtnpbnptdkgbnmbngktdmbptgmnpbktddknmbpgdtktbpmndkggdpbnmtgk' onclick='O.innerHTML=F(this.value)'> (n)<br>
<input value='yrstuvwxuuxwvytsrvvuxwrytswwvuxsrytxxwvutsryyyrstuvwxrrstyvwxusstyrwxuvttyrsxuvw' onclick='O.innerHTML=F(this.value)'> (y)<br>
<input value='01235789ab46001235789ab4611234089ab6572234519ab67087789a623450b1889ab7345016299ab684501273aab6795012384bb678a0123495334502ab67819445013b67892a5501246789a3b66789b12345a0'onclick='O.innerHTML=F(this.value)'> (0)<br>
Non groups <br>
<input value='12345112345224153335421441532553214' onclick='O.innerHTML=F(this.value)'> (FAIL)<br>
<input value='123456711234567223167543312764544765123556714326645327177542316' onclick='O.innerHTML=F(this.value)'> (FAIL)<br>
<input value='012300123113132210333333' onclick='O.innerHTML=F(this.value)'> (FAIL)<br>

Haskell 391B

import Data.Maybe
import Data.List
o a b=elemIndex b a
l£a=fromJust.o a$l
a§b=[a!!i|i<-b]
f s|isJust j&&and(map(isJust.o h)s)&&and[or[p%q==e|q<-h]&&and[p%(q%r)==(p%q)%r|q<-h,r<-h]|p<-h]=[e]|True="!"where n=floor$(sqrt(fromIntegral$length s+1))-1;h=take n s;g=[s§[a..b]|(a,b)<-zip[1+n,2+n+n..][n+n,3*n+1..(n+1)^2]];v=s§[n,1+2*n..n+n*n];a%b=g!!(b£v)!!(a£h);j=o g h;e=v!!fromJust j

สาปแช่งเหล่านั้นimport!

import Data.Maybe
import Data.List

{- rename elemIndex to save characters -}
o a b=elemIndex b a

{- get the index of l in a -}
l£a=fromJust.o a$l

{- extract a sublist of a with indices b -}
a§b=[a!!i|i<-b]

f s |isJust j {-Identity-}
     &&and (map (isJust.o h) s) {-Closure-}
     &&and[
        or [p%q==e|q<-h] {-Inverse-}
        && and [ p%(q%r)==(p%q)%r | q<-h,r<-h ] {-Associativity-}
     |
        p<-h
     ]=[e]
    |True="!"
    where
    {-size-}    n=floor$(sqrt(fromIntegral$length s+1))-1
    {-horiz-}   h=take n s
    {-table-}   g=[s§[a..b]|(a,b)<-zip[1+n,2+n+n..][n+n,3*n+1..(n+1)^2]]
    {-vert-}    v=s§[n,1+2*n..n+n*n]
    {-operate-} a%b=g!!(b£v)!!(a£h)
                j=o g h {-index of the first row identical to the top-}
    {-ident-}   e=v!!fromJust j

คำอธิบาย

f::String->Stringแผนที่สตริงทั้งองค์ประกอบตัวตนหรือe::Char!

whereประโยคสร้างพวงของตัวแปรและฟังก์ชั่นซึ่งผมได้แสดงความคิดเห็น; v::[Int]เป็นรายการแนวตั้งขององค์ประกอบh::[Int]แนวนอนหนึ่งรายการ

%::Char->Char->Char ใช้การดำเนินการของกลุ่มกับข้อโต้แย้ง

g::[[Int]]คือตารางกลุ่ม (สำหรับการยกเลิกการอ้างอิงโดยใช้%)

j::Maybe Intมีดัชนีของข้อมูลระบุตัวตนvหากมีอยู่เป็นอย่างอื่นNothingซึ่งเป็นสาเหตุที่isJust jทำให้เกิดfข้อมูลระบุตัวตน