correction de mots avec espace en dernière lettre

README.md

@@ -1,16 +1,17 @@
 # wgamesolv
 
 Words Games Solver.    
-Script d'aide à la résolution des jeux de mots style wordle
+Script d'aide à la résolution des jeux de mots style Wordle, SUTOM, mots-croisés, Scrabble...     
+On a fait ça pour s'amuser, pas spécialement pour tricher aux jeux de mots.  
+Auteurs : AntoineVe et Brunus.  
+Courageux testeur des 1ères versions et précieux apporteur d'idées: DarKou.  
+Licence : MIT  
 
-Utilisation : wgamesolv.py -fl L -nb 7 (autres options)
+Utilisation : wgamesolv.py -d dictionnaire.json -nb 7 (autres options)
 
 -d, --dictionary : dictionnaire à utiliser  
-ex : -d SutomList.json  
+ex : -d fr_Fc.json  
-Les dictionnaires sont récupérables ici :  
+Trois dictionnaires ont été fusionnés pour n'en faire qu'un : Wordle, SUTOM et l'officiel du Scrabble  
-https://framagit.org/JonathanMM/sutom/-/blob/main/ts/mots/listeMotsProposables.ts  
-Et :  
-https://raw.githubusercontent.com/LouanBen/wordle-fr/main/mots.txt  
 
 -fl, --firstLetter : première lettre du mot  
 ex : -fl C  
@@ -22,7 +23,7 @@ ex : -nb 7
 -ft, --firstTry : optimise le premier essai en sortant les mots de -nb lettres, commençant par -fl lettre, ne contenant aucune lettre en plusieurs occurence et contenant -ft voyelles.  
 ex : -ft 4  
 Cette option peut être utilisée pour le tout premier essai, pour optimiser les chances d'avoir des lettres validées.  
-Cette option est ensuite inutile ou contre-productive pour les essais suivants.  
+Cette option est ensuite inutile ou contre-productive pour les essais suivants et ne peut pas être utilisée avec la pattern.  
 
 -nd, --noDoubleLetters : filtre les mots composé d'une seule occurence de chaque lettre.
 
@@ -32,7 +33,8 @@ ex : -kl AEP
 -bl, --badLetters : lettres déjà invalidées  
 ex : -bl ZTOR
 
--p, --pattern : lettres validées et bien placées, séparée par des '.' pour les lettres non validées  
+-p, --pattern : lettres validées et bien placées, lettres connues et mal placées, séparée par des '.' pour les lettres non validées  
-ex : -p L..I... (le mots était LUCIOLE)
+Les lettres en caps sont les lettres connues et bien placées, les lettres en minuscules sont les lettres connues mais mal placées    
+ex : -p L.uI... (le mots était LUCIOLE)
 
-Exemple complet : wgamesolv.py -d SutomList.json -nb 7 -fl L -p L..I... -kl E -bl AMNR
+Exemple complet : wgamesolv.py -d fr_FR.json -nb 7 -fl L -p L.uI... -kl U -bl AMNR

wgamesolv.py

@@ -3,15 +3,16 @@
 
 import json
 import argparse
+from random import shuffle
 
 
 def load_dict(dict_file):
-    try :
+    try:
         with open(dict_file, "r") as dico:
             liste = json.load(dico)
         return liste
-    except:
+    except Exception as error:
-        print("Impossible d'ouvrir le fichier" + fp)
+        print(f"Impossible d'ouvrir le fichier {dict_file} : {error}")
         exit(2)
 
 
@@ -19,48 +20,38 @@ def noDouble(mots):
     # Fonction d'élimination de mots contenant plusieurs occurences de lettres
     ndList = []
     for mot in mots:
-        llist = []
+        if len(list(mot)) == len(set(list(mot))):
-        for l in mot:
-            if not l in llist:
-                llist.append(l)
-        if len(mot) == len(llist):
             ndList.append(mot)
-    return(ndList)
+    return ndList
 
-def firstTryFilter(mots, max_mots):
+
+def firstTryFilter(mots, max_mots, pattern):
     '''
     First Try : sélectionne des mots ayant des chances de valider ou invalider
-    l'une des lettres les plus utilisée en français
+    l'une des lettres les plus utilisée en français.
     '''
-    bestLetters = ['E', 'A', 'I', 'R', 'S', 'N', 'T', 'O', 'L', 'U']
+    if pattern:
-    bestWords = []
+        return mots  # Inhibe le filtre si on utilise aussi un pattern
-    for mot in mots:
-        for bestLetter in bestLetters:
-            if bestLetter in mot:
-                bestWords.append(mot)
-            bestWords = list(set(bestWords))
-    bestWords = noDouble(bestWords)  # Autant maximiser les chances
-    bestWords = bestWords[0:max_mots]
-    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 patternCheck(pattern, mot, l):
-    goodPosCounter = 0
-    for pos in range(len(pattern)):
-        print("Checking : " + l + "against : " + pattern[pos] + " and " + mot[pos])
-        if pattern[pos] == l and mot[pos] == l:
-            goodPosCounter +=1
-            print("checked")
-    if goodPosCounter == pattern.count(l):
-        return(0)
     else:
-        return(1)
+        bestLetters = ['E', 'A', 'I', 'R', 'S', 'N', 'T', 'O', 'L', 'U']
-'''
+        bestWords = []
+        shuffle(mots)
+        mots = mots[:100]
+        for mot in mots:
+            for bestLetter in bestLetters:
+                if bestLetter in mot:
+                    bestWords.append(mot)
+                bestWords = list(set(bestWords))
+        bestWords_noDouble = noDouble(bestWords)  # Autant maximiser les chances
+        if len(bestWords_noDouble) > 0:
+            bestWords = bestWords_noDouble
+        bestWords = bestWords[:max_mots]
+        return bestWords
+
 
 def resolv_fl(liste, firstletter):
     # On ne garde que les mots qui commence par FirstLetter
+    firstletter = firstletter.upper()
     return [mot for mot in liste if mot[0] == firstletter]
 
 
@@ -69,53 +60,55 @@ def resolv_len(liste, lenght):
     return [mot for mot in liste if len(mot) == lenght]
 
 
-# First Try
+def resolv_pattern(liste, pattern):
-#if ft:
+    # Pattern : élimination des mots ne satisfaisant pas la pattern
-#    bestWords = noDouble(firstTryFilter(goodLen, ft))
+    pattern_dict, not_pattern_dict = {}, {}
+    for lettre in pattern:
+        if lettre != "." and lettre.isupper():
+            pattern_dict.update({pattern.index(lettre): lettre})
+        if lettre != "." and lettre.islower():
+            not_pattern_dict.update({pattern.index(lettre): lettre.upper()})
+    MotsOK, MotsKO = [], []
+    for mot in liste:
+        for key in pattern_dict:
+            if mot[key] == pattern_dict[key]:
+                MotsOK.append(mot)
+            else:
+                MotsKO.append(mot)
+        for key in not_pattern_dict:
+            if mot[key] == not_pattern_dict[key]:
+                MotsKO.append(mot)
+    MotsKO = set(MotsKO)
+    liste = [mot for mot in MotsOK if mot not in MotsKO]
+    liste = list(set(liste))
+    return liste
 
-# 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)
+def resolv_kl(liste, lettres):
-#if bl:
+    '''
-#    if klFilter:
+    Known Letters : élimination des mots ne comprenant pas
-#        mots = klFilter
+    les lettres validées (hors pattern)
-#    elif patternFilter:
+    '''
-#        mots = patternFilter
+    lettres = list(set(list(lettres.upper())))
-#    else:
+    MotsRestants = []
-#        mots = goodLen
+    for mot in liste:
-#    for mot in mots:
+        if len(set(lettres).intersection(mot)) == len(lettres):
-#        invalidate = 0
+            MotsRestants.append(mot)
-#        for l in bl:
+    return MotsRestants
-#            if l in mot and l in pattern:
+
-#                if pattern.count(l) != mot.count(l):
+
-#                    invalidate += 1
+def resolv_bl(liste, lettres):
-#            elif l in mot:
+    '''
-#                invalidate += 1
+    Bad Letters : élimination des mots contenant
-#        if invalidate == 0:
+    des lettres invalidées (hors pattern)
-#            blFilter.append(mot)
+    '''
+    lettres = list(set(list(lettres.upper())))
+    MotsSuppr = []
+    for mot in liste:
+        for lettre in lettres:
+            if lettre in mot:
+                MotsSuppr.append(mot)
+    return [mot for mot in liste if mot not in MotsSuppr]
 
 
 if __name__ == "__main__":
@@ -132,8 +125,7 @@ if __name__ == "__main__":
         '-fl',
         '--firstLetter',
         help='Première lettre',
-        default=False,
+        default=False
-        required=True
     )
     parser.add_argument(
         '-nb',
@@ -159,7 +151,7 @@ if __name__ == "__main__":
         '-p',
         '--pattern',
         default=False,
-        help='Placement, avec des "." pour les inconnues : -p A...T.I.'
+        help='Placement : bien placée en majuscule, mal placée en minuscule et non existante par un \'.\'. E.g. : Ra..e.T'
     )
     parser.add_argument(
         '-nd',
@@ -178,26 +170,24 @@ if __name__ == "__main__":
 
     args = parser.parse_args()
 
-    if args.pattern and args.nbLetters and len(pattern) != nb:
+    if args.pattern and args.nbLetters and len(args.pattern) != args.nbLetters:
         print("Tu as merdé ta pattern petit scarabé !")
         exit(2)
 
-    # Known Letters
-    kl = args.knownLetters
-    
-    # Bad Letters
-    bl = args.badLetters
-    
-    # First Try
-    ft = args.firstTry
-
     liste = load_dict(args.dictionary)
     liste = resolv_len(liste, args.nbLetters)
-    liste = resolv_fl(liste, args.firstLetter)
+    if args.firstLetter:
+        liste = resolv_fl(liste, args.firstLetter)
+    if args.pattern:
+        liste = resolv_pattern(liste, args.pattern)
     if args.noDoubleLetters:
         liste = noDouble(liste)
+    if args.knownLetters:
+        liste = resolv_kl(liste, args.knownLetters)
+    if args.badLetters:
+        liste = resolv_bl(liste, args.badLetters)
     if args.firstTry:
-        liste = firstTryFilter(liste, args.firstTry)
+        liste = firstTryFilter(liste, args.firstTry, args.pattern)
         if len(liste) == 1:
             print(f"Essaie : \"{liste[0]}\"")
         elif len(liste) > 1: