อะไรคือหลักการทางคณิตศาสตร์ / การคำนวณที่อยู่เบื้องหลังเกมนี้?


196

ลูก ๆ ของฉันมีเกมที่สนุกที่เรียกว่าSpot It! ข้อ จำกัด ของเกม (ที่ดีที่สุดที่ฉันสามารถอธิบายได้) คือ:

  • เป็นสำรับไพ่ 55 ใบ
  • ในการ์ดแต่ละใบมี 8 ภาพที่ไม่ซ้ำกัน (เช่นการ์ดไม่สามารถมี 2 ภาพเดียวกัน)
  • เมื่อเลือกไพ่ 2 ใบใด ๆ จากเด็คจะมีรูปภาพที่จับคู่เพียง 1 รูปเท่านั้น
  • รูปภาพที่ตรงกันอาจถูกปรับสัดส่วนบนการ์ดที่แตกต่างกัน แต่นั่นเป็นเพียงการทำให้เกมนั้นยากขึ้น (เช่นต้นไม้ขนาดเล็กยังคงตรงกับต้นไม้ใหญ่)

หลักการของเกมคือพลิกไพ่ 2 ใบและใครก็ตามที่เลือกภาพที่ตรงกันจะได้รับแต้ม

นี่คือภาพเพื่อความกระจ่าง:

เล็งเห็น

(ตัวอย่าง: คุณสามารถเห็นได้จากไพ่ 2 ใบด้านบนด้านบนว่าภาพที่จับคู่คือไดโนเสาร์สีเขียวระหว่างภาพล่างขวาและกลางขวาเป็นหัวของตัวตลก)

ฉันพยายามที่จะเข้าใจสิ่งต่อไปนี้:

  1. รูปภาพขั้นต่ำจำนวนเท่าใดที่ต้องใช้เพื่อให้ตรงกับเกณฑ์เหล่านี้และคุณจะพิจารณาสิ่งนี้อย่างไร

  2. ด้วยการใช้ pseudocode (หรือ Ruby) คุณจะสร้างการ์ดเกม 55 เกมอย่างไรจากอาร์เรย์ของรูปภาพ N (โดยที่ N คือจำนวนขั้นต่ำจากคำถามที่ 1)

ปรับปรุง:

รูปภาพเกิดขึ้นมากกว่าสองครั้งต่อเด็ค (ตรงกันข้ามกับที่บางคนคาดการณ์ไว้) ดูรูปไพ่ 3 ใบแต่ละใบมีสายฟ้า:3 ใบ


64
+1 สำหรับการเปลี่ยนเกมเป็นสิ่งที่ทำให้สมองของฉันเจ็บ
คาบาเร่ต์

3
จำนวนรูปภาพขั้นต่ำต่อการ์ดหรือจำนวนรูปภาพขั้นต่ำที่ระบุว่ามี 8 การ์ดต่อหนึ่งใบ? ภาพทุกภาพต้องมีความเหมาะสมหรือไม่
trutheality

7
ฉันคิดว่าคุณต้องเพิ่มข้อ จำกัด เพิ่มเติม มิฉะนั้นคุณสามารถใส่แอปเปิลลงในการ์ดทุกใบแล้วเพิ่มจำนวนภาพที่ไม่ซ้ำกันลงในการ์ดแต่ละใบ การ์ดแต่ละคู่จะจับคู่กับภาพของแอปเปิ้ลเท่านั้น
mbeckish

8
@cabaret: ในกรณีที่ว่าคุณจะชอบชุด สนุกอย่างไม่น่าเชื่อและทำให้รุนแรงขึ้น
dmckee --- ผู้ดูแลอดีตลูกแมว

4
ในขณะที่นี่เป็นคำถามที่ดีมันถูกถามแล้วในเว็บไซต์คณิตศาสตร์ (โดยฉัน) ดูเหมือนหัวข้อปิดเล็กน้อยที่นี่ - math.stackexchange.com/questions/36798/…
Javid Jamae

คำตอบ:


148

รูปทรงเรขาคณิตโปรเจค จำกัด

สัจพจน์ของprojective (เครื่องบิน) เรขาคณิตจะแตกต่างจากรูปทรงเรขาคณิตแบบยุคลิดเล็กน้อย

  • ทุกสองคะแนนมีหนึ่งบรรทัดที่ผ่านพวกเขา (นี่คือเหมือนกัน)
  • ทุกสองบรรทัดพบกันในจุดเดียว (นี่คือความแตกต่างเล็กน้อยจาก Euclid)

ตอนนี้เพิ่ม"จำกัด "ลงในซุปและคุณมีคำถาม:

เรามีรูปทรงเรขาคณิตที่มีเพียง 2 จุดได้หรือไม่? ด้วย 3 คะแนน ด้วย 4 ด้วย 7?

ยังมีคำถามที่เปิดอยู่เกี่ยวกับปัญหานี้ แต่เรารู้สิ่งนี้:

  • หากมีรูปทรงเรขาคณิตที่มีQจุดแล้วQ = n^2 + n + 1และnถูกเรียกว่าorderของเรขาคณิต
  • มีn+1คะแนนในทุกบรรทัด
  • จากทุกจุดผ่านn+1เส้นตรงทุกเส้น
  • Qจำนวนของสายนี้ยังมี

  • และในที่สุดถ้าnเป็นไพรม์ก็จะมีเรขาคณิตของระเบียบnอยู่


สิ่งที่เกี่ยวข้องกับปริศนาตัวหนึ่งอาจถามได้

ใส่cardแทนpointและpictureแทนที่จะเป็นlineและสัจพจน์กลายเป็น:

  • ไพ่สองใบทุกใบมีภาพเดียวกัน
  • สำหรับภาพทุกภาพมีการ์ดหนึ่งใบที่มีทั้งคู่

ตอนนี้จะช่วยให้n=7เรามีรูปทรงเรขาคณิตที่มีorder-7 จำกัด Q = 7^2 + 7 + 1นั่นทำให้Q=57เส้น (รูปภาพ) และQ=57คะแนน (ไพ่) ฉันเดาว่าผู้สร้างตัวต่อตัดสินใจว่า 55 เป็นจำนวนที่มากกว่า 57 และเหลือไพ่ 2 ใบ

