wgamesolv/wgamesolv.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

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()

# Dictionary
if args.dictionary:
    try :
        with open(args.dictionary, "r") as dico:
            liste = json.load(dico)
    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):
    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)
'''

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]


# 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" )