इस खेल के पीछे गणितीय / कम्प्यूटेशनल सिद्धांत क्या हैं?

Question

मेरे बच्चों को यह मजेदार खेल स्पॉट इट कहा जाता है ! खेल की कमी (जैसा कि सबसे अच्छा मैं वर्णन कर सकता हूं) हैं:

• यह 55 कार्ड का एक डेक है
• प्रत्येक कार्ड पर 8 अद्वितीय चित्र हैं (यानी एक कार्ड में एक ही चित्र के 2 नहीं हो सकते)
• डेक से चुने गए किसी भी 2 कार्ड को देखते हुए, 1 और केवल 1 मिलान चित्र है ।
• चित्रों का मिलान अलग-अलग कार्डों पर अलग-अलग तरीके से किया जा सकता है, लेकिन यह केवल खेल को कठिन बनाने के लिए है (यानी एक छोटा पेड़ अभी भी एक बड़े पेड़ से मेल खाता है)

खेल का सिद्धांत है: 2 कार्ड पर पलटें और जो कोई भी पहली बार पिक्चर खींचता है उसे एक पॉइंट मिलता है।

यहाँ स्पष्टीकरण के लिए एक तस्वीर है:

(उदाहरण: आप नीचे के 2 कार्ड से देख सकते हैं कि मिलान चित्र हरा डायनासोर है। नीचे-दाएँ और मध्य-दाएँ चित्र के बीच, यह एक जोकर का सिर है।)

मैं निम्नलिखित समझने की कोशिश कर रहा हूँ:

1. इन मानदंडों को पूरा करने के लिए आवश्यक विभिन्न चित्रों की न्यूनतम संख्या क्या है और आप इसे कैसे निर्धारित करेंगे?

2. स्यूडोकोड (या रूबी) का उपयोग करते हुए, आप एन चित्रों की एक सरणी से 55 गेम कार्ड कैसे उत्पन्न करेंगे (जहां प्रश्न 1 से एन न्यूनतम संख्या है)?

अपडेट करें:

चित्र प्रति डेक दो बार से अधिक होते हैं (इसके विपरीत जो कुछ अधिभूत हुए हैं)। 3 कार्ड की इस तस्वीर को देखें, जिनमें से प्रत्येक में बिजली के बोल्ट हैं:

Comments

एक खेल को किसी चीज़ में बदलने के लिए, जो मेरे दिमाग को चोट पहुँचाता है।

— कैबरे

प्रति कार्ड चित्रों की न्यूनतम संख्या या दी गई तस्वीरों की न्यूनतम संख्या 8 प्रति कार्ड हैं? इसके अलावा, क्या हर तस्वीर को मैच्योर होना पड़ता है?

— सच्चाई

मुझे लगता है कि आपको और अधिक बाधाओं को जोड़ने की आवश्यकता है। अन्यथा, आप प्रत्येक कार्ड पर एक सेब रख सकते हैं, और फिर प्रत्येक कार्ड में कई अद्वितीय छवियां जोड़ सकते हैं। कार्ड की प्रत्येक जोड़ी केवल सेब की छवि पर मेल खाएगी।

— मबेकिश

@ कैबरे: उस मामले में आप सेट करना चाहते हैं । अविश्वसनीय रूप से मज़ेदार और उत्तेजित।

— dmckee --- पूर्व-मध्यस्थ ने

हालांकि यह एक बड़ा सवाल है, इसके पहले से ही गणित साइट (मेरे द्वारा) पर पूछा गया है। यह यहाँ एक छोटा विषय लगता है। - math.stackexchange.com/questions/36798/…

— जाविद जमा

Answer 1

परिमित प्रोजेक्टिव ज्यामिति

सूक्तियों की प्रक्षेपीय (विमान) ज्यामिति इयूक्लिडियन ज्यामिति की तुलना में थोड़ा अलग हैं:

• प्रत्येक दो बिंदुओं की ठीक एक रेखा होती है जो उनके बीच से गुजरती है (यह वही है)।
• हर दो लाइनें बिल्कुल एक बिंदु में मिलती हैं (यह यूक्लिड से थोड़ी अलग है)।

अब, सूप में "परिमित" जोड़ें और आपके पास सवाल है:

क्या हमारे पास सिर्फ 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 कार्ड में दिखाई देते हैं) हैं।

---

यहाँ 7 अंक के साथ सबसे प्रसिद्ध परिमित प्रक्षेपी (ऑर्डर -2) प्लेन (ज्यामिति) का प्रतिनिधित्व किया गया है, जिसे फानो प्लेन के रूप में जाना जाता है, जिसे नोएले इवांस से कॉपी किया गया है - परिमित ज्यामिति समस्या पृष्ठ

मैं एक ऐसी छवि बनाने की सोच रहा था जो यह बताए कि 7 कार्ड और 7 चित्रों के साथ उपरोक्त ऑर्डर -2 प्लेन को एक समान पहेली कैसे बनाया जा सकता है, लेकिन फिर math.exchange ट्विन प्रश्न के एक लिंक में वास्तव में ऐसा एक आरेख है: Dobble-et- la-geometrie-finie

Comments

तो यह खेल गैर-यूक्लिडियन ज्यामिति को प्रदर्शित करता है? क्या यह कहना सही होगा कि द कार्ड्स सही हैं?

— RMorrisey

यह भयानक लगता है, लेकिन मुझे कोई निश्चितता नहीं है कि यह वास्तव में समस्या को अच्छी तरह से मॉडल करता है। @ypercube, क्या आप थोड़ा और समझा सकते हैं कि आपको कार्ड / चित्र और बिंदु / रेखा के बीच की समानता क्यों मान्य है?

— नैट कोहल

@ नैट: 1 सादृश्य every two cards have exactly one picture in common, प्रश्न में कहा गया है। 2 for every two pictures there is exactly one card that has both of them, ओपी हमें बता सकता है कि क्या खेल सेट इसे संतुष्ट करता है।

— ypercube y

बहुत बढ़िया जवाब! महान अंतर्दृष्टि, यह महसूस करते हुए कि यह गेम ऑर्डर -7 प्रोजेक्टिव प्लेन के गुणों से मेल खाता है, साथ ही मैंने जो लेपर्स के लिए प्रोजेक्टिव प्लान के सर्वश्रेष्ठ स्पष्टीकरणों में से एक को देखा है।

— RBarryYoung

प्रतिभाशाली। मुझे यह जानने के लिए 100 बार पढ़ने की ज़रूरत है कि पायथन में कार्ड सेट कैसे उत्पन्न करें, यह जानने की कोशिश करें ...

— Jared

Answer 2

उन लोगों के लिए, जिन्हें 57 अंकों के साथ अनुमानित विमान ज्यामिति का चित्रण करने में परेशानी होती है, 57 कार्ड और 57 प्रतीकों के साथ खेल के निर्माण का एक बहुत अच्छा, सहज तरीका है ( इस प्रश्न के लिए युवल फिल्मस द्वारा उत्तर पर आधारित ):

1. 8 प्रतीकों वाले कार्ड के लिए, अद्वितीय प्रतीकों का 7x7 ग्रिड बनाएं।
2. 0 से 6 तक "ढलान" के लिए एक अतिरिक्त 8 प्रतीकों को जोड़ें, साथ ही अनंत ढलान के लिए एक।
3. प्रत्येक कार्ड ग्रिड पर एक लाइन (7 प्रतीक) प्लस लाइन के ढलान के लिए निर्धारित ढलान से एक प्रतीक है। लाइनों में एक ऑफसेट (यानी बाईं ओर शुरुआती बिंदु), और एक ढलान (यानी प्रत्येक चरण दाएं के लिए कितने प्रतीक हैं)। जब रेखा शीर्ष पर ग्रिड छोड़ देती है, तो नीचे फिर से दर्ज करें। इस उदाहरण का आंकड़ा देखें ( ऐसे दो कार्ड के लिए बोर्डगेमेक से चित्र ):

