Paire 2 éléments dans une liste et faire une déclaration conditionnelle pour voir si les paires sont égales les uns aux autres

Question

J'ai donc ce devoir et semble être bloqué sur cette question.

écrire une fonction qui prend, en argument, une liste appelée aList. Il renvoie un Booléen Vrai si la liste contient trois paires d'entiers, et Faux dans le cas contraire.

Exemple:

>>>threePairs([5, 6, 3, 2, 1, 4]) 
False 

>>>threePairs([1, 1, 2, 2, 2, 2]) 
True 

J'ai essayé d'utiliser les index et je ne je suis coincé à comprendre comment je fais sais pas vraiment comment couper en tranches de sorte que ces paires égales entre elles dans l'état si c'est vrai.

C'est ce que j'avais avant de le supprimer et d'essayer à nouveau.

def threePairs(aList): 
    if [0] == [1] and [2] == [3] and [4] == [5]: 
     return True 
    else: 
     return False 

Answer 1

Vous n'avez pas besoin de couper, vous avez besoin d'accès à l'index (comme une note de côté, vous devriez demander à votre professeur si elles ont jamais entendu parler de pep8, three_pairs(mylist) serait beaucoup mieux):

def threePairs(aList): 
    if aList[0] == aList[1] and aList[2] == aList[3] and aList[4] == aList[5]: 
     return True 
    else: 
     return False 

mais si vous êtes jamais revenir True et False comme celui-ci, vous pouvez simplement retourner le résultat de la comparaison:

def threePairs(aList): 
    return aList[0] == aList[1] and aList[2] == aList[3] and aList[4] == aList[5] 

bien que d'autres réponses font allusion - vos exemples ne sont pas bien définis. Que faire si vous avez:

>>> threePairs([1, 2, 3, 1, 2, 3]) 

Si ce retour True ou False?

Answer 2

Vous pouvez zip la liste en tranches avec elle-même une position avant, avec des étapes égales à 2 pour obtenir des éléments adjacents. Alors que, pour nourrir all avec la condition dont vous avez besoin:

def threePairs(l): 
    return all(i == j for i,j in zip(l[::2], l[1::2])) 

zip prend simplement un élément de chacun des iterables fournis et il revient en tant que tuple jusqu'à ce que l'une des séquences est épuisé.

Ainsi, par exemple, si l = [5, 6, 3, 2, 1, 4] et zip est utilisé avec zip(l[::2], l[1::2]) vous auriez:

# l[::2] = [5, 3, 1] 
# l[1::2] = [6, 2, 4] 
print(list(zip(l[::2], l[1::2]))) 
[(5, 6), (3, 2), (1, 4)] 

Answer 3

Que diriez-vous faire un Counter() et vérifier le nombre « paires » vous avez:

In [1]: from collections import Counter 

In [2]: def has_pairs(l, n): 
      return sum(value/2 for value in Counter(l).values() 
         if value % 2 == 0) == n 

In [3]: has_pairs([5, 6, 3, 2, 1, 4], 3) 
Out[3]: False 

In [4]: has_pairs([1, 1, 2, 2, 2, 2], 3) 
Out[4]: True 

Fonctionne pour une liste avec n'importe quelle longueur et n'importe quel nombre de paires.

Au lieu d'utiliser un sum() pour compter toutes les paires, vous pouvez itérer sur le compteur une valeur à la fois et avoir une sortie précoce si le nombre de paires atteint ou dépasse le nombre d'entrée de paires.

Answer 4

def threepairs(aList): 
    counter = 0 
    for element in aList: 
     if counter >= 3: 
      return True 
     if element % 2 == 0: 
      counter += 1 
    return False