นอกจากนี้เรายังได้รับn+1 = 8ดังนั้นจากทุกจุด (การ์ด), 8 บรรทัดผ่าน (8 ภาพปรากฏขึ้น) และทุก ๆ บรรทัด (รูปภาพ) มี 8 คะแนน (ปรากฏใน 8 การ์ด)


นี่คือตัวแทนของเครื่องบิน finite projective (order-2) (เรขาคณิต) ที่โด่งดังที่สุดที่มี 7 คะแนนเรียกว่าFano PlaneคัดลอกมาจากNoelle Evans - ปัญหาเรขาคณิต Finite

ป้อนคำอธิบายรูปภาพที่นี่

ฉันกำลังคิดที่จะสร้างภาพที่อธิบายว่าเครื่องบินลำดับ 2 ข้างต้นสามารถสร้างปริศนาที่คล้ายกันกับ 7 ใบและ 7 ภาพได้ แต่จากลิงค์จากคำถามคู่ math.exchange มีแผนภาพเช่นนั้น: Dobble-et- la-geometrie-finie

เครื่องบิน Fano


9
ดังนั้นเกมนี้แสดงรูปทรงเรขาคณิตที่ไม่ใช่ยูคลิด? มันจะถูกต้องหรือไม่ที่จะบอกว่าการ์ดถูกต้อง?
RMorrisey

2
มันฟังดูยอดเยี่ยม แต่ฉันก็ไม่แน่ใจว่ามันจะแก้ปัญหาแบบนี้ได้ดี @ypercube คุณช่วยอธิบายอีกเล็กน้อยได้ไหมว่าทำไมคุณคิดว่าการเปรียบเทียบระหว่างการ์ด / รูปภาพและจุด / บรรทัดนั้นถูกต้อง?
Nate Kohl

@ เนท: การเปรียบเทียบครั้งที่ 1 every two cards have exactly one picture in commonระบุไว้ในคำถาม อันดับที่ 2 for every two pictures there is exactly one card that has both of themOP สามารถบอกเราได้ว่าชุดเกมตรงตามที่กำหนดหรือไม่
ypercubeᵀᴹ

4
คำตอบที่ยอดเยี่ยม! ข้อมูลเชิงลึกที่ยอดเยี่ยมทำให้ทราบว่าเกมนั้นตรงกับคุณสมบัติของ Order-7 Projective Plane บวกกับหนึ่งในคำอธิบายที่ดีที่สุดของ Projective Planes สำหรับคนธรรมดาที่ฉันได้เห็น
RBarryYoung

3
สุกใส ฉันจะต้องอ่านมากกว่านี้ 100 ครั้งเพื่อพยายามที่จะคิดออกว่าจะสร้างชุดบัตรในหลาม ...
Jared

22

สำหรับผู้ที่มีปัญหาในการถ่ายภาพเรขาคณิตระนาบ projective ด้วย 57 คะแนนมีวิธีที่ดีและใช้งานง่ายในการสร้างเกมด้วย 57 ใบและ 57 สัญลักษณ์ (ตามคำตอบของYuval Filmusสำหรับคำถามนี้ ):

  1. สำหรับการ์ดที่มี 8 สัญลักษณ์ให้สร้างตารางที่มีสัญลักษณ์ไม่ซ้ำกัน 7x7
  2. เพิ่มสัญลักษณ์เพิ่มเติม 8 รายการสำหรับ "ลาด" จาก 0 ถึง 6 บวกอีกหนึ่งสัญลักษณ์สำหรับความชันอินฟินิตี้
  3. การ์ดแต่ละใบเป็นเส้นบนกริด (7 สัญลักษณ์) และอีกหนึ่งสัญลักษณ์จากความชันที่ตั้งไว้สำหรับความชันของเส้น เส้นมีการชดเชย (เช่นจุดเริ่มต้นด้านซ้าย) และความลาดชัน (เช่นจำนวนสัญลักษณ์ที่จะขึ้นไปในแต่ละขั้นตอนที่ถูกต้อง) เมื่อบรรทัดออกจากกริดที่ด้านบนให้ป้อนที่ด้านล่างอีกครั้ง ดูตัวอย่างนี้ (ภาพจากboardgamegeek ) สำหรับไพ่สองใบดังกล่าว:

ไพ่สองตัวอย่าง (แดงและเขียว) นำมาเป็นเส้นจากตาราง

ในตัวอย่างฉันใช้หนึ่งบรรทัดที่มีความชันเป็นศูนย์ (สีแดง) และอีกอันที่มีความชัน 1 (สีเขียว) พวกเขาตัดกันที่จุดร่วมจุดเดียว (นกฮูก)

วิธีนี้ทำให้มั่นใจได้ว่าไพ่สองใบใด ๆ มีสัญลักษณ์หนึ่งสัญลักษณ์ที่ตรงกันทั้งหมดเพราะ

  1. หากลาดแตกต่างกันเส้นจะตัดกันที่จุดเดียวเสมอ
  2. หากความลาดชันเท่ากันแล้วเส้นจะไม่ตัดกันและจะไม่มีสัญลักษณ์ทั่วไปจากตาราง ในกรณีนี้สัญลักษณ์ความชันจะเหมือนกัน

ด้วยวิธีนี้เราสามารถสร้างการ์ด 7x7 (7 offsets และ 7 ลาด)

นอกจากนี้เรายังสามารถสร้างการ์ดเพิ่มเติมเจ็ดใบจากเส้นแนวตั้งผ่านกริด สำหรับสิ่งเหล่านั้นจะใช้ไอคอนความชันอินฟินิตี้

เนื่องจากการ์ดแต่ละใบประกอบด้วยเจ็ดสัญลักษณ์จากกริดและสัญลักษณ์ "ความชัน" หนึ่งอันเราสามารถสร้างการ์ดเพิ่มเติมหนึ่งใบซึ่งประกอบด้วยสัญลักษณ์ความชัน 8 ทั้งหมด