उदाहरण में, मैं ढलान शून्य (लाल) के साथ एक लाइन लेता हूं, और एक ढलान 1 (हरा) के साथ। वे बिल्कुल एक सामान्य बिंदु (उल्लू) पर प्रतिच्छेद करते हैं।

यह विधि सुनिश्चित करती है कि किसी भी दो कार्ड में एक समान प्रतीक है, क्योंकि

1. यदि ढलान अलग हैं, तो लाइनें हमेशा एक बिंदु पर काटेंगी।
2. यदि ढलान समान हैं, तो लाइनें चौराहे नहीं होंगी और ग्रिड से कोई सामान्य प्रतीक नहीं होगा। इस मामले में, ढलान का प्रतीक समान होगा।

इस तरह, हम 7x7 कार्ड (7 ऑफसेट और 7 ढलान) का निर्माण कर सकते हैं।

हम ग्रिड के माध्यम से ऊर्ध्वाधर लाइनों से सात अतिरिक्त कार्ड भी बना सकते हैं (यानी प्रत्येक कॉलम ले रहे हैं)। उन लोगों के लिए, अनन्तता ढलान आइकन का उपयोग किया जाता है।

क्योंकि प्रत्येक कार्ड में ग्रिड से सात प्रतीक होते हैं और ठीक एक "ढलान" प्रतीक होता है, हम एक अतिरिक्त कार्ड बना सकते हैं, जिसमें बस सभी 8 ढलान के प्रतीक होते हैं।

यह हमें 7x8 + 1 = 57 संभावित कार्ड और 7 x 7 + 8 = 57 आवश्यक प्रतीकों के साथ छोड़ देता है।

(स्वाभाविक रूप से, यह केवल प्राइम-नंबर-आकार के ग्रिड (जैसे n = 7) के साथ काम करता है। अन्यथा, अलग-अलग ढलान की लाइनें शून्य या एक से अधिक चौराहे हो सकती हैं यदि ढलान ग्रिड आकार का विभाजक है।)

Answer 3

तो वहाँ k = 55 कार्ड हैं जिनमें m = 8 चित्र हैं जिनमें से प्रत्येक में n चित्र कुल हैं। हम सवाल को फिर से कर सकते हैं 'कितने चित्रों n कर हमें जरूरत है, ताकि हम का एक सेट का निर्माण कर सकते कश्मीर कार्ड के किसी भी जोड़ी के बीच केवल एक ही साझा तस्वीर के साथ कार्ड?' बराबर पूछ कर:

एन -डायमेंशनल वेक्टर स्पेस और सभी वैक्टर के सेट को देखते हुए , जिसमें एक और सभी शून्य के बराबर एम तत्व होते हैं , एन कितना बड़ा होता है , ताकि हम k वेक्टर्स का एक सेट पा सकें , जिनके युग्मक डॉट उत्पाद हैं सभी 1 के बराबर है ?

वहाँ से जोड़े बनाने के लिए वास्तव में ( एन चुनें एम ) संभव वैक्टर हैं। इसलिए हमें कम से कम एक बड़े n की आवश्यकता है ताकि ( n choose m )> = k । यह सिर्फ एक कम बाध्यता है, इसलिए जोड़ीदार अनुकूलता की कमी को पूरा करने के लिए हमें संभवतः बहुत अधिक एन की आवश्यकता है ।

बस थोड़ा सा प्रयोग करने के लिए मैंने वैध कार्ड सेटों की गणना के लिए एक छोटा हास्केल प्रोग्राम लिखा:

संपादित करें: मुझे सिर्फ नील और गजेट के समाधान को देखने के बाद एहसास हुआ कि एल्गोरिथ्म मैं हमेशा सबसे अच्छा संभव समाधान नहीं ढूंढता है, इसलिए नीचे दी गई सब कुछ जरूरी नहीं है। मैं जल्द ही अपना कोड अपडेट करने का प्रयास करूंगा।

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

पहले कुछ n के लिए n से चुनने के लिए चित्रों की विभिन्न संख्या के लिए m = 8 चित्र प्रति कार्ड के लिए संगत कार्ड की अधिकतम संख्या परिणामी :

