Compare commits

...

18 Commits

Author SHA1 Message Date
fc93178303 Nettoyage 2022-01-24 22:22:40 +01:00
e4b517168a Fonction "Pattern" 2022-01-24 22:15:17 +01:00
e2452c1434 Fonction "Bad Letters" 2022-01-24 21:46:06 +01:00
f9cf15d487 Fonction "Know Letters" 2022-01-24 21:05:06 +01:00
758d6bb0bb Nettoyage 2022-01-24 20:21:54 +01:00
cb17864265 Fonction "First Try" 2022-01-24 20:16:31 +01:00
0a8c29de74 Réorganisation du code 2022-01-24 19:44:49 +01:00
8b9175454b Ajout de l'option "no double" 2022-01-24 19:30:24 +01:00
ebea271d49 Préparation pour l'affichage des résultats 2022-01-24 19:05:38 +01:00
90aab55b75 Simplification de l'argument du nombre de lettre 2022-01-24 18:51:54 +01:00
1563e1bf1d Fonction pour charger le dictionnaire et début de mise en forme du programme 2022-01-24 18:50:29 +01:00
5e60b32352 Fonction pour la longueur du mot 2022-01-24 18:39:40 +01:00
ba5600e65f Fonction pour la première lettre 2022-01-24 18:33:52 +01:00
78586d42f0 Simplification du argparse 2022-01-24 17:31:21 +01:00
b6f5850b84 Comme l'on a des arguments obligatoires, pas de besoin de vérifier s'il y en a. 2022-01-24 16:56:04 +01:00
9dbc9fc89d Ouvre le dictionnaire avec un 'with statement' 2022-01-24 16:52:59 +01:00
57c87fe986 import os : pas besoin 2022-01-24 16:48:38 +01:00
971f078ee2 Python3 2022-01-24 16:47:29 +01:00

View File