สิ่งนี้ทำให้เรามี 7x8 + 1 = 57 การ์ดที่เป็นไปได้และ 7 x 7 + 8 = 57 สัญลักษณ์ที่จำเป็น

(ตามธรรมชาติแล้วจะใช้งานได้เฉพาะกับกริดที่มีขนาดเฉพาะจำนวนมากเท่านั้น (เช่น n = 7) มิฉะนั้นเส้นของความชันที่แตกต่างกันอาจมีศูนย์หรือมากกว่าหนึ่งทางแยกถ้าความชันเป็นตัวหารของขนาดกริด)


18

ดังนั้นจึงมีการ์ดk = 55ที่ประกอบด้วยm = 8ภาพแต่ละภาพจากจำนวนรวมของรูปภาพn เราสามารถย้ำคำถาม 'วิธีการหลายภาพnเราต้องทำเพื่อให้เราสามารถสร้างชุดของkบัตรมีเพียงภาพที่ใช้ร่วมกันอย่างใดอย่างหนึ่งระหว่างคู่ของบัตรใด ๆ ? อย่างเท่าเทียมกันโดยถามว่า:

รับnปริภูมิเวกเตอร์มิติและชุดของเวกเตอร์ทั้งหมดที่มีตรงmองค์ประกอบเท่ากับหนึ่งและศูนย์อื่น ๆ ทั้งหมดวิธีการใหญ่มีnจะเป็นเพื่อที่เราจะสามารถหาชุดของkเวกเตอร์ที่มีคู่ dot ผลิตภัณฑ์ที่มี ทั้งหมดเท่ากับ1หรือไม่

มีเวกเตอร์ที่เป็นไปได้อย่างแน่นอน ( nเลือกm ) เพื่อสร้างคู่จาก ดังนั้นเราอย่างน้อยต้องมีขนาดใหญ่พอที่nเพื่อให้ ( nเลือกม. )> = k นี่เป็นขอบเขตที่ต่ำกว่าดังนั้นเพื่อให้บรรลุข้อ จำกัด ความเข้ากันได้แบบคู่เราอาจต้องการn ที่สูงกว่ามาก

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

แก้ไข:ฉันเพิ่งรู้หลังจากเห็นโซลูชันของ Neil และ Gajet ว่าอัลกอริทึมที่ฉันใช้ไม่ได้ค้นหาโซลูชันที่ดีที่สุดเสมอไปดังนั้นทุกอย่างด้านล่างนี้ไม่ถูกต้อง ฉันจะพยายามอัปเดตรหัสของฉันในไม่ช้า

module Main where

cardCandidates n m = cardCandidates' [] (n-m) m
cardCandidates' buildup  0  0 = [buildup]
cardCandidates' buildup zc oc
    | zc>0 && oc>0 = zerorec ++ onerec
    | zc>0         = zerorec
    | otherwise    = onerec
    where zerorec = cardCandidates' (0:buildup) (zc-1) oc
          onerec  = cardCandidates' (1:buildup) zc (oc-1)

dot x y = sum $ zipWith (*) x y
compatible x y = dot x y == 1

compatibleCards = compatibleCards' []
compatibleCards' valid     [] = valid
compatibleCards' valid (c:cs)
  | all (compatible c) valid = compatibleCards' (c:valid) cs
  |                otherwise = compatibleCards'    valid  cs

legalCardSet n m = compatibleCards $ cardCandidates n m

main = mapM_ print [(n, length $ legalCardSet n m) | n<-[m..]]
  where m = 8

จำนวนสูงสุดของการ์ดที่ใช้งานร่วมกันได้สำหรับm = 8 ภาพต่อการ์ดสำหรับจำนวนรูปภาพที่แตกต่างกันให้เลือกจากnสำหรับสองสามแรกnมีลักษณะดังนี้:

วิธีการบังคับแบบเดรัจฉานนี้ไม่ได้ไกลนักเนื่องจากการระเบิดแบบ combinatorial แต่ฉันคิดว่ามันอาจจะน่าสนใจ

ที่น่าสนใจดูเหมือนว่าสำหรับm , k นั้นจะเพิ่มขึ้นเมื่อnเท่านั้นถึงnแน่นอนหลังจากนั้นจะคงที่

ซึ่งหมายความว่าสำหรับจำนวนภาพต่อการ์ดแต่ละใบมีจำนวนรูปภาพให้เลือกจำนวนหนึ่งซึ่งส่งผลให้มีจำนวนการ์ดตามกฎหมายสูงสุด การเพิ่มรูปภาพให้เลือกมากกว่าในอดีตว่าจำนวนที่เหมาะสมไม่เพิ่มจำนวนการ์ดที่ถูกกฎหมายอีกต่อไป

k ที่ดีที่สุดสองสามอย่างแรกคือ:

ตาราง k ที่ดีที่สุด


นั่นเป็นเพียงความพยายามครั้งแรกที่ถูกต้องใช่ไหม? คุณยังไม่ได้รวมข้อกำหนด "ผลิตภัณฑ์จุดคู่ที่มีค่าเท่ากับ 1" ...
Nemo

เห็นได้ชัดว่าเน้นไวยากรณ์ที่นี่ไม่ได้จริงๆสนับสนุน Haskell ( meta.stackexchange.com/questions/78363/... ) แต่ฉันจะโยนในคำใบ้เพียงในกรณีที่มันไม่ในอนาคต
BoltClock

@BoltClock ขอบคุณสำหรับการแก้ไขของคุณ! ฉันไม่รู้ว่าคุณสามารถให้คำแนะนำสำหรับการเน้นไวยากรณ์เฉพาะภาษาได้
Thies Heidecke

มันไม่ได้เป็นอย่างที่รู้จักกันดีเลย :)
BoltClock

9

คนอื่น ๆ ได้อธิบายถึงกรอบทั่วไปสำหรับการออกแบบ (ระนาบ projective จำกัด ) และแสดงวิธีการสร้างระนาบ projective จำกัด ของคำสั่งนายกรัฐมนตรี ฉันต้องการเติมช่องว่างบางอย่าง