ब्रूट फोर्स मेथड की वजह से यह ब्रूट फोर्स मेथड बहुत दूर नहीं जाता है। लेकिन मुझे लगा कि यह अभी भी दिलचस्प हो सकता है।

दिलचस्प है, ऐसा लगता है कि दिए गए मीटर के लिए , k केवल n तक एक निश्चित n के साथ बढ़ता है , जिसके बाद यह स्थिर रहता है।

इसका मतलब यह है, कि प्रत्येक कार्ड के लिए हर संख्या में चित्रों की एक निश्चित संख्या होती है, जिसमें से अधिकतम संभव कानूनी कार्डों का परिणाम होता है। अतीत से चुनने के लिए अधिक चित्रों को जोड़ने से इष्टतम संख्या किसी भी कानूनी कार्ड की संख्या में वृद्धि नहीं करती है।

पहले कुछ इष्टतम k हैं:

Comments

यह एक बाउंड पर एक प्रारंभिक प्रयास है, है ना? आपने "जोड़ीदार डॉट उत्पादों को 1" आवश्यकता के बराबर शामिल नहीं किया है ...

— निमो

जाहिरा तौर पर यहाँ वाक्यविन्यास हाइलाइटर वास्तव में अभी तक हास्केल का समर्थन नहीं करता है ( meta.stackexchange.com/questions/78363/… ), लेकिन मैं भविष्य में ऐसा होने पर केवल संकेत में टॉस करूँगा।

— BoltClock

@BoltClock आपके संपादन के लिए धन्यवाद! मुझे नहीं पता था कि आप भाषा-विशिष्ट वाक्य रचना हाइलाइटिंग के लिए संकेत दे सकते हैं।

— थिस हाइडेक

ऐसा नहीं है बहुत अभी तक अच्छी तरह से ज्ञात :)

— BoltClock

Answer 4

अन्य लोगों ने डिजाइन (परिमित प्रक्षेप्य तल) के लिए सामान्य रूपरेखा का वर्णन किया है और दिखाया है कि कैसे प्रधान आदेश के परिमित प्रक्षेपी विमानों को उत्पन्न किया जाए। मैं कुछ अंतराल में भरना चाहूंगा।

कई अलग-अलग आदेशों के लिए परिमित प्रक्षेपी विमानों को उत्पन्न किया जा सकता है, लेकिन वे प्राइम ऑर्डर के मामले में सबसे सीधे हैं p। फिर पूर्णांक मॉडुलो pएक परिमित क्षेत्र बनाते हैं जिसका उपयोग विमान में बिंदुओं और रेखाओं के लिए निर्देशांक का वर्णन करने के लिए किया जा सकता है। अंक के लिए निर्देशांक के 3 अलग अलग प्रकार के होते हैं: (1,x,y), (0,1,x), और (0,0,1), जहां xऔर yसे मूल्यों पर ले जा सकते हैं 0करने के लिए p-1। 3 विभिन्न प्रकार के बिंदु 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]। हम इस प्रक्रिया का उपयोग कार्डों की पूरी सूची और उन चित्रों को विकसित करने के लिए कर सकते हैं जिनमें वे शामिल हैं।

वैसे, मुझे लगता है कि रेखाओं के रूप में चित्रों और बिंदुओं के रूप में चित्रों के बारे में सोचना आसान है, लेकिन अंक और रेखाओं के बीच प्रक्षेप्य ज्यामिति में एक द्वंद्व है, इसलिए यह वास्तव में कोई फर्क नहीं पड़ता। हालाँकि, मैं निम्न में से कार्ड के लिए चित्रों और रेखाओं के बिंदुओं का उपयोग करूँगा।

वही निर्माण किसी परिमित क्षेत्र के लिए काम करता है। हम जानते हैं कि qअगर q=p^kकोई प्राइम पावर है तो ऑर्डर का एक परिमित क्षेत्र है । उस क्षेत्र को कहा जाता है GF(p^k)जो "गैलोज़ फील्ड" के लिए खड़ा है। प्राइम पावर केस में फ़ील्ड बनाना उतना आसान नहीं है, जितना वे प्राइम केस में हैं।

