Nettoyage

wgamesolv.py

@@ -1,11 +1,111 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-import os
-import sys
 import json
 import argparse
 
+
+def load_dict(dict_file):
+    try:
+        with open(dict_file, "r") as dico:
+            liste = json.load(dico)
+        return liste
+    except Exception as error:
+        print(f"Impossible d'ouvrir le fichier {dict_file} : {error}")
+        exit(2)
+
+
+def noDouble(mots):
+    # Fonction d'élimination de mots contenant plusieurs occurences de lettres
+    ndList = []
+    for mot in mots:
+        llist = []
+        for lettre in mot:
+            if lettre not in llist:
+                llist.append(lettre)
+        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
+    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:
+            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)
+
+
+def resolv_fl(liste, firstletter):
+    # On ne garde que les mots qui commence par FirstLetter
+    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]
+
+
+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'
     )
@@ -19,6 +119,7 @@ parser.add_argument(
         '-fl',
         '--firstLetter',
         help='Première lettre',
+        default=False,
         required=True
     )
     parser.add_argument(
@@ -26,217 +127,72 @@ parser.add_argument(
         '--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",
     )
 
-if not len(sys.argv) > 1:
-    print("-h or --help pour afficher l'aide")
-    exit(1)
-
     args = parser.parse_args()
 
-# Dictionary
+    if args.pattern and args.nbLetters and len(args.pattern) != args.nbLetters:
-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)
-else:
-    pattern = False
 
-# Known Letters
+    liste = load_dict(args.dictionary)
-if args.knownLetters:
+    liste = resolv_len(liste, args.nbLetters)
-    kl = args.knownLetters
+    liste = resolv_fl(liste, args.firstLetter)
-else:
-    kl = False
-
-# Bad Letters
-if args.badLetters:
-    bl = args.badLetters
-else:
-    bl = False
-
-# No Double
     if args.noDoubleLetters:
-    nd = True
+        liste = noDouble(liste)
-else: nd = False
-
-# First Try
     if args.firstTry:
-    ft = args.firstTry
+        liste = firstTryFilter(liste, args.firstTry)
-else: ft = False
+        if len(liste) == 1:
-
+            print(f"Essaie : \"{liste[0]}\"")
-patternFilter = []
+        elif len(liste) > 1:
-klFilter = []
+            print(f"Mots à tester : {liste}")
-blFilter = []
-ftFilter = []
-
-# Fonction d'élimination de mots contenant plusieurs occurences de lettres
-def noDouble(mots):
-    ndList = []
-    for mot in mots:
-        llist = []
-        for l in mot:
-            if not l in llist:
-                llist.append(l)
-        if len(mot) == len(llist):
-            ndList.append(mot)
-    return(ndList)
-
-# First Try : sélectionne des mots ayant des chances de valider ou invalider des voyelles
-def firstTryFilter(mots, ft):
-    vLetters = ['A', 'E', 'I', 'O', 'U', 'Y']
-    bestWords = []
-    for mot in mots:
-        vCount = 0
-        for l in mot:
-            if l in vLetters:
-                vCount +=1
-        if vCount >= ft:
-            bestWords.append(mot)
-    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)
+            print("Hmmm... Je crois qu'on s'est perdu...")
-'''
+        exit(0)
-
+    if args.knownLetters:
-# First Letter : élimination des mots ne commençant pas par FirstLetter
+        liste = resolv_kl(liste, args.knownLetters)
-if fl:
+    if args.badLetters:
-    goodFl = [mot for mot in liste if mot.startswith(fl)]
+        liste = resolv_bl(liste, args.badLetters)
-
+    if args.pattern:
-# Nb Lettres : élimination des mots n'ayant pas le bon nombre de lettres
+        liste = resolv_pattern(liste, args.pattern)
-if fl:
+    if len(liste) > 1:
-    goodLen = [mot for mot in goodFl if len(mot) == nb]
+        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:
-    goodLen = [mot for mot in liste if len(mot) == nb]
+        print("Hmmm... Je crois qu'on s'est perdu...")
-
-# 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" )