เครื่องบิน projective จำกัด สามารถสร้างขึ้นสำหรับการสั่งซื้อที่แตกต่างกันมาก pแต่พวกเขามีความตรงไปตรงมาที่สุดในกรณีของการสั่งซื้อที่สำคัญ จากนั้นโมดูโลจำนวนเต็มจะpสร้างฟิลด์ จำกัด ซึ่งสามารถใช้อธิบายพิกัดของจุดและเส้นในระนาบ : มี 3 ชนิดที่แตกต่างกันของพิกัดสำหรับจุด(1,x,y), (0,1,x)และ(0,0,1)ที่xและyสามารถใช้ในค่าจากไป0 p-13 คะแนนที่แตกต่างกันอธิบายถึงสูตรp^2+p+1สำหรับจำนวนคะแนนในระบบ นอกจากนี้เรายังสามารถอธิบายเส้นเดียวกับที่ 3 ชนิดที่แตกต่างกันของพิกัด: [1,x,y], และ[0,1,x][0,0,1]

เราคำนวณว่าจุดและสายเป็นเหตุการณ์ที่เกิดขึ้นโดยไม่ว่าจะเป็นสินค้าที่มีจุดพิกัดของพวกเขาจะมีค่าเท่ากับ 0 pพอควร ดังนั้นสำหรับตัวอย่างเช่นจุด(1,2,5)เส้นและ[0,1,1]เป็นเหตุการณ์ที่เกิดขึ้นเมื่อp=7ตั้งแต่1*0+2*1+5*1 = 7 == 0 mod 7แต่จุด(1,3,3)เส้นและไม่ได้เป็นเหตุการณ์ที่เกิดขึ้นตั้งแต่[1,2,6]1*1+3*2+3*6 = 25 != 0 mod 7

แปลเป็นภาษาของการ์ดและภาพที่หมายถึงบัตรที่มีพิกัด(1,2,5)มีภาพที่มีพิกัด[0,1,1]แต่บัตรที่มีพิกัดไม่ได้มีภาพที่มีพิกัด(1,3,3) [1,2,6]เราสามารถใช้ขั้นตอนนี้เพื่อพัฒนารายการการ์ดและรูปภาพที่มี

โดยวิธีการที่ฉันคิดว่ามันง่ายกว่าที่จะคิดว่าภาพเป็นจุดและการ์ดเป็นเส้น แต่มีความเป็นสองเท่าในเรขาคณิต projective ระหว่างจุดและเส้นดังนั้นมันไม่สำคัญ อย่างไรก็ตามในสิ่งต่อไปนี้ฉันจะใช้คะแนนสำหรับรูปภาพและเส้นสำหรับการ์ด

การก่อสร้างเดียวกันนี้ใช้ได้กับทุกพื้นที่ จำกัด เรารู้ว่ามีขอบเขต จำกัด ของการสั่งซื้อqหากและเฉพาะในกรณีที่q=p^kเป็นพลังที่สำคัญ ฟิลด์นี้เรียกว่าGF(p^k)ซึ่งย่อมาจาก "สนาม Galois" เขตข้อมูลนั้นไม่ง่ายที่จะสร้างในกรณีพลังงานหลักเช่นเดียวกับในกรณีเฉพาะ

โชคดีที่ทำงานหนักได้ถูกทำและดำเนินการในซอฟต์แวร์ฟรีคือSage หากต้องการรับการออกแบบระนาบ projective ของลำดับ 4 ตัวอย่างเช่นพิมพ์

print designs.ProjectiveGeometryDesign(2,1,GF(4,'z'))

และคุณจะได้ผลลัพธ์ที่ดูเหมือน

ProjectiveGeometryDesign<points=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20], blocks=[[0, 1, 2, 3, 20], [0,
4, 8, 12, 16], [0, 5, 10, 15, 19], [0, 6, 11, 13, 17], [0, 7, 9, 14,
18], [1, 4, 11, 14, 19], [1, 5, 9, 13, 16], [1, 6, 8, 15, 18], [1, 7,
10, 12, 17], [2, 4, 9, 15, 17], [2, 5, 11, 12, 18], [2, 6, 10, 14, 16],
[2, 7, 8, 13, 19], [3, 4, 10, 13, 18], [3, 5, 8, 14, 17], [3, 6, 9, 12,
19], [3, 7, 11, 15, 16], [4, 5, 6, 7, 20], [8, 9, 10, 11, 20], [12, 13,
14, 15, 20], [16, 17, 18, 19, 20]]>

ฉันตีความข้างต้นดังต่อไปนี้: มี 21 ภาพที่มีป้ายกำกับจาก 0 ถึง 20 แต่ละบล็อค (เส้นในรูปทรงเรขาคณิตโปรเจค) บอกฉันว่ารูปภาพใดปรากฏบนการ์ด ตัวอย่างเช่นการ์ดใบแรกจะมีรูปภาพ 0, 1, 2, 3 และ 20; ไพ่ใบที่สองจะมีรูปภาพ 0, 4, 8, 12 และ 16; และอื่น ๆ

สามารถสร้างระบบการสั่งซื้อ 7 ได้

print designs.ProjectiveGeometryDesign(2,1,GF(7)) 

ซึ่งสร้างผลลัพธ์

