Quels sont les principes mathématiques / informatiques derrière ce jeu?

Géomésortinges projectives finies

Les axiomes de la géomésortinge projective (plane) sont légèrement différents de la géomésortinge euclidienne:

• Chaque deux points ont exactement une ligne qui les traverse (c’est la même chose).
• Toutes les deux lignes se rencontrent exactement en un point (c’est un peu différent d’Euclid).

Maintenant, ajoutez “fini” dans la soupe et vous avez la question:

Peut-on avoir une géomésortinge avec seulement 2 points? Avec 3 points? Avec 4? Avec 7?

Il y a encore des questions ouvertes sur ce problème mais nous le soaps:

• S’il existe des géomésortinges avec des points Q , alors Q = n^2 + n + 1 et n est appelé l’ order de la géomésortinge.
• Il y a n+1 points dans chaque ligne.
• De chaque point, passez exactement n+1 lignes.

• Le nombre total de lignes est également Q

• Et enfin, si n est premier, alors il existe une géomésortinge d’ordre n .

Qu’est-ce que cela a à voir avec le puzzle, on peut se demander.

Mettez la card au lieu du point et de l’ picture au lieu de la line et les axiomes deviennent:

• Chaque deux cartes ont exactement une image en commun.
• Pour chaque deux images, il y a exactement une carte qui a les deux.

Prenons maintenant n=7 et nous avons la géomésortinge finie d’ order-7 avec Q = 7^2 + 7 + 1 . Cela fait que Q=57 lignes (images) et Q=57 points (cartes). Je suppose que les créateurs de casse-tête ont décidé que 55 est plus le numéro rond que 57 et a laissé 2 cartes dehors.

Nous obtenons également n+1 = 8 , donc de chaque point (carte), 8 lignes passent (8 images apparaissent) et chaque ligne (image) a 8 points (apparaît en 8 cartes).

Voici une représentation du plan (géomésortinge) projectif fini (ordre 2) le plus célèbre avec 7 points, connu sous le nom de Fano Plane , copié de Noelle Evans – Page Problème de géomésortinge finie

Je pensais à créer une image expliquant comment le plan ci-dessus-2 pourrait être un puzzle similaire avec 7 cartes et 7 images, mais alors un lien de la question de math.exchange a exactement le même diagramme: Dobble-et- la-geomesortinge-finie

Il y a donc k = 55 cartes contenant m = 8 images chacune d’un pool de n images au total. Nous pouvons reformuler la question “Combien de photos avons-nous besoin, de sorte que nous puissions construire un ensemble de k cartes avec une seule image partagée entre deux paires de cartes?” de manière équivalente en demandant:

Étant donné un espace vectoriel à n dimensions et l’ensemble de tous les vecteurs, qui contiennent exactement m éléments égaux à un et à tous les autres zéro, la taille doit être telle que nous puissions trouver un ensemble de k vecteurs tous égaux à 1 ?

Il existe exactement ( n choisir m ) vecteurs possibles à partir desquels construire des paires. Nous avons donc au moins besoin d’un n assez grand pour que ( n choisisse m )> = k . Ceci est juste une limite inférieure, donc pour remplir la contrainte de compatibilité par paire, nous avons probablement besoin d’un n beaucoup plus élevé.

Juste pour expérimenter un peu, j’ai écrit un petit programme Haskell pour calculer des jeux de cartes valides:

Edit: Je viens de me rendre compte après avoir vu la solution de Neil et Gajet, que l’algorithme que j’utilise ne trouve pas toujours la meilleure solution possible, donc tout ce qui est en dessous n’est pas nécessairement valide. Je vais essayer de mettre à jour mon code bientôt.

 module Main where cardCandidates nm = cardCandidates' [] (nm) 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 xy = sum $ zipWith (*) xy compatible xy = dot xy == 1 compatibleCards = compatibleCards' [] compatibleCards' valid [] = valid compatibleCards' valid (c:cs) | all (compatible c) valid = compatibleCards' (c:valid) cs | otherwise = compatibleCards' valid cs legalCardSet nm = compatibleCards $ cardCandidates nm main = mapM_ print [(n, length $ legalCardSet nm) | n<-[m..]] where m = 8 

Le nombre maximum résultant de cartes compatibles pour m = 8 images par carte pour un nombre d'images différent à choisir parmi n pour les premiers n ressemble à ceci:

Cette méthode de force brute ne va pas très loin à cause de l'explosion combinatoire. Mais je pensais que cela pourrait encore être intéressant.

Il est intéressant de noter que pour m donné, k augmente avec n jusqu’à un certain n , après quoi il rest constant.

