Avete mai sentito parlare di Dobble? Se avete bambini, scommetto di si! Ad ogni buon conto, si tratta di un gioco da tavolo per grandi e piccini basato sul pattern recognition, ovvero sulla capacità di riconoscere segni e modelli (in questo caso forme e colori) il più velocemente possibile. Il gioco presenta 55 carte, ciascuna delle quali presenta 8 diversi disegni disposti in ordine sparso. Il gioco è fatto in modo che ogni coppia di carte abbia un solo simbolo in comune, che i giocatori devono trovare nel più breve tempo possibile. Il gioco è uscito nel 2009 con il nome di Spot It!, mentre Dobble è un nome alternativo con cui è stato commercializzato in molti paesi europei (tra cui l'Italia, pubblicato dalla casa editrice Asmodee). Per maggiori informazioni, consigliamo di consultare la pagina del gioco su BoardGameGeek.com.

Se vi siete imbattuti in questo articolo, è probabile che abbiate interesse ad approfondire come hanno fatto i creatori del gioco a realizzare le carte di Dobble in modo tale che ciascuna di esse abbia sempre un (e un solo) simbolo in comune con tutte le altre. In questo articolo proveremo a illustrare questa tecnica, spiegando sinteticamente i principi su cui si basa, in modo da consentire a chiunque di poter creare una  sua versione personalizzata di Dobble.

Un problema "geometrico"

Come è facile intuire, si tratta di un risultato che è possibile ottenere mediante l'applicazione di un determinato algoritmo. Nello specifico, si tratta di una funzione per la generazione di serie geometriche combinatorie aventi seguenti caratteristiche: ciascuna serie deve essere composta da un determinato numero (N) di elementi diversi tra loro; ciascuna serie deve avere un (e un solo) elemento in comune con ciascuna altra serie; Nel caso di Dobble, ciascuna serie (la carta) è composta da 8 elementi (i simboli): N è dunque pari a 8. Sappiamo inoltre che il mazzo è composto da 55 carte. La nostra funzione dovrà quindi essere in grado di produrre almeno 55 serie, ciascuna delle quali composta da 8 elementi diversi tra loro e aventi 1 (e un solo) elemento in comune con ciascun'altra serie.

Il codice sorgente

Ecco la funzione JavaScript che può essere utilizzata per generare le serie, o per meglio dire le carte. Ovviamente, ciascun numero contenuto nelle varie serie ha il compito di rappresentare un elemento, o per meglio dire un simbolo, tra quelli presenti sulle nostre carte: il numero 1 corrisponderà al cuore, il numero 2 all'albero, e così via. // --------------------------------------------------------------------------- // Funzione che genera serie geometriche combinatorie per Dobble / Spot it! // // Ciascuna serie generata presenta le seguenti caratteristiche: // // - E' composta da N elementi diversi tra loro. // - Contiene sempre un elemento (e uno solo) in comune con le altre. // // Rilasciato su licenza GNU - General Public Licence v3.0 // https://www.gnu.org/liceNes/gpl-3.0.en.html // // Darkseal, 2018-2019 // https://www.ryadel.com/en/dobble-spot-it-algorithm-math-function-javascript // --------------------------------------------------------------------------- // function dobble() { var N = 8; // numero di simboli su ogni carta var nC = 0; // numero progressivo delle carte var sTot = ; // array da riempire con le serie // carte da #01 a #N for (i=0; i = width ? n : new Array(width - n.length + 1).join(z) + n; } E' possibile provare o modificare questa funzione su qualsiasi browser web utilizzando questo JSFiddle. Come si può vedere, la funzione effettua due cicli: il primo costruisce un numero di serie pari al numero degli elementi (N) mettendo in prima posizione l'elemento numero 1 e poi riempiendole con elementi in ordine crescente seguendo un percorso "orizzontale". In questo modo, si assicura che tutte le serie prodotte finora avranno l'elemento numero 1 (e soltanto quello) in comune. Questa operazione, come si può vedere dall'immagine, costruisce una matrice  che contiene tutti gli elementi.

Il secondo ciclo costruisce tutte le serie rimanenti mettendo in prima posizione gli elementi numero 2, 3, 4, 5 e così via (fino a N) e poi riempiendole con elementi in ordine crescente: stavolta, però, il percorso è sviluppato in "verticale", così da "incrociare" ciascuna serie generata durante il ciclo precedente una volta sola. Inutile dire che la prima serie, che contiene i primi 8 elementi, deve necessariamente essere "saltata", così da non creare possibili duplicati con gli elementi posti in prima posizione.

Da questo si evince anche che il numero di serie diverse tra loro che questo algoritmo è in grado di produrre è pari a N + (N-1) * (N-1). Nel caso di Dobble, in cui N è pari a 8, significa che possiamo avere fino a un massimo di 8 + (8-1)*(8-1) = 57 carte diverse, quindi ben 2 in più del numero di carte contenute nell'edizione italiana. Se i simboli su ogni carta fossero 9, potremmo quindi avere fino a 73 carte diverse; se fossero 10, potremmo averne fino a 91: e così via.

Conclusioni

Have you ever heard of Dobble? If you have children, I bet you did! Anyway, it's a pattern recognition board game for children (but also great for all ages) where the players must idenfity common shapes across multiple cards as quickly as possible. The game has 55 cards, each of which presents 8 different shapes arranged in random order. The game is made so that each pair of cards has one (and only one) shape in common, which players must find as soon as possible. The game was released in 2009 under the name Spot it!, while Dobble is an alternative market name mostly used in European countries (including Italy, where it was published by Asmodee around 2013). For more information about this game, we strongly advise to take a look at its page on the BoardGameGeek community website.

If you came across this article, it most likely means that you're interested in learning more about how the game's creators managed to made Dobble cards so that each of them always has one (and only) shape in common with all the others. In this article we'll try to understand how they did that thanks to a lightweight JavaScript function that can be used to achieve the same result, even with a different number of cards and/or symbols. Such function could also be used by anyone to create their own customized version of Dobble.

A "geometric" problem

As you can easily imagine, the underlying logic that determines the set of shapes printed on each card is the result of an algorithm of some sort. More specifically, such assignment logic can be calculated with a function able to generate combinatorial geometric series with the following characteristics: each series must have a specific number (N) of different element (taken from a common element pool); each series must have one (and only one) element in common with each other series; In the case of Dobble, each series (the card) is composed of 8 elements (the shapes): N is therefore equal to 8. We also know that the deck is made of 55 cards. Therefore, our function must be able to produce (at least) 55 different series with 8 internally-different elements and 1 (and only one) element in common with any other card.

The source code

Here's a small JavaScript function that can be used to generate the series, or rather the cards. Obviously, each number contained in the various series has the task of representing a unique shape among those present on our cards: the number 1 for the heart, the number 2 for the tree, and so on. For the sake of simplicity, we won't make the numbers-to-shapes mapping in this post, being it a rather trivial task. // --------------------------------------------------------------------------- // JavaScript function to generate combinatorial geometric series // for board games like Dobble / Spot it! // // Each generated series is expected to have the following features: // // - a specific number (N) of different element; // - one (and only one) element in common with each other series; // // Released on GNU - General Public Licence v3.0 // https://www.gnu.org/liceNes/gpl-3.0.en.html // // Darkseal, 2018-2019 // https://www.ryadel.com/en/dobble-spot-it-algorithm-math-function-javascript // --------------------------------------------------------------------------- // function dobble() { var N = 8; // numero di simboli su ogni carta var nC = 0; // numero progressivo delle carte var sTot = ; // array da riempire con le serie // carte da #01 a #N for (i=0; i = width ? n : new Array(width - n.length + 1).join(z) + n; } To try this function and/or change its values to generate different series, check out this JSFiddle. As we can see, the function performs two cycles: the first constructs a serial number equal to the number of elements (N) by placing the element number 1 in the first position and then filling them with the other elements in ascending order by following a horizontal progression (from left to right); such logic will make sure that all series produced so far will have the element number 1 (and only that one) in common. This operation, as can be seen from the image, also constructs a matrix that contains all the elements.

The second cycle builds all the remaining series by placing the elements number 2, 3, 4, 5 and so on (up to N) in the first position and then filling them with the other elements in ascending order: however, this time the progression develops vertically (from top to bottom), thus ensuring that all the series generated during the first cycle will be "crossed" only once. It goes without saying that the first series must be skipped by such progression, since it contains the first 8 elements which are used as "first position" by all the other series.

By looking at the above processes, we can easily understand how the maximum number of different series that this function can produce is equal to N + (N-1) * (N-1). In the case of Dobble, where N is equal to 8, it means that we can have up to a maximum of 8 + (8-1) * (8-1) = 57 different cards: that's 2 more than the number of cards contained in the Italian edition! If the shapes on each card were  10, we could have up to 91; if they were 12, up to 133; and so on.

Conclusion