Générateur de cartes Dobble / SpotIt

15

introduction

Dobble / SpotIt est un jeu de cartes, où les gens doivent repérer le même symbole sur une paire de cartes dans les plus brefs délais, l'indiquer et passer à la paire suivante. Chaque carte a plusieurs symboles (8 en version normale), mais exactement un est commun à chaque paire de cartes.

Exemple d'une copie physique du jeu: Cartes avec des exemples de paires

Défi

Écrivez un programme qui, compte tenu de l'ensemble de symboles (caractères ascii simples) et du nombre de symboles sur une seule carte, produira des cartes de liste de sortie avec des symboles pour chaque carte. Il existe évidemment de nombreuses combinaisons équivalentes, votre programme n'a qu'à écrire l'une des combinaisons qui produit le plus grand nombre de cartes pour une entrée donnée.

C'est un code-golf, donc plus court le code, mieux c'est.

Il serait également formidable que le calcul se termine avant la mort thermique de l'univers pour le cas le plus compliqué.

Contribution

Deux arguments pour fonctionner / stdin (votre choix)

  • Le premier étant une collection de symboles, quelque chose comme «ABCDE» ou [«A», «B», «C», «D», «E»] - votre choix de format, que ce soit une chaîne, un ensemble, une liste, un flux , ou tout ce qui est idiomatique pour la langue de votre choix. Les caractères seront donnés à partir de l'ensemble de [A-Za-z0-9], pas de doublons (donc la taille maximale de l'ensemble de symboles d'entrée est 62). Ils ne seront pas nécessairement classés dans vous pouvez donc également obtenir "yX4i9A" pour le boîtier à 6 symboles).

  • Le deuxième argument est un entier, indiquant la quantité de symboles sur une seule carte. Ce sera <= que la taille du jeu de symboles.

Production

Imprimez plusieurs lignes séparées par des retours à la ligne, chacune d'entre elles contenant des symboles pour une seule carte.

Exemples

ABC
2
>>>>
AB
BC
AC

Ou

ABCDEFG
3
>>>>
ABC
BDE
CEF
BFG
AEG
CDG
ADF

Ou

ABCDE
4
>>>>
ABCD

Conseils

  • Le nombre de cartes produites ne peut pas être supérieur au nombre de symboles distincts et dans de nombreuses combinaisons, il sera considérablement plus petit
  • Vous voudrez peut-être lire un peu de fond en mathématiques si vous avez besoin d'aide avec le côté mathématique du problème

Ceci est mon premier défi de golf de code, alors veuillez pardonner les éventuels problèmes de formatage / style - je vais essayer de corriger les erreurs si vous les pointez dans les commentaires.

Artur Biesiadowski
la source
En relation
Peter Taylor
Cas de test suggéré ('abcdefghijklmnopqrstu', 5)-> ['abcde', 'afghi', 'ajklm', 'anopq', 'arstu', 'bfjnr', 'bgkpt', 'bhlou', 'bimqs', 'cfkqu', 'cgjos', 'chmpr', 'cilnt', 'dfmot', 'dglqr', 'dhkns', 'dijpu', 'eflps', 'egmnu', 'ehjqt', 'eikor']ou une autre solution de travail à 21 cartes. (Notez que c'est le plan fini projectif d'ordre 4).
Jonathan Allan

Réponses:

5

Python 2 , 192 162 octets

J'ai un argument selon lequel cela produit le jeu de cartes maximum pour chaque scénario et il gère les 3 cas de test.

from itertools import*
def m(a,s):
    C=["".join(x)for x in combinations(a,s)]
    while len(C):
        print C[0]
        C=list(set(A for A in C if len(set(A)&set(C[0]))==1<s))

Essayez-le en ligne!

Algorithme

Étant donné un alphabet aet une taille de carte s, prenez toutes les combinaisons d' séléments aet appelez-le C, puis:

  • Prenez le premier élément de C, appelez-leC0
  • sauvegarder C0
  • Supprimez tous les éléments Cdont l'union est différente C0de1
  • Répéter avec le deuxième élément de C
  • Continuez jusqu'à ce qu'il Csoit vide

Imprimez ensuite les éléments enregistrés.

Argument

Certains sous - ensemble non vide de Cnotre solution maximale, K. Puisqu'il contient au moins un élément et que deux éléments sont indiscernables, choisissez un élément arbitraire,, C0of Cto be in K. Pour tout élément ede la K, la cardinalité de l' eunion xest 1 pour x != ein K; Éliminez donc tous les éléments Cdont l'union avec C0n'a pas de cardinallité 1. Par le même raisonnement, choisissez un nouvel élément arbitraire dans C, ajoutez K-le et réduisez C. CEst finalement l'ensemble vide et Ksera la solution maximale car à aucun moment nous n'avons choisi un élément qui se distingue de tout autre élément.


Cas de test

Ces cas de test ont été écrits avant que je réalise que l'impression était une exigence.

a=["a","b","c"]
b=2
c=3
d=m(a,b)
print d,len(d)==c
>> ['bc', 'ab', 'ac'] True

a=["a","b","c","d","e","f","g"]
b=3
c=7
d=m(a,b)
print d,len(d)==c
>> ['aef', 'abc', 'bde', 'ceg', 'adg', 'cdf', 'bfg'] True

a=["a","b","c","d","e"]
b=4
c=1
d=m(a,b)
print d,len(d)==c
>> ['abcd'] True

Mise à jour

  • +9 [16-12-07] Ajuster l'exigence d'impression
  • -11 [16-12-07] J'ai joué ma Rvariable
  • -30 [16-12-09] J'ai joué à ma Kvariable grâce à @Leo !
Non linéaire
la source
1
Avez-vous vraiment besoin de soustraire l'ensemble K de C à chaque étape? Je pense que le filtrage que vous faites ( A for A in C if len(set(A)&set(C[0]))==1) supprime déjà les éléments choisis, à moins que s == 1 (dans ce cas, len (set (C [0]) & set (C [0])) soit 1). Vous pouvez jouer votre avant-dernière ligne sur:C=[A for A in C if len(set(A)&set(C[0]))==1<s]
Leo
Je rédigeais un défi Dobble dans le bac à sable et Dom Hastings m'a fait remarquer à cette question dupe possible ( ce qui pourrait bien être), mais une chose que je remarque est qu'il est beaucoup plus difficile de faire une plate - forme Dobble complète de N * N + N + 1 cartes (et symboles) avec N + 1 symboles par carte, N étant une puissance première non principale. Pour N = 4 = 2 ^ 2, ce serait un jeu utilisant 4 * 4 + 4 + 1 = 21 symboles et le même nombre de cartes; cependant, cette solution produit un jeu de 13 cartes seulement - mais 21 sont possibles .
Jonathan Allan,
@JonathanAllan vient d'ajouter un lien TIO. J'ai exécuté la fonction avec un alphabet de 21 caractères et avec 5 caractères par carte. Il a produit 21 cartes. Je pense que c'est correct, sauf si j'ai mal compris.
NonlinearFruit
Hmm, désolé, j'ai dû faire une erreur en l'exécutant localement alors! ( C'est un jeu complet d'ordre 4 ) :)
Jonathan Allan
2

Haskell, 175 156 octets

Ma première prise au golf, faites-moi savoir si j'ai foiré quelque chose.

import Data.List
f 0_=[[]]
f n a=g$c n a
c n a=[a!!i:x|i<-[0..(length a)-1],x<-f(n-1)(drop(i+1)a)]
g[]=[]
g(x:t)=x:g(filter(\z->length(z`intersect`x)<= 1)t)

Essayez-le en ligne!

Merci à @Paul Mutser pour l'amélioration et -19 octets


Version originale

Bugs
la source
1
Bienvenue chez PPCG! Notez que les importations comptent pour votre score. Amélioration possible: 156 octets, y compris l'importation
Paul Mutser
Merci pour l'avertissement, je ne savais pas si c'était le cas!
bugs