Cela signifie que pour chaque nombre d'images par carte, il existe un certain nombre d'images à choisir, ce qui entraîne un nombre maximum de cartes légales. Ajouter plus de photos pour choisir le nombre optimal ne fait pas augmenter le nombre de cartes légales.

Les premiers k optimaux sont:

Pour ceux qui ont du mal à imaginer la géomésortinge du plan projectif avec 57 points, il existe un moyen très agréable et intuitif de construire le jeu avec 57 cartes et 57 symboles (basé sur la réponse de Yuval Filmus à cette question ):

1. Pour les cartes avec 8 symboles, créez une grid 7×7 de symboles uniques.
2. Ajoutez 8 symboles supplémentaires pour les “pentes” de 0 à 6, plus un pour la pente à l’infini.
3. Chaque carte est une ligne sur la grid (7 symboles) plus un symbole de la pente définie pour la pente de la ligne. Les lignes ont un décalage (c.-à-d. Le sharepoint départ à gauche) et une pente (c.-à-d. Le nombre de symboles à monter pour chaque étape à droite). Lorsque la ligne quitte la grid en haut, entrez à nouveau en bas. Voir cet exemple de figure (images de boardgamegeek ) pour deux de ces cartes:

Dans l’exemple, je prends une ligne avec une pente nulle (rouge) et une avec une pente 1 (verte). Ils se croisent exactement à un point commun (le hibou).

Cette méthode garantit que deux cartes ont exactement un symbole commun, car

1. Si les pentes sont différentes, les lignes se croisent toujours exactement à un point.
2. Si les pentes sont identiques, les lignes ne se croisent pas et il n’y aura pas de symbole commun de la grid. Dans ce cas, le symbole de la pente sera le même.

De cette façon, nous pouvons construire des cartes 7×7 (7 compensations et 7 pentes).

Nous pouvons également construire sept cartes supplémentaires à partir de lignes verticales à travers la grid (c’est-à-dire en prenant chaque colonne). Pour ceux-là, l’icône de pente infini est utilisée.

Chaque carte étant composée de sept symboles de la grid et d’un symbole “pente”, nous pouvons créer une carte supplémentaire, qui consiste simplement en tous les 8 symboles de pente.

Cela nous laisse avec 7×8 + 1 = 57 cartes possibles, et 7 x 7 + 8 = 57 symboles requirejs.

(Naturellement, cela ne fonctionne qu’avec une grid en nombre premier (par exemple n = 7). Sinon, les lignes de différentes pentes pourraient avoir zéro ou plus d’une intersection si la pente est un diviseur de la taille de la grid.)

Je viens de trouver un moyen de le faire avec 57 ou 58 images mais maintenant j’ai un très gros mal de tête, je posterai le code ruby ​​dans 8-10 heures après avoir bien dormi! juste un indice ma solution toutes les 7 cartes partagent la même marque et un total de 56 cartes peuvent être construits en utilisant ma solution.

Voici le code qui génère les 57 cartes dont ypercube parlait. il utilise exactement 57 images, et désolé, j’ai écrit du code C ++, mais sachant que le vector est un tableau contenant des valeurs de type, il est facile de comprendre ce que fait ce code. et ce code génère P^2+P+1 cartes en utilisant P^2+P+1 images contenant chacune P+1 image et partageant seulement 1 image en commun, pour chaque valeur prime P. ce qui signifie que nous pouvons avoir 7 cartes utilisant 7 images ayant chacune 3 images (pour p = 2), 13 cartes utilisant 13 images (pour p = 3), 31 cartes utilisant 31 images (pour p = 5), 57 cartes pour 57 images (pour p = 7) et ainsi de suite …

 #include  #include  using namespace std; vector  > cards; void createcards(int p) { cards.resize(0); for (int i=0;i> p; p!=0;cin>> p) { createcards(p); checkCards(); } } 

encore une fois désolé pour le code retardé.

D’autres ont décrit le cadre général de la conception (plan projectif fini) et montré comment générer des plans projectifs finis d’ordre primordial. Je voudrais juste combler certaines lacunes.

Les plans projectifs finis peuvent être générés pour de nombreux ordres différents, mais ils sont plus simples dans le cas du premier ordre p . Les entiers modulo p forment alors un corps fini qui peut être utilisé pour décrire les coordonnées des points et des lignes du plan. Il existe trois types de coordonnées pour les points: (1,x,y) , (0,1,x) et (0,0,1) , où x et y peuvent prendre des valeurs de 0 à p-1 . Les 3 types de points différents expliquent la formule p^2+p+1 pour le nombre de points du système. Nous pouvons également décrire des lignes avec les 3 mêmes types de coordonnées: [1,x,y] , [0,1,x] et [0,0,1] .

