wgamesolv.py

@@ -4,19 +4,103 @@
 import json
 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',
+    default=False,
+    required=True
+)
+parser.add_argument(
+    '-nb',
+    '--nbLetters',
+    type=int,
+    help='Nombre de lettres, un entier',
+    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",
+)
 
-def load_dict(dict_file):
+args = parser.parse_args()
+
+# Dictionary
+if args.dictionary:
     try :
-        with open(dict_file, "r") as dico:
+        with open(args.dictionary, "r") as dico:
             liste = json.load(dico)
-        return liste
     except:
         print("Impossible d'ouvrir le fichier" + fp)
+
+# First letter
+fl = args.firstLetter
+
+# Nbr Letters
+if args.firstLetter:
+    nb = args.nbLetters
+else:
+    nbLetters = False
+
+# Pattern
+pattern = args.pattern
+if 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
+
+patternFilter = []
+klFilter = []
+blFilter = []
+ftFilter = []
+
+# Fonction d'élimination de mots contenant plusieurs occurences de lettres
 def noDouble(mots):
-    # Fonction d'élimination de mots contenant plusieurs occurences de lettres
     ndList = []
     for mot in mots:
         llist = []
@@ -27,20 +111,17 @@ def noDouble(mots):
             ndList.append(mot)
     return(ndList)
 
-def firstTryFilter(mots, max_mots):
+# First Try : sélectionne des mots ayant des chances de valider ou invalider des voyelles
-    '''
+def firstTryFilter(mots, ft):
-    First Try : sélectionne des mots ayant des chances de valider ou invalider
+    vLetters = ['A', 'E', 'I', 'O', 'U', 'Y']
-    l'une des lettres les plus utilisée en français
-    '''
-    bestLetters = ['E', 'A', 'I', 'R', 'S', 'N', 'T', 'O', 'L', 'U']
     bestWords = []
     for mot in mots:
-        for bestLetter in bestLetters:
+        vCount = 0
-            if bestLetter in mot:
+        for l in mot:
+            if l in vLetters:
+                vCount +=1
+        if vCount >= ft:
             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
@@ -59,156 +140,83 @@ def patternCheck(pattern, mot, l):
         return(1)
 '''
 
-def resolv_fl(liste, firstletter):
+# First Letter : élimination des mots ne commençant pas par FirstLetter
-    # On ne garde que les mots qui commence par FirstLetter
+if fl:
-    return [mot for mot in liste if mot[0] == firstletter]
+    goodFl = [mot for mot in liste if mot.startswith(fl)]
-
-
-def resolv_len(liste, lenght):
-    # On ne garde que les mots qui ont la bonne longueur
-    return [mot for mot in liste if len(mot) == lenght]
 
+# 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:
+if ft:
-#    bestWords = noDouble(firstTryFilter(goodLen, ft))
+    bestWords = noDouble(firstTryFilter(goodLen, ft))
 
 # Pattern : élimination des mots ne satisfaisant pas la pattern
-#if pattern:
+if pattern:
-#    patternCount = len(pattern) - pattern.count(".")
+    patternCount = len(pattern) - pattern.count(".")
-#    for mot in goodLen:
+    for mot in goodLen:
-#        patternEval = 0
+        patternEval = 0
-#        for l in range(len(mot)):
+        for l in range(len(mot)):
-#            if mot[l] == pattern[l]:
+            if mot[l] == pattern[l]:
-#                patternEval += 1
+                patternEval += 1
-#        if patternEval == patternCount :   
+        if patternEval == patternCount :   
-#            patternFilter.append(mot)
+            patternFilter.append(mot)
-#
+
 # Known Letters : élimination des mots ne comprenant pas les lettres validées (hors pattern)
-#if kl:
+if kl:
-#    if patternFilter:
+    if patternFilter:
-#        mots = patternFilter
+        mots = patternFilter
-#    else:
+    else:
-#        mots = goodLen
+        mots = goodLen
-#    for mot in mots:
+    for mot in mots:
-#        validate = 0
+        validate = 0
-#        for l in kl:
+        for l in kl:
-#            if l in mot:
+            if l in mot:
-#                validate += 1
+                validate += 1
-#        if validate == len(kl):
+        if validate == len(kl):
-#            klFilter.append(mot)
+            klFilter.append(mot)
 
 # Bad Letters : élimination des mots contenant des lettres invalidées (hors pattern)
-#if bl:
+if bl:
-#    if klFilter:
+    if klFilter:
-#        mots = klFilter
+        mots = klFilter
-#    elif patternFilter:
+    elif patternFilter:
-#        mots = 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)
-
-
-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(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)
-    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...")
+        mots = goodLen
-        exit(0)
+    for mot in mots:
-    if len(liste) > 1:
+        invalidate = 0
-        print(liste)
+        for l in bl:
-        print(f"Il y a {len(liste)} mots dans la liste")
+            if l in mot and l in pattern:
-    elif len(liste) == 1:
+                if pattern.count(l) != mot.count(l):
-        print(f"La solution est \"{liste[0]}\".")
+                    invalidate += 1
-    else:
+            elif l in mot:
-        print("Hmmm... Je crois qu'on s'est perdu...")
+                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" )