@ -1,242 +1,198 @@
#!/usr/bin/env python #!/usr/bin/env python3
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
import os
import sys
import json import json
import argparse import argparse
parser = argparse.ArgumentParser(
description='Cheating with SUTOM'
)
parser.add_argument(
'-d',
'--dictionary',
help='Dictionnaire des mots du jeu',
required=True
)
parser.add_argument(
'-fl',
'--firstLetter',
help='Première lettre',
required=True
)
parser.add_argument(
'-nb',
'--nbLetters',
type=int,
help='Nombre de lettres, un entier',
required=True
)
parser.add_argument(
'-kl',
'--knownLetters',
help='Lettres connues, hors première, sans espaces : -kl BE'
)
parser.add_argument(
'-bl',
'--badLetters',
help='Lettres non valides, sans espaces : -bl AKL'
)
parser.add_argument(
'-p',
'--pattern',
help='Placement, avec des "." pour les inconnues : -p A...T.I.'
)
parser.add_argument(
'-nd',
'--noDoubleLetters',
help="Option pour ne chercher que des mots ne contenant qu'une occurence de chaque lettre",
action="store_true"
)
parser.add_argument(
'-ft',
'--firstTry',
type=int,
help="Sélectionne des mots commençants par firstLetter et composés de ft voyelles différentes: -ft 4",
)
if not len(sys.argv) > 1: def load_dict(dict_file):
print("-h or --help pour afficher l'aide") try:
exit(1) with open(dict_file, "r") as dico:
liste = json.load(dico)
args = parser.parse_args() return liste
except Exception as error:
# Dictionary print(f"Impossible d'ouvrir le fichier {dict_file} : {error}")
if args.dictionary:
fp = args.dictionary
try :
f = open(fp)
liste = json.load(f)
except:
print("Impossible d'ouvrir le fichier" + fp)
# First Letter
if args.firstLetter:
fl = args.firstLetter
else:
fl = False
# Nbr Letters
if args.firstLetter:
nb = args.nbLetters
else:
nbLetters = False
# Pattern
if args.pattern:
pattern = args.pattern
if args.nbLetters and len(pattern) != nb:
print("Tu as merdé ta pattern petit scarabé !")
exit(2) exit(2)
else:
pattern = False
# Known Letters
if args.knownLetters:
kl = args.knownLetters
else:
kl = False
# Bad Letters
if args.badLetters:
bl = args.badLetters
else:
bl = False
# No Double
if args.noDoubleLetters:
nd = True
else: nd = False
# First Try
if args.firstTry:
ft = args.firstTry
else: ft = False
patternFilter = []
klFilter = []
blFilter = []
ftFilter = []
# Fonction d'élimination de mots contenant plusieurs occurences de lettres
def noDouble(mots): def noDouble(mots):
# Fonction d'élimination de mots contenant plusieurs occurences de lettres
ndList = [] ndList = []
for mot in mots: for mot in mots:
llist = [] llist = []
for l in mot: for lettre in mot:
if not l in llist: if lettre not in llist:
llist.append(l) llist.append(lettre)
if len(mot) == len(llist): if len(mot) == len(llist):
ndList.append(mot) ndList.append(mot)
return(ndList) return(ndList)
# First Try : sélectionne des mots ayant des chances de valider ou invalider des voyelles
def firstTryFilter(mots, ft): def firstTryFilter(mots, max_mots):
vLetters = ['A', 'E', 'I', 'O', 'U', 'Y'] '''
First Try : sélectionne des mots ayant des chances de valider ou invalider
l'une des lettres les plus utilisée en français
'''
bestLetters = ['E', 'A', 'I', 'R', 'S', 'N', 'T', 'O', 'L', 'U']
bestWords = [] bestWords = []
for mot in mots: for mot in mots:
vCount = 0 for bestLetter in bestLetters:
for l in mot: if bestLetter in mot:
if l in vLetters: bestWords.append(mot)
vCount +=1 bestWords = list(set(bestWords))
if vCount >= ft: bestWords = noDouble(bestWords) # Autant maximiser les chances
bestWords.append(mot) bestWords = bestWords[0:max_mots]
return(bestWords) return(bestWords)
# Fonction de comparaison des lettres d'un mot, avec celle de la pattern
# Plus nécessaire actuellement mais peut être dans une prochaine vie def resolv_fl(liste, firstletter):
''' # On ne garde que les mots qui commence par FirstLetter
def patternCheck(pattern, mot, l): return [mot for mot in liste if mot[0] == firstletter]
goodPosCounter = 0
for pos in range(len(pattern)):
print("Checking : " + l + "against : " + pattern[pos] + " and " + mot[pos]) def resolv_len(liste, lenght):
if pattern[pos] == l and mot[pos] == l: # On ne garde que les mots qui ont la bonne longueur
goodPosCounter +=1 return [mot for mot in liste if len(mot) == lenght]
print("checked")
if goodPosCounter == pattern.count(l):
return(0) def resolv_pattern(liste, pattern):
# Pattern : élimination des mots ne satisfaisant pas la pattern
pattern_dict = {}
for lettre in pattern:
if lettre != ".":
pattern_dict.update({pattern.index(lettre): lettre})
MotsOK, MotsKO = [], []
for mot in liste:
for key in pattern_dict:
if mot[key] == pattern_dict[key]:
MotsOK.append(mot)
else:
MotsKO.append(mot)
liste = [mot for mot in MotsOK if mot not in MotsKO]
liste = list(set(liste))
return liste
def resolv_kl(liste, lettres):
'''
Known Letters : élimination des mots ne comprenant pas
les lettres validées (hors pattern)
'''
lettres = list(set(list(lettres)))
MotsRestants = []
for mot in liste:
if len(set(lettres).intersection(mot)) == len(lettres):
MotsRestants.append(mot)
return MotsRestants
def resolv_bl(liste, lettres):
'''
Bad Letters : élimination des mots contenant
des lettres invalidées (hors pattern)
'''
lettres = list(set(list(lettres)))
MotsSuppr = []
for mot in liste:
for lettre in lettres:
if lettre in mot:
MotsSuppr.append(mot)
for mot in MotsSuppr:
try:
liste.pop(liste.index(mot))
except ValueError:
pass
return liste
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description='Cheating with SUTOM'
)
parser.add_argument(
'-d',
'--dictionary',
help='Dictionnaire des mots du jeu',
required=True
)
parser.add_argument(
'-fl',
'--firstLetter',
help='Première lettre',
default=False,
required=True
)
parser.add_argument(
'-nb',
'--nbLetters',
type=int,
help='Nombre de lettres, un entier',
default=False,
required=True
)
parser.add_argument(
'-kl',
'--knownLetters',
default=False,
help='Lettres connues, hors première, sans espaces : -kl BE'
)
parser.add_argument(
'-bl',
'--badLetters',
default=False,
help='Lettres non valides, sans espaces : -bl AKL'
)
parser.add_argument(
'-p',
'--pattern',
default=False,
help='Placement, avec des "." pour les inconnues : -p A...T.I.'
)
parser.add_argument(
'-nd',
'--noDoubleLetters',
help="Option pour ne chercher que des mots ne contenant qu'une occurence de chaque lettre",
default=False,
action="store_true"
)
parser.add_argument(
'-ft',
'--firstTry',
default=False,
type=int,
help="Sélectionne des mots commençants par firstLetter et composés de ft voyelles différentes: -ft 4",
)
args = parser.parse_args()
if args.pattern and args.nbLetters and len(args.pattern) != args.nbLetters:
print("Tu as merdé ta pattern petit scarabé !")
exit(2)
liste = load_dict(args.dictionary)
liste = resolv_len(liste, args.nbLetters)
liste = resolv_fl(liste, args.firstLetter)
if args.noDoubleLetters:
liste = noDouble(liste)
if args.firstTry:
liste = firstTryFilter(liste, args.firstTry)
if len(liste) == 1:
print(f"Essaie : \"{liste[0]}\"")
elif len(liste) > 1:
print(f"Mots à tester : {liste}")
else:
print("Hmmm... Je crois qu'on s'est perdu...")
exit(0)
if args.knownLetters:
liste = resolv_kl(liste, args.knownLetters)
if args.badLetters:
liste = resolv_bl(liste, args.badLetters)
if args.pattern:
liste = resolv_pattern(liste, args.pattern)
if len(liste) > 1:
print(liste)
print(f"Il y a {len(liste)} mots dans la liste")
elif len(liste) == 1:
print(f"La solution est \"{liste[0]}\".")
else: else:
return(1) print("Hmmm... Je crois qu'on s'est perdu...")
'''
# First Letter : élimination des mots ne commençant pas par FirstLetter
if fl:
goodFl = [mot for mot in liste if mot.startswith(fl)]
# Nb Lettres : élimination des mots n'ayant pas le bon nombre de lettres
if fl:
goodLen = [mot for mot in goodFl if len(mot) == nb]
else:
goodLen = [mot for mot in liste if len(mot) == nb]
# First Try
if ft:
bestWords = noDouble(firstTryFilter(goodLen, ft))
# Pattern : élimination des mots ne satisfaisant pas la pattern
if pattern:
patternCount = len(pattern) - pattern.count(".")
for mot in goodLen:
patternEval = 0
for l in range(len(mot)):
if mot[l] == pattern[l]:
patternEval += 1
if patternEval == patternCount :
patternFilter.append(mot)
# Known Letters : élimination des mots ne comprenant pas les lettres validées (hors pattern)
if kl:
if patternFilter:
mots = patternFilter
else:
mots = goodLen
for mot in mots:
validate = 0
for l in kl:
if l in mot:
validate += 1
if validate == len(kl):
klFilter.append(mot)
# Bad Letters : élimination des mots contenant des lettres invalidées (hors pattern)
if bl:
if klFilter:
mots = klFilter
elif patternFilter:
mots = patternFilter
else:
mots = goodLen
for mot in mots:
invalidate = 0
for l in bl:
if l in mot and l in pattern:
if pattern.count(l) != mot.count(l):
invalidate += 1
elif l in mot:
invalidate += 1
if invalidate == 0:
blFilter.append(mot)
# Affiche du résultat
if pattern and kl and bl:
print(", ".join(blFilter))
print(str(len(blFilter)) + " mots dans la liste" )
elif pattern and kl:
print(", ".join(klFilter))
print(str(len(klFilter)) + " mots dans la liste" )
elif pattern:
print(", ".join(patternFilter))
print(str(len(patternFilter)) + " mots dans la liste" )
elif kl and bl:
print(", ".join(blFilter))
print(str(len(blFilter)) + " mots dans la liste" )
elif bl and pattern:
print(", ".join(blFilter))
print(str(len(blFilter)) + " mots dans la liste" )
elif ft:
print(", ".join(bestWords))
print(str(len(bestWords)) + " mots dans la liste" )
else:
print(", ".join(goodLen))
print(str(len(goodLen)) + " mots dans la liste" )