Nous calculons si un point et une ligne sont incidents si le produit scalaire de leurs coordonnées est égal à 0 mod p . Ainsi par exemple le point (1,2,5) et la ligne [0,1,1] sont incidents lorsque p=7 puisque 1*0+2*1+5*1 = 7 == 0 mod 7 , mais le le point (1,3,3) et la ligne [1,2,6] ne sont pas incidents puisque 1*1+3*2+3*6 = 25 != 0 mod 7 .

Traduisant dans le langage des cartes et des images, cela signifie que la carte avec les coordonnées (1,2,5) contient l’image avec les coordonnées [0,1,1] , mais la carte avec les coordonnées (1,3,3) ne contient pas l’image avec les coordonnées [1,2,6] . Nous pouvons utiliser cette procédure pour développer une liste complète des cartes et des images qu’elles contiennent.

Au fait, je pense qu’il est plus facile de considérer les images comme des points et des cartes que comme des lignes, mais il existe une dualité dans la géomésortinge projective entre les points et les lignes, donc peu importe. Cependant, dans ce qui suit, j’utiliserai des points pour les images et des lignes pour les cartes.

La même construction fonctionne pour tout champ fini. On sait qu’il existe un corps fini q si et seulement si q=p^k , une puissance première. Le champ est appelé GF(p^k) qui signifie “champ de Galois”. Les champs ne sont pas aussi faciles à construire que dans le cas principal.

Heureusement, le travail acharné a déjà été effectué et implémenté dans des logiciels libres, à savoir Sage . Pour obtenir une conception de plan projectif d’ordre 4, par exemple, tapez simplement

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

et vous obtiendrez une sortie qui ressemble à

 ProjectiveGeometryDesign 

J’interprète ce qui suit comme suit: il y a 21 images étiquetées de 0 à 20. Chacun des blocs (ligne en géomésortinge projective) me dit quelles images apparaissent sur une carte. Par exemple, la première carte aura les images 0, 1, 2, 3 et 20; la deuxième carte aura les images 0, 4, 8, 12 et 16; etc.

Le système d’ordre 7 peut être généré par

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

qui génère la sortie

 ProjectiveGeometryDesign 

Voici la solution de Gajet en Python, car je trouve Python plus lisible. Je l’ai modifié pour qu’il fonctionne également avec des nombres non premiers. J’ai utilisé les connaissances de Thies pour générer un code d’affichage plus facile à comprendre.

 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) 

Avec sortie:

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

Utilisation du prouveur de théorème z3

Soit P le nombre de symboles par carte. Selon cet article et la réponse de ypercubeᵀᴹ , il y a respectivement N = P**2 - P + 1 cartes et symboles. Un jeu de cartes peut être représenté avec sa masortingce d’incidence qui comporte une ligne pour chaque carte et une colonne pour chaque symbole possible. Son élément (i,j) est 1 si la carte i a le symbole j . Il suffit de remplir cette masortingce en tenant compte de ces contraintes:

• chaque élément est zéro ou un
• la sum de chaque ligne est exactement P
• la sum de chaque colonne est exactement P
• deux lignes doivent avoir exactement un symbole en commun

Cela signifie que N**2 variables et N**2 + 2*N + (N choose 2) contraintes. Il semble être gérable dans peu de temps avec z3 pour les petites entrées.

edit : Malheureusement, P = 8 semble être trop grand pour cette méthode. J’ai tué le processus après 14 heures de temps de calcul.

 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 masortingx 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 masortingx 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_masortingx = spotit_z3(symbols_per_card) for row in incidence_masortingx: print(row) 

Résultats

 $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  

J’aime beaucoup ce fil. Je construis ce projet pithon github avec des parties de ce code ici pour dessiner des cartes personnalisées en png (on peut donc commander des jeux de cartes personnalisés sur Internet).

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

J’ai écrit un article sur la façon de générer ce type de deck, avec le code en Perl. Le code n’est pas optimisé mais il est au moins capable de générer des paquets d’ordres “raisonnables” … et d’autres encore.

Voici un exemple avec l’ordre 8, qui doit prendre en compte un calcul sous-jacent un peu plus compliqué, car 8 n’est pas un nombre premier bien qu’il s’agisse d’un ordre valide pour générer ce type de decks. Voir ci-dessus ou l’article pour une explication plus détaillée, ci-dessous si vous voulez juste générer un Spot-It légèrement plus difficile 🙂

 $ 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 

Chaque identifiant de 0 à 72 peut être lu à la fois comme identifiant de carte et comme identifiant d’image. Par exemple, la dernière ligne signifie que:

• la carte 72 contient les images 2 , 13 , 22 , …, 59 , 68 , ET
• l’image 72 apparaît dans les cartes 2 , 13 , 22 , …, 59 et 68 .