import math

def pgcd(a,b):
	while b:
		a, b = b, a % b
	return a

def flip(dict):
	# créer une liste vide
	d = {}
	
	for cle, val in dict.items():
		# si "val" n'est pas ajouté comme une clé dans d, 
		# créer une liste vide
		if val not in d:
			d[val] = []
		# ajouter "cle" dans la dictionnaire  
		d[val].append(cle)

	return d


#  Triangle de Pascal

def generate_pascal_row(row):
	# le début du triangle
 	if row == []: return [1]
 	# créer une liste en ajoutant un 0 au début 
 	# c.a.d décaler la liste 
 	top = [0] + row
 	# créer une liste en ajoutant un 0 à la fin
 	bottom = row + [0]
 	return [a + b for a, b in zip(top, bottom)]



def afficher_pascal(n):
    liste = []
    for i in range(n):
        liste = generate_pascal_row(liste)
        print(" "*(n-i)+liste+""*(n-i))
    return None















def print_pascal_triangle(n):
   
    prev = []
    rows = [prev := generate_pascal_row(prev) for _ in range(n)]
    # rows = [[1], [1,1], [1,2,1]]
    
    rows = [[str(e) for e in row] for row in rows]
    rows = [' '.join(row) for row in rows]
    width = len(rows[-1])
    
    # Print each row
    for row in rows:
        print("{row:^{width}}".format(row=row, width=width))

def get_english_words(dictionary_path):
     try:
         with open(dictionary_path, 'r') as f:
             content = f.read()
         return {line.strip().upper() for line in content.split('\n') if line}
     except OSError:
         return {'FAUTES_FAUTES'}


def is_triad_word(word, english):
    """Vérifier si le mot est triade
    """
    return word[::2] in english and word[1::2] in english


def is_triad_phrase(phrase, english):
    """Vérifier si tous les mots dans la phrase sont triades
    """
    # fonction all verifie si tous les elements dans
    # liste sont True
    return all([is_triad_word(word, english) for word in phrase.split()])


# import math

def character_distance(left, right):
    return abs(ord(left) - ord(right))


def is_surpassing_word(word):
    """Vérifier si un mot est surpassé
        word     ->  S  U  P  E  R  B
        word[1:] ->  U  P  E  R  B
                     ----------------
                     SU UP PE ER RB
        zip(word, word[1:]) genère (S, U), (U, P), (P, E), (E, R), (R, B)

    """
    distances = [character_distance(left, right) for left, right in zip(word, word[1:])]
    return all(left < right for left, right in zip(distances, distances[1:]))


def is_surpassing_phrase(phrase):
    """Vérifier si tous les mots dans la phrase song surpassés
    """
    return all([is_surpassing_word(word) for word in phrase.split()])













# def is_triade_word(mot):
# 	"""
# 	 à compléter
# 	 on va séparer le mot en deux sous-mots
# 	 vérifier si les deux derniers font partie de l'ensemble
# 	 get_english_words(...)
# 	"""
# 	return True # ou False


def flip(dict):
	d = {}
	for key, value in dict.items():
		# les cles seront les valeurs
		# si value n'existe pas encore, créer la liste de value initiallement vide 
		if value not in d.keys():
			d[value] = []
		#ajouter key dans la liste de value 
		d[value].append(key)
	return d


def comprehension_write():
   
    nums = [0, 1, 2, 3]
    fruits = ['apple', 'orange', 'pear']
    people = ["TA_sam", "TA_guido", "student_poohbear", "student_htiek"]

    print([2 * num + 1 for num in nums])  # [1, 3, 5, 7]

    print([fruit[0].upper() for fruit in fruits])  # ['A', 'O', 'P']
    print([fruit for fruit in fruits if 'p' in fruit])  # ['apple', 'pear']

    print([name[3:] for name in people if name.startswith('TA_')])  # ["sam", "guido"]
    print([(fruit, len(fruit)) for fruit in fruits])  # [('apple', 5), ('orange', 6), ('pear', 4)]
    print({fruit:len(fruit) for fruit in fruits})  # {'orange': 6, 'apple': 5, 'pear': 4}

def main():
	#d = {"CA": "US", "NY": "US", "ON": "CA"}
	#print(flip(d))

	#comprehension_write()
	
	#pascal = generate_pascal_row([1,3,3,1])
	#print(pascal)

	#print_pascal_triangle(10)
    dict = get_english_words("./words.txt")
    print(is_triad_phrase("abc", dict))
 
	return 0

if __name__ == '__main__':
    main()