Fonction "First Try"

wgamesolv.py

@@ -4,103 +4,19 @@
 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",
-)
 
-args = parser.parse_args()
+def load_dict(dict_file):
-
-# Dictionary
-if args.dictionary:
     try :
-        with open(args.dictionary, "r") as dico:
+        with open(dict_file, "r") as dico:
             liste = json.load(dico)
+        return liste
     except:
         print("Impossible d'ouvrir le fichier" + fp)
+        exit(2)
 
-# 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 = []
@@ -111,17 +27,20 @@ def noDouble(mots):
             ndList.append(mot)
     return(ndList)
 
-# First Try : sélectionne des mots ayant des chances de valider ou invalider des voyelles
+def firstTryFilter(mots, max_mots):
-def firstTryFilter(mots, ft):
+    '''
-    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 = []
     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)
 
 # Fonction de comparaison des lettres d'un mot, avec celle de la pattern
@@ -140,83 +59,156 @@ def patternCheck(pattern, mot, l):
         return(1)
 '''
 
-# First Letter : élimination des mots ne commençant pas par FirstLetter
+def resolv_fl(liste, firstletter):
-if fl:
+    # On ne garde que les mots qui commence par FirstLetter
-    goodFl = [mot for mot in liste if mot.startswith(fl)]
+    return [mot for mot in liste if mot[0] == firstletter]
+
+
+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:
+#    else:
-        mots = goodLen
+#        mots = goodLen
-    for mot in mots:
+#    for mot in mots:
-        invalidate = 0
+#        invalidate = 0
-        for l in bl:
+#        for l in bl:
-            if l in mot and l in pattern:
+#            if l in mot and l in pattern:
-                if pattern.count(l) != mot.count(l):
+#                if pattern.count(l) != mot.count(l):
-                    invalidate += 1
+#                    invalidate += 1
-            elif l in mot:
+#            elif l in mot:
-                invalidate += 1
+#                invalidate += 1
-        if invalidate == 0:
+#        if invalidate == 0:
-            blFilter.append(mot)
+#            blFilter.append(mot)
 
-# Affiche du résultat  
+
-if pattern and kl and bl:
+if __name__ == "__main__":
-    print(", ".join(blFilter))
+    parser = argparse.ArgumentParser(
-    print(str(len(blFilter)) + " mots dans la liste" )
+        description='Cheating with SUTOM'
-elif pattern and kl:
+    )
-    print(", ".join(klFilter))
+    parser.add_argument(
-    print(str(len(klFilter)) + " mots dans la liste" )
+        '-d',
-elif pattern:
+        '--dictionary',
-    print(", ".join(patternFilter))
+        help='Dictionnaire des mots du jeu',
-    print(str(len(patternFilter)) + " mots dans la liste" )
+        required=True
-elif kl and bl:
+    )
-    print(", ".join(blFilter))
+    parser.add_argument(
-    print(str(len(blFilter)) + " mots dans la liste" )
+        '-fl',
-elif bl and pattern:
+        '--firstLetter',
-    print(", ".join(blFilter))
+        help='Première lettre',
-    print(str(len(blFilter)) + " mots dans la liste" )
+        default=False,
-elif ft:
+        required=True
-    print(", ".join(bestWords))
+    )
-    print(str(len(bestWords)) + " mots dans la liste" )
+    parser.add_argument(
-else:
+        '-nb',
-    print(", ".join(goodLen))
+        '--nbLetters',
-    print(str(len(goodLen)) + " mots dans la liste" )
+        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...")
+        exit(0)
+    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:
+        print("Hmmm... Je crois qu'on s'est perdu...")