सौभाग्य से, कड़ी मेहनत पहले से ही किया गया है और मुफ्त सॉफ्टवेयर, अर्थात् ऋषि में लागू किया गया है । उदाहरण के लिए, ऑर्डर 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]]>

मैं ऊपर दिए गए तरीके से व्याख्या करता हूं: 0 से 20 तक लेबल वाली 21 तस्वीरें हैं। प्रत्येक ब्लॉक (प्रॉजेक्ट ज्योमेट्री में लाइन) मुझे बताता है कि कार्ड पर कौन सी तस्वीरें दिखाई देती हैं। उदाहरण के लिए, पहले कार्ड में 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]]>

Answer 5

मुझे सिर्फ ५ or या ५ to तस्वीरों के साथ ऐसा करने का एक तरीका मिला है, लेकिन अब मुझे बहुत बुरा सिरदर्द है, मैं sle-१० घंटे में रूबी कोड पोस्ट करूँगा जब मैं अच्छी तरह से सो गया! सिर्फ एक संकेत मेरा मेरा समाधान हर 7 कार्ड एक ही निशान साझा करते हैं और मेरे समाधान का उपयोग करके कुल 56 कार्ड बनाए जा सकते हैं।

यहां वह कोड है जो सभी 57 कार्डों को उत्पन्न करता है जो कि ypercube के बारे में बात कर रहे थे। यह वास्तव में 57 चित्रों का उपयोग करता है, और माफ करना, मैंने वास्तविक C ++ कोड लिखा है, लेकिन यह जानते हुए कि vector <something>एक सरणी प्रकार है जिसमें somethingयह समझना आसान है कि यह कोड क्या करता है। और यह कोड प्रत्येक प्राइम पी वैल्यू के लिए, प्रत्येक चित्र वाले चित्रों P^2+P+1का उपयोग करके और सामान्य रूप से केवल 1 चित्र साझा करने के लिए कार्ड बनाता है । जिसका अर्थ है कि हमारे पास 7 चित्रों का उपयोग करके 7 कार्ड हो सकते हैं, जिनमें से प्रत्येक में 3 चित्र (p = 2 के लिए), 13 कार्ड का उपयोग करते हुए 13 चित्र (p = 3 के लिए), 31 कार्ड का उपयोग करते हुए 31 चित्र (p = 5 के लिए), 57 चित्रों के लिए 57 कार्ड हैं (पी = 7 के लिए) और इसी तरह ...P^2+P+1P+1

#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();
    }
}

विलंबित कोड के लिए फिर से खेद है।

Comments

मेरे पास इसका एक सुंदर प्रमाण है, लेकिन अफसोस कि यह टिप्पणी बॉक्स इसे शामिल करने के लिए बहुत छोटा है।

— sarnold

@ गजीत: क्या आपने इसे चलाया p=4? (और 21 कार्ड / चित्र)

— ypercube

4 मेरे एल्गोरिथ्म में काम नहीं करता है क्योंकि 4 एक अभाज्य संख्या नहीं है, मेरे एल्गोरिथ्म में यह महत्वपूर्ण है कि पी प्रमुख होना चाहिए।

— अली

@ypercube की फिर से जाँच करने के बाद मेरे एल्गोरिथ्म में कुछ छोटी गलतियाँ थीं, लेकिन मैंने इसे 2, 3,5,7 के लिए जाँचा और मैं किसी भी अन्य प्राइम नंबर के लिए यह साबित कर सकता हूँ कि यह काम करेगा, इसलिए यहाँ मेरा पूरा कोड है (लेकिन c ++ में)

— अली 1 एस 232

@ गजेट: शांत समाधान! अब मुझे लगता है कि मेरे लालची एल्गोरिथ्म ने हमेशा सबसे अच्छा समाधान क्यों नहीं पैदा किया।