ProjectiveGeometryDesign<points=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, 53, 54, 55, 56], blocks=[[0, 1, 2, 3, 4, 5, 6,
56], [0, 7, 14, 21, 28, 35, 42, 49], [0, 8, 16, 24, 32, 40, 48, 50], [0,
9, 18, 27, 29, 38, 47, 51], [0, 10, 20, 23, 33, 36, 46, 52], [0, 11, 15,
26, 30, 41, 45, 53], [0, 12, 17, 22, 34, 39, 44, 54], [0, 13, 19, 25,
31, 37, 43, 55], [1, 7, 20, 26, 32, 38, 44, 55], [1, 8, 15, 22, 29, 36,
43, 49], [1, 9, 17, 25, 33, 41, 42, 50], [1, 10, 19, 21, 30, 39, 48,
51], [1, 11, 14, 24, 34, 37, 47, 52], [1, 12, 16, 27, 31, 35, 46, 53],
[1, 13, 18, 23, 28, 40, 45, 54], [2, 7, 19, 24, 29, 41, 46, 54], [2, 8,
14, 27, 33, 39, 45, 55], [2, 9, 16, 23, 30, 37, 44, 49], [2, 10, 18, 26,
34, 35, 43, 50], [2, 11, 20, 22, 31, 40, 42, 51], [2, 12, 15, 25, 28,
38, 48, 52], [2, 13, 17, 21, 32, 36, 47, 53], [3, 7, 18, 22, 33, 37, 48,
53], [3, 8, 20, 25, 30, 35, 47, 54], [3, 9, 15, 21, 34, 40, 46, 55], [3,
10, 17, 24, 31, 38, 45, 49], [3, 11, 19, 27, 28, 36, 44, 50], [3, 12,
14, 23, 32, 41, 43, 51], [3, 13, 16, 26, 29, 39, 42, 52], [4, 7, 17, 27,
30, 40, 43, 52], [4, 8, 19, 23, 34, 38, 42, 53], [4, 9, 14, 26, 31, 36,
48, 54], [4, 10, 16, 22, 28, 41, 47, 55], [4, 11, 18, 25, 32, 39, 46,
49], [4, 12, 20, 21, 29, 37, 45, 50], [4, 13, 15, 24, 33, 35, 44, 51],
[5, 7, 16, 25, 34, 36, 45, 51], [5, 8, 18, 21, 31, 41, 44, 52], [5, 9,
20, 24, 28, 39, 43, 53], [5, 10, 15, 27, 32, 37, 42, 54], [5, 11, 17,
23, 29, 35, 48, 55], [5, 12, 19, 26, 33, 40, 47, 49], [5, 13, 14, 22,
30, 38, 46, 50], [6, 7, 15, 23, 31, 39, 47, 50], [6, 8, 17, 26, 28, 37,
46, 51], [6, 9, 19, 22, 32, 35, 45, 52], [6, 10, 14, 25, 29, 40, 44,
53], [6, 11, 16, 21, 33, 38, 43, 54], [6, 12, 18, 24, 30, 36, 42, 55],
[6, 13, 20, 27, 34, 41, 48, 49], [7, 8, 9, 10, 11, 12, 13, 56], [14, 15,
16, 17, 18, 19, 20, 56], [21, 22, 23, 24, 25, 26, 27, 56], [28, 29, 30,
31, 32, 33, 34, 56], [35, 36, 37, 38, 39, 40, 41, 56], [42, 43, 44, 45,
46, 47, 48, 56], [49, 50, 51, 52, 53, 54, 55, 56]]>

8

ฉันเพิ่งพบวิธีที่จะทำกับ 57 หรือ 58 ภาพ แต่ตอนนี้ฉันมีอาการปวดหัวไม่ดีมากฉันจะโพสต์รหัสทับทิมใน 8-10 ชั่วโมงหลังจากที่ฉันนอนหลับดี! เพียงคำใบ้วิธีแก้ปัญหาของฉันทุก ๆ ใบมี 7 ใบที่มีเครื่องหมายเหมือนกันและสามารถสร้างได้ทั้งหมด 56 ใบโดยใช้วิธีแก้ปัญหาของฉัน

นี่คือรหัสที่สร้างการ์ด 57 ใบที่ ypercube กำลังพูดถึง มันใช้รูปภาพ 57 รูปและคนที่แต่งตัวประหลาดขอโทษฉันได้เขียนรหัส C ++ จริง แต่รู้ว่าvector <something>เป็นอาร์เรย์ที่มีค่าประเภทsomethingมันง่ายต่อการเข้าใจสิ่งที่รหัสนี้ และรหัสนี้จะสร้างP^2+P+1การ์ดโดยใช้P^2+P+1รูปภาพแต่ละP+1รูปที่มีรูปภาพและใช้รูปภาพร่วมกันเพียง 1 รูปเท่านั้นสำหรับค่า P สำคัญทุกค่า ซึ่งหมายความว่าเราสามารถมี 7 ใบโดยใช้ 7 ภาพแต่ละภาพมี 3 ภาพ (สำหรับ p = 2), 13 ใบโดยใช้ 13 ภาพ (สำหรับ p = 3), 31 ใบโดยใช้ 31 ภาพ (สำหรับ p = 5), 57 ใบสำหรับ 57 ภาพ (สำหรับ p = 7) และอื่น ๆ ...

#include <iostream>
#include <vector>

using namespace std;

vector <vector<int> > cards;

void createcards(int p)
{
    cards.resize(0);
    for (int i=0;i<p;i++)
    {
        cards.resize(cards.size()+1);
        for(int j=0;j<p;j++)
        {
            cards.back().push_back(i*p+j);
        }
        cards.back().push_back(p*p+1);
    }

    for (int i=0;i<p;i++)
    {
        for(int j=0;j<p;j++)
        {
            cards.resize(cards.size()+1);
            for(int k=0;k<p;k++)
            {
                cards.back().push_back(k*p+(j+i*k)%p);
            }
            cards.back().push_back(p*p+2+i);
        }
    }

    cards.resize(cards.size()+1);

    for (int i=0;i<p+1;i++)
        cards.back().push_back(p*p+1+i);
}

void checkCards()
{
    cout << "---------------------\n";
    for(unsigned i=0;i<cards.size();i++)
    {
        for(unsigned j=0;j<cards[i].size();j++)
        {
            printf("%3d",cards[i][j]);
        }
        cout << "\n";
    }
    cout << "---------------------\n";
    for(unsigned i=0;i<cards.size();i++)
    {
        for(unsigned j=i+1;j<cards.size();j++)
        {
            int sim = 0;
            for(unsigned k=0;k<cards[i].size();k++)
                for(unsigned l=0;l<cards[j].size();l++)
                    if (cards[i][k] == cards[j][l])
                        sim ++;
            if (sim != 1)
                cout << "there is a problem between cards : " << i << " " << j << "\n";

        }
    }
}

int main()
{
    int p;
    for(cin >> p; p!=0;cin>> p)
    {
        createcards(p);
        checkCards();
    }
}

ขออภัยอีกครั้งสำหรับรหัสล่าช้า


37
ฉันมีหลักฐานที่สง่างามเกี่ยวกับเรื่องนี้ แต่กล่องความคิดเห็นนี้มีขนาดเล็กเกินไปที่จะเก็บไว้
sarnold

@Gajet: คุณเรียกใช้เพื่อp=4? (และการ์ด 21 ใบ / ภาพ)
ypercubeᵀᴹ

4 ไม่ทำงานในอัลกอริทึมของฉันเนื่องจาก 4 ไม่ใช่จำนวนเฉพาะในอัลกอริทึมของฉันเป็นสิ่งสำคัญที่ p ควรเป็นจำนวนมาก
Ali1S232

@percube หลังจากตรวจสอบอีกครั้งมีข้อผิดพลาดเล็กน้อยในอัลกอริทึมของฉัน แต่ฉันตรวจสอบเพื่อ, 2, 3,5,7 และฉันสามารถพิสูจน์ได้ว่าหมายเลขเฉพาะอื่น ๆ มันจะทำงานดังนั้นนี่คือรหัสที่สมบูรณ์ของฉัน (แต่ใน c ++)
Ali1S232

1
@Gajet: ทางออกที่ยอดเยี่ยม! ตอนนี้ฉันเข้าใจว่าทำไมอัลกอริทึมความโลภของฉันไม่ได้สร้างทางออกที่ดีที่สุดเสมอไป
Thies Heidecke

6

นี่คือวิธีแก้ปัญหาของ Gajet ใน Python เนื่องจากฉันพบว่า Python อ่านง่ายขึ้น ฉันได้ปรับเปลี่ยนเพื่อให้สามารถทำงานกับตัวเลขที่ไม่สำคัญเช่นกัน ฉันใช้ข้อมูลเชิงลึกของ Thies เพื่อสร้างรหัสที่แสดงที่เข้าใจง่ายขึ้น

from __future__ import print_function
from itertools import *

def create_cards(p):
    for min_factor in range(2, 1 + int(p ** 0.5)):
        if p % min_factor == 0:
            break
    else:
        min_factor = p
    cards = []
    for i in range(p):
        cards.append(set([i * p + j for j in range(p)] + [p * p]))
    for i in range(min_factor):
        for j in range(p):
            cards.append(set([k * p + (j + i * k) % p
                              for k in range(p)] + [p * p + 1 + i]))

    cards.append(set([p * p + i for i in range(min_factor + 1)]))
    return cards, p * p + p + 1

def display_using_stars(cards, num_pictures):
    for pictures_for_card in cards:
        print("".join('*' if picture in pictures_for_card else ' '
                      for picture in range(num_pictures)))

def check_cards(cards):
    for card, other_card in combinations(cards, 2):
        if len(card & other_card) != 1:
            print("Cards", sorted(card), "and", sorted(other_card),
                  "have intersection", sorted(card & other_card))

cards, num_pictures = create_cards(7)
display_using_stars(cards, num_pictures)
check_cards(cards)

ด้วยการส่งออก:

***      *   
   ***   *   
      ****   
*  *  *   *  
 *  *  *  *  
  *  *  * *  
*   *   *  * 
 *   **    * 
  **   *   * 
*    * *    *
 * *    *   *
  * * *     *
         ****

2
ฉันคิดว่าไพ่สามใบสุดท้ายในตัวอย่างของคุณไม่ถูกต้องเพราะพวกเขาไม่แชร์ภาพกับไพ่ใบที่ห้า เพิ่งตรวจสอบรหัสของฉันนานกว่าหนึ่งชั่วโมงก่อนที่ฉันจะรับรู้ :) ที่น่าสนใจดูเหมือนว่าขนาดสูงสุดของชุดบัตรตามกฎหมายคือ 5 ต่อ 4 ภาพต่อบัตรและไม่เพิ่มขึ้นแม้จะมีรูปภาพให้เลือกมากกว่า
Thies Heidecke

1
@ ด้วยแผนภาพที่ฉันผลิตโดยใช้รหัสของ Gajet มันง่ายกว่ามากที่จะเห็นว่าทำไมมี(p) + (p * p) + (1)การกำหนดค่าที่แน่นอน
Neil G

1
@Neil: ขอบคุณสำหรับแผนภาพที่อัปเดตทำให้ง่ายขึ้นมากที่จะเห็นว่าโซลูชั่นของ Gajet ทำงานอย่างไร!
Thies Heidecke

1
@Gajet: all p except 4 and 6ผมคิดว่าคุณมีความผิดเกี่ยวกับ หากคุณต้องการที่จะผลิตเครื่องบิน จำกัด ที่มีp*p+p+1จุดและเส้น (บัตรและภาพ) จากนั้นจะเกี่ยวข้องกับและไม่ได้finite fields ringsมีฟิลด์ จำกัด ของการสั่งซื้อpเมื่อ P คือหรือprime prime powerรหัสของคุณทำงานได้อย่างถูกต้องสำหรับช่วงเวลาเพราะการแสดงออกชอบk * p + (j + i * k) % pจะแสดงk*p + j + i*kในแง่ของการคูณและนอกจากนี้ในฟิลด์ จำกัด pของการสั่งซื้อ
ypercubeᵀᴹ

1
มันจะทำงานอย่างถูกต้องสำหรับอำนาจนายกเกินไปถ้าคุณสามารถแสดงการดำเนินงานเหล่านี้ (. Mult และนอกจากนี้) ในฟิลด์ จำกัด ของการสั่งซื้อp^2, p^3ฯลฯ ดังนั้นจึงจะทำงานให้4, 8, 9, 16, 25, 27, ...
ypercubeᵀᴹ

4

การใช้โปรแกรมz3พิสูจน์ทฤษฎีบท

