Si vous vérifiez le code ci-dessous, j'ai utilisé des boucles pour vérifier si dans un ensemble de mots, un mot est le suffixe d'un autre.

Ma question est, comment puis-je remplacer la boucle double for? Le gars qui a écrit la tâche a mentionné qu'il existe une solution utilisant des algorithmes (je ne sais pas ce que c'est: /)

def checkio(words):
    if len(words) == 1: return False
    else:
        for w1 in words:
            for w2 in words:
                if w1 == w2:
                    continue
                elif w1.endswith(w2) or w2.endswith(w1): return True
                else: return False

print checkio({"abc","cba","ba","a","c"}) # prints True in Komodo 
print checkio({"walk", "duckwalk"}) # prints True

Deuxième question: il semble que la fonction actuelle ne fonctionne pas dans tous les environnements. Quelqu'un peut-il signaler ce que j'ai fait de mal? Cela fonctionne sur mon IDE Komodo mais ne fonctionnera pas sur le site Web de chekio.

Voici un lien vers la tâche: http://www.checkio.org / mission / fin-de-l'autre /

2
user4990011 12 juil. 2015 à 17:11

5 réponses

Meilleure réponse

Laissez Python générer toutes les combinaisons à vérifier:

import itertools

def checkio(data):
    return any((x.endswith(y) or y.endswith(x)) for x, y in itertools.combinations(data, 2))

Et laissez Python le tester:

assert checkio({"abc","cba","ba","a","c"}) == True
assert checkio({"walk", "duckwalk"}) == True
assert checkio({"aaa", "bbb"}) == False
8
dlask 12 juil. 2015 à 14:33

Le str.endswith () de Python fera le travail.

Exemple de script:

>>> a = 'hello'
>>> a.endswith('llo')
True
>>> a.endswith('ello')
True
>>> a.endswith('o')
True
>>> a.endswith('lo')
True
>>> a.endswith('ell')
False

Habillage d'une fonction:

import itertools
def checkio(words):

    words = [ w for w, s in itertools.product(words, words) if w != s and ( w.endswith(s) or s.endswith(w) ) ]
    return False if len(words) == 0 else True

Exemple de sortie: Vous pouvez le tester ici:

checkio( {"hello", "lo", "he"} ) => True
checkio( {"hello", "la", "hellow", "cow"} ) => False
checkio( {"walk", "duckwalk"} ) => True
checkio( {"one"} ) => False
checkio( {"helicopter", "li", "he"} ) => False
1
raymelfrancisco 14 juil. 2015 à 14:29

Peut utiliser des intersections et des compréhensions:

def checkio(words):
    for w in words:
        ends = {w[i:] for i in range(1,len(w))}
        if len(words & ends) > 0:
            return True
    return False

Production:

>>> checkio({"walk", "duckwalk"})
True
>>> checkio({"walk", "duckbill"})
False

La façon dont cela fonctionne est la suivante. Supposons que words contienne le mot "peur". Lorsque w a 'peur', l'ensemble des tranches ends devient {'cared', 'ared', 'red', 'e', ​​'d'}. & est l'opérateur d'intersection de Python. Si un mot est commun à words et ends, par exemple 'rouge', cette intersection ne sera pas vide donc len(words & ends) > 0 sera True - qui est ensuite renvoyée comme valeur de la fonction. Si le code réussit à parcourir tous les mots sans rencontrer et pour lesquels len(words & ends) > 0, il n'y a pas d'exemple d'un mot étant un suffixe d'un autre dans la liste et False est donc retourné.

2
John Coleman 12 juil. 2015 à 15:44

Merci les gars, tous vos commentaires et réponses m'ont aidé à voir les choses différemment. Je pense que ce code est beaucoup moins volumineux et clair et ne nécessite pas d'importation de module

def checkio(words):
    for w1 in words:
        for w2 in words:
            if w1 != w2 and (w1.endswith(w2) or w2.endswith(w1)):
                return True
    return False
2
PM 2Ring 12 juil. 2015 à 15:09

Voici une version pour boucle utilisant itertools.combinations():

def checkio(words):
    for w1, w2 in itertools.combinations(words, 2):
        if w1.endswith(w2) or w2.endswith(w1):
            return True
    return False

print checkio({"abc","cba","ba","a","c"}) # prints True in Komodo only :/
print checkio({"walk", "duckwalk"}) # prints True
print checkio({"a", "foo", "bar"}) # prints False

Donnant:

True
True
False

Si vous imprimez chaque itération, vous verrez comment fonctionne la fonction combinations(), donc pour le dernier exemple vous la verrez, essayez ce qui suit:

a - foo
a - bar
foo - bar
4
Martin Evans 12 juil. 2015 à 15:48