wgamesolv.py

@@ -6,12 +6,12 @@ import argparse
 
 
 def load_dict(dict_file):
-    try:
+    try :
         with open(dict_file, "r") as dico:
             liste = json.load(dico)
         return liste
-    except Exception as error:
+    except:
-        print(f"Impossible d'ouvrir le fichier {dict_file} : {error}")
+        print("Impossible d'ouvrir le fichier" + fp)
         exit(2)
 
 
@@ -20,14 +20,13 @@ def noDouble(mots):
     ndList = []
     for mot in mots:
         llist = []
-        for lettre in mot:
+        for l in mot:
-            if lettre not in llist:
+            if not l in llist:
-                llist.append(lettre)
+                llist.append(l)
         if len(mot) == len(llist):
             ndList.append(mot)
     return(ndList)
 
-
 def firstTryFilter(mots, max_mots):
     '''
     First Try : sélectionne des mots ayant des chances de valider ou invalider
@@ -44,6 +43,21 @@ def firstTryFilter(mots, max_mots):
     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)
+'''
 
 def resolv_fl(liste, firstletter):
     # On ne garde que les mots qui commence par FirstLetter
@@ -55,54 +69,53 @@ def resolv_len(liste, lenght):
     return [mot for mot in liste if len(mot) == lenght]
 
 
-def resolv_pattern(liste, pattern):
+# First Try
-    # Pattern : élimination des mots ne satisfaisant pas la pattern
+#if ft:
-    pattern_dict = {}
+#    bestWords = noDouble(firstTryFilter(goodLen, ft))
-    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
 
+# 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)
 
-def resolv_kl(liste, lettres):
+# Bad Letters : élimination des mots contenant des lettres invalidées (hors pattern)
-    '''
+#if bl:
-    Known Letters : élimination des mots ne comprenant pas
+#    if klFilter:
-    les lettres validées (hors pattern)
+#        mots = klFilter
-    '''
+#    elif patternFilter:
-    lettres = list(set(list(lettres)))
+#        mots = patternFilter
-    MotsRestants = []
+#    else:
-    for mot in liste:
+#        mots = goodLen
-        if len(set(lettres).intersection(mot)) == len(lettres):
+#    for mot in mots:
-            MotsRestants.append(mot)
+#        invalidate = 0
-    return MotsRestants
+#        for l in bl:
-
+#            if l in mot and l in pattern:
-
+#                if pattern.count(l) != mot.count(l):
-def resolv_bl(liste, lettres):
+#                    invalidate += 1
-    '''
+#            elif l in mot:
-    Bad Letters : élimination des mots contenant
+#                invalidate += 1
-    des lettres invalidées (hors pattern)
+#        if invalidate == 0:
-    '''
+#            blFilter.append(mot)
-    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__":
@@ -165,10 +178,19 @@ if __name__ == "__main__":
 
     args = parser.parse_args()
             
-    if args.pattern and args.nbLetters and len(args.pattern) != args.nbLetters:
+    if args.pattern and args.nbLetters and len(pattern) != nb:
         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)
@@ -183,12 +205,6 @@ if __name__ == "__main__":
         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")