อนุญาตPเป็นจำนวนสัญลักษณ์ต่อการ์ด ตามบทความนี้และypercubeᵀᴹคำตอบมีN = P**2 - P + 1บัตรและสัญลักษณ์ตามลำดับ สำรับไพ่สามารถแสดงด้วยเมทริกซ์อุบัติการณ์ซึ่งมีแถวสำหรับการ์ดแต่ละใบและคอลัมน์สำหรับแต่ละสัญลักษณ์ที่เป็นไปได้ ใช้(i,j)องค์ประกอบคือ1ถ้าการ์ดiมีสัญลักษณ์jเกี่ยวกับมัน เราจำเป็นต้องกรอกเมทริกซ์นี้ด้วยข้อ จำกัด เหล่านี้ในใจ:

  • องค์ประกอบทุกอย่างเป็นศูนย์หรือหนึ่ง
  • ผลรวมของแต่ละแถวนั้นแน่นอน P
  • ผลรวมของแต่ละคอลัมน์นั้นแน่นอน P
  • แถวสองแถวใด ๆ ต้องมีสัญลักษณ์เดียวเหมือนกันทุกประการ

นั่นหมายถึงN**2ตัวแปรและ N**2 + 2*N + (N choose 2)ข้อ จำกัด ดูเหมือนว่าจะสามารถจัดการได้ในเวลาไม่นานพร้อมกับz3อินพุตขนาดเล็ก

แก้ไข : น่าเสียดาย P = 8 ดูเหมือนว่าใหญ่เกินไปสำหรับวิธีนี้ ฉันฆ่ากระบวนการหลังจาก 14 ชั่วโมงของเวลาการคำนวณ

from z3 import *
from itertools import combinations

def is_prime_exponent(K):
    return K > 1 and K not in 6  # next non-prime exponent is 10, 
                                 # but that is too big anyway

def transposed(rows):
    return zip(*rows)

def spotit_z3(symbols_per_card):
    K = symbols_per_card - 1
    N = symbols_per_card ** 2 - symbols_per_card + 1
    if not is_prime_exponent(K):
        raise TypeError("Symbols per card must be a prime exponent plus one.")

    constraints = []

    # the rows of the incidence matrix
    s = N.bit_length()
    rows = [[BitVec("r%dc%d" % (r, c), s) for c in range(N)] for r in range(N)]

    # every element must be either 1 or 0
    constraints += [Or([elem == 1, elem == 0]) for row in rows for elem in row]

    # sum of rows and cols must be exactly symbols_per_card
    constraints += [Sum(row) == symbols_per_card for row in rows]
    constraints += [Sum(col) == symbols_per_card for col in transposed(rows)]

    # Any two rows must have exactly one symbol in common, in other words they
    # differ in (symbols_per_card - 1) symbols, so their element-wise XOR will
    # have 2 * (symbols_per_card - 1) ones.
    D = 2 * (symbols_per_card - 1)
    for row_a, row_b in combinations(rows, 2):
        constraints += [Sum([a ^ b for a, b in zip(row_a, row_b)]) == D]

    solver = Solver()
    solver.add(constraints)

    if solver.check() == unsat:
        raise RuntimeError("Could not solve it :(")

    # create the incidence matrix
    model = solver.model()
    return [[model[elem].as_long() for elem in row] for row in rows]


if __name__ == "__main__":
    import sys
    symbols_per_card = int(sys.argv[1])
    incidence_matrix = spotit_z3(symbols_per_card)
    for row in incidence_matrix:
        print(row)

ผล

$python spotit_z3.py 3
[0, 0, 1, 1, 0, 1, 0]
[0, 0, 0, 0, 1, 1, 1]
[0, 1, 0, 1, 0, 0, 1]
[1, 1, 0, 0, 0, 1, 0]
[0, 1, 1, 0, 1, 0, 0]
[1, 0, 0, 1, 1, 0, 0]
[1, 0, 1, 0, 0, 0, 1]
python spotit_z3.py 3  1.12s user 0.06s system 96% cpu 1.225 total

$ time python3 spotit_z3.py 4
[0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0]
[0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0]
[0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0]        
[0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1]
[0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1]
[0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0]
[0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]
[1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
[1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0]
python spotit_z3.py 4  664.62s user 0.15s system 99% cpu 11:04.88 total

$ time python3 spotit_z3.py 5
[1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
[0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1]
[0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1]
[1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
[0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1]
[1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
python spotit_z3.py 5  1162.72s user 20.34s system 99% cpu 19:43.39 total

$ time python3 spotit_z3.py 8
<I killed it after 14 hours of run time.>

4

ฉันชอบกระทู้นี้มาก ฉันสร้างโครงการงูหลาม github นี้ด้วยส่วนของรหัสนี้ที่นี่เพื่อวาดการ์ดที่กำหนดเองเป็น png (เพื่อให้หนึ่งสามารถสั่งซื้อการ์ดเกมที่กำหนดเองในอินเทอร์เน็ต)

https://github.com/plagtag/ProjectiveGeometry-Game


3

ฉันเขียนบทความเกี่ยวกับวิธีสร้างสำรับชนิดนี้ด้วยรหัสใน Perl รหัสไม่ได้รับการปรับให้เหมาะสม แต่อย่างน้อยก็สามารถสร้างสำรับการสั่งซื้อ "สมเหตุสมผล" ... และอีกมากมาย

ต่อไปนี้เป็นตัวอย่างของการสั่งซื้อ 8 ซึ่งจะต้องพิจารณาคณิตศาสตร์พื้นฐานที่ซับซ้อนกว่าเล็กน้อยเนื่องจาก 8 ไม่สำคัญแม้ว่าคำสั่งที่ถูกต้องสำหรับการสร้างเด็คประเภทนี้ ดูด้านบนหรือบทความสำหรับคำอธิบายโดยละเอียดเพิ่มเติมด้านล่างหากคุณต้องการสร้าง Spot-It ที่ยากขึ้นเล็กน้อย :-)

$ time pg2 8
elements in field: 8
  0. (1, 9, 17, 25, 33, 41, 49, 57, 65)
  1. (0, 9, 10, 11, 12, 13, 14, 15, 16)
  2. (2, 9, 18, 27, 36, 45, 54, 63, 72)
  3. (6, 9, 22, 26, 37, 43, 56, 60, 71)
  4. (7, 9, 23, 32, 34, 46, 52, 59, 69)
  5. (8, 9, 24, 30, 35, 42, 55, 61, 68)
  6. (3, 9, 19, 29, 39, 44, 50, 64, 70)
  7. (4, 9, 20, 31, 38, 48, 53, 58, 67)
  8. (5, 9, 21, 28, 40, 47, 51, 62, 66)
  9. (0, 1, 2, 3, 4, 5, 6, 7, 8)
 10. (1, 10, 18, 26, 34, 42, 50, 58, 66)
 11. (1, 14, 22, 30, 38, 46, 54, 62, 70)
 12. (1, 15, 23, 31, 39, 47, 55, 63, 71)
 13. (1, 16, 24, 32, 40, 48, 56, 64, 72)
 14. (1, 11, 19, 27, 35, 43, 51, 59, 67)
 15. (1, 12, 20, 28, 36, 44, 52, 60, 68)
 16. (1, 13, 21, 29, 37, 45, 53, 61, 69)
 17. (0, 17, 18, 19, 20, 21, 22, 23, 24)
 18. (2, 10, 17, 28, 35, 46, 53, 64, 71)
 19. (6, 14, 17, 29, 34, 48, 51, 63, 68)
 20. (7, 15, 17, 26, 40, 44, 54, 61, 67)
 21. (8, 16, 17, 27, 38, 47, 50, 60, 69)
 22. (3, 11, 17, 31, 37, 42, 52, 62, 72)
 23. (4, 12, 17, 30, 39, 45, 56, 59, 66)
 24. (5, 13, 17, 32, 36, 43, 55, 58, 70)
 25. (0, 49, 50, 51, 52, 53, 54, 55, 56)
 26. (3, 10, 20, 30, 40, 43, 49, 63, 69)
 27. (2, 14, 21, 32, 39, 42, 49, 60, 67)
 28. (8, 15, 18, 28, 37, 48, 49, 59, 70)
 29. (6, 16, 19, 31, 36, 46, 49, 61, 66)
 30. (5, 11, 23, 26, 38, 45, 49, 64, 68)
 31. (7, 12, 22, 29, 35, 47, 49, 58, 72)
 32. (4, 13, 24, 27, 34, 44, 49, 62, 71)
 33. (0, 57, 58, 59, 60, 61, 62, 63, 64)
 34. (4, 10, 19, 32, 37, 47, 54, 57, 68)
 35. (5, 14, 18, 31, 35, 44, 56, 57, 69)
 36. (2, 15, 24, 29, 38, 43, 52, 57, 66)
 37. (3, 16, 22, 28, 34, 45, 55, 57, 67)
 38. (7, 11, 21, 30, 36, 48, 50, 57, 71)
 39. (6, 12, 23, 27, 40, 42, 53, 57, 70)
 40. (8, 13, 20, 26, 39, 46, 51, 57, 72)
 41. (0, 65, 66, 67, 68, 69, 70, 71, 72)
 42. (5, 10, 22, 27, 39, 48, 52, 61, 65)
 43. (3, 14, 24, 26, 36, 47, 53, 59, 65)
 44. (6, 15, 20, 32, 35, 45, 50, 62, 65)
 45. (2, 16, 23, 30, 37, 44, 51, 58, 65)
 46. (4, 11, 18, 29, 40, 46, 55, 60, 65)
 47. (8, 12, 21, 31, 34, 43, 54, 64, 65)
 48. (7, 13, 19, 28, 38, 42, 56, 63, 65)
 49. (0, 25, 26, 27, 28, 29, 30, 31, 32)
 50. (6, 10, 21, 25, 38, 44, 55, 59, 72)
 51. (8, 14, 19, 25, 40, 45, 52, 58, 71)
 52. (4, 15, 22, 25, 36, 42, 51, 64, 69)
 53. (7, 16, 18, 25, 39, 43, 53, 62, 68)
 54. (2, 11, 20, 25, 34, 47, 56, 61, 70)
 55. (5, 12, 24, 25, 37, 46, 50, 63, 67)
 56. (3, 13, 23, 25, 35, 48, 54, 60, 66)
 57. (0, 33, 34, 35, 36, 37, 38, 39, 40)
 58. (7, 10, 24, 31, 33, 45, 51, 60, 70)
 59. (4, 14, 23, 28, 33, 43, 50, 61, 72)
 60. (3, 15, 21, 27, 33, 46, 56, 58, 68)
 61. (5, 16, 20, 29, 33, 42, 54, 59, 71)
 62. (8, 11, 22, 32, 33, 44, 53, 63, 66)
 63. (2, 12, 19, 26, 33, 48, 55, 62, 69)
 64. (6, 13, 18, 30, 33, 47, 52, 64, 67)
 65. (0, 41, 42, 43, 44, 45, 46, 47, 48)
 66. (8, 10, 23, 29, 36, 41, 56, 62, 67)
 67. (7, 14, 20, 27, 37, 41, 55, 64, 66)
 68. (5, 15, 19, 30, 34, 41, 53, 60, 72)
 69. (4, 16, 21, 26, 35, 41, 52, 63, 70)
 70. (6, 11, 24, 28, 39, 41, 54, 58, 69)
 71. (3, 12, 18, 32, 38, 41, 51, 61, 71)
 72. (2, 13, 22, 31, 40, 41, 50, 59, 68)
errors in check: 0

real    0m0.303s
user    0m0.200s
sys 0m0.016s

ตัวระบุแต่ละตัวจาก0ถึง72สามารถอ่านได้ทั้งในฐานะตัวระบุการ์ดและตัวระบุรูปภาพ ตัวอย่างเช่นแถวสุดท้ายหมายความว่า:

  • บัตร72มีรูปภาพ2, 13, 22, ... , 59, 68และ
  • ภาพที่72ปรากฏในบัตร2, 13, 22, ... , และ5968
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.