— थिस हाइडेक

Answer 6

यहां पायथन में गजेट का समाधान है, क्योंकि मुझे पायथन अधिक पठनीय लगता है। मैंने इसे संशोधित किया है ताकि यह गैर-अभाज्य संख्याओं के साथ भी काम करे। मैंने कुछ और आसानी से समझे जाने वाले प्रदर्शन कोड उत्पन्न करने के लिए 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)

आउटपुट के साथ:

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

Comments

मुझे लगता है कि आपके उदाहरण में अंतिम तीन कार्ड मान्य नहीं हैं, क्योंकि वे पांचवें कार्ड के साथ एक तस्वीर साझा नहीं करते हैं। महज एक घंटे से अधिक पहले मैंने अपने कोड की जांच की, मुझे यह महसूस हुआ :) दिलचस्प बात यह है कि ऐसा लगता है कि एक कानूनी कार्डसेट का अधिकतम आकार प्रति कार्ड 4 चित्रों के लिए 5 है और चुनने के लिए अधिक चित्रों के साथ भी नहीं बढ़ता है।

— थिएस हेकडे

@ गजट कोड का उपयोग करके मैंने जो आरेख बनाया है, उसके साथ यह देखना बहुत आसान है कि वास्तव में (p) + (p * p) + (1)कॉन्फ़िगरेशन क्यों हैं ।

— नील जी

@ नील: अद्यतन आरेख के लिए धन्यवाद, यह देखना बहुत आसान है कि गजेट का समाधान कैसे काम करता है!

— थिस हेदेके

@ गजीत: मुझे लगता है कि आप गलत हैं all p except 4 and 6। यदि आप एक परिमित विमान का उत्पादन करना चाहते हैं जहाँ p*p+p+1बिंदु और रेखाएँ (कार्ड और चित्र) हैं, तो यह संबंधित है finite fieldsऔर नहीं rings। pजब पी primeया ए के क्रम के परिमित क्षेत्र होते हैं prime power। आपका कोड primes के लिए सही तरीके से काम करता है क्योंकि अभिव्यक्ति की तरह गुणन क्रम के क्रम में गुणा और जोड़ के रूप में व्यक्त k * p + (j + i * k) % pकर रहे हैं । k*p + j + i*kp

— ypercube y

यह बहुत, प्रधानमंत्री शक्तियों के लिए सही ढंग से कार्य करेगा जब आप आदेश के परिमित क्षेत्रों में इन आपरेशनों (। Mult और इसके अलावा) व्यक्त कर सकते हैं p^2, p^3आदि तो, इसके लिए काम करेंगे4, 8, 9, 16, 25, 27, ...

— ypercubeᵀᴹ

Answer 7

का उपयोग करते हुए 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.>

Answer 8

मुझे यह धागा बहुत पसंद है। मैं इस कोड के कुछ हिस्सों के साथ इस github python प्रोजेक्ट का निर्माण करता हूं, ताकि कस्टम कार्ड को png के रूप में आकर्षित किया जा सके (ताकि कोई व्यक्ति इंटरनेट में कस्टम कार्ड गेम ऑर्डर कर सके)।

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

Answer 9

मैंने पर्ल में कोड के साथ इस तरह के डेक को कैसे उत्पन्न किया जाए, इसके बारे में एक लेख लिखा था । कोड को ऑप्टिमाइज़ नहीं किया गया है लेकिन यह कम से कम "उचित" ऑर्डर ... और कुछ और के डेक उत्पन्न करने में सक्षम है।

यहां ऑर्डर 8 के साथ एक उदाहरण दिया गया है, जिसमें कुछ अधिक जटिल अंतर्निहित गणित पर विचार करना होगा, क्योंकि 8 इस तरह के डेक को उत्पन्न करने के लिए एक वैध आदेश नहीं है। ऊपर या अधिक विस्तृत विवरण के लिए लेख देखें, नीचे यदि आप थोड़ा और अधिक कठिन स्पॉट-इट बनाना चाहते हैं तो :-)

$ 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, ..., 59, और 68।