C'est le code que j'ai jusqu'à présent.

def find_duplicate_integers(arg):
     stats = {}
     for i in arg:
         if i > 1:
            if i in stats:
                 stats[i] += 1
            else:
                 stats[i] = 1
     return stats

C'est le résultat que je veux

>>> find_duplicate_integers([1, 1, 3, 2, 3, 1, 0])
{1: 3, 3: 2}

Mais c'est le résultat que j'obtiens

>>> find_duplicate_integers([1, 1, 3, 2, 3, 1, 0])
{2: 1, 3: 2}

Je m'excuse si cela est dû à une erreur fondamentale, mais je ne sais pas comment faire fonctionner cela. Toute aide serait grandement appréciée!

0
KING JAL 10 mars 2016 à 07:40

4 réponses

Meilleure réponse

Si vous voulez savoir ce qui ne va pas avec votre code, regardez la modification suivante que j'ai apportée à votre code.

def find_duplicate_integers(arg):
    stats = {}
    res  = {}
    for i in arg:
        if i in stats:
            stats[i] += 1
            res[i] = stats[i]
        else:
            stats[i] = 1
    return res

print find_duplicate_integers([1, 1, 3, 2, 3, 1, 0])

Tout d'abord, vous ne regardiez même pas car vous posez la condition de ne vérifier que les entiers supérieurs à 1

if i > 1

Cette condition n'est pas requise (selon ce que je comprends de vos besoins).

Ensuite, j'ai créé une liste différente juste pour stocker les vars qui ont une valeur supérieure à 1.

J'insiste, ce n'est pas la meilleure façon de résoudre ce problème. J'essaie simplement de souligner ce qui n'allait pas dans votre code qui vous a donné les résultats que vous obteniez.

1
Abhilash Panigrahi 10 mars 2016 à 05:07

Vous pouvez le faire sur une seule ligne:

def find_duplicate_integers(arg):
    return {i: arg.count(i) for i in set(arg) if arg.count(i) > 1}

Si vous vous souciez de l'exécution, il pourrait y avoir des moyens plus rapides de le faire.

ÉDITER:

Si vous en avez besoin pour être vraiment rapide, vous pouvez le faire comme ceci:

from collections import defaultdict
from random import SystemRandom
from timeit import Timer


def find_duplicate_integers3(arg):
    d = defaultdict(lambda: 0)
    for i in arg:
        d[i] += 1
    return {k: v for k, v in d.items() if v > 1}

rdev = SystemRandom()
numberList = [rdev.randint(0, 10 ** 3) for _ in range(1000)]

t1 = Timer(lambda: find_duplicate_integers3(numberList))  # Mine
t2 = Timer(lambda: find_duplicate_integers1(numberList))  # Goodies's
print(t1.timeit(number=1000))  # => 0.42611347176268827
print(t2.timeit(number=1000))  # => 1.0357027557108174

EDIT2:

Comme l'a souligné donkopotamus, il existe un moyen encore meilleur (et plus rapide) de le faire: collections.Counter

3
Felix 10 mars 2016 à 05:56

Vous pouvez le faire très facilement en utilisant collections.Counter dans bibliothèque standard de pythons

def find_duplicate_integers(arg):
    return {k: v for k, v in collections.Counter(arg).items() if v > 1}

Alors

>>> find_duplicate_integers([1, 1, 3, 2, 3, 1, 0])
{1: 3, 3: 2}
1
donkopotamus 10 mars 2016 à 05:40

Utilisez groupby à partir de itertools.

from itertools import groupby
def find_duplicate_integers(numberlist, minimum=1):
    repeats = dict([(a, sum(1 for _ in b)) for a, b in groupby(sorted(numberlist))])
    return dict((a, b) for a, b in repeats.items() if b > minimum)

print(find_duplicate_integers([1, 1, 3, 2, 3, 1, 0]))  # => {1: 3, 3: 2}
print(find_duplicate_integers([1, 1, 3, 2, 3, 1, 0], minimum=3))  # => {1: 3}

Comparé à la solution de @ caenyon. Ma fonction est # 1 c'est # 2.

from itertools import groupby
from random import SystemRandom
from timeit import Timer
rdev = SystemRandom()
numberList = [rdev.randint(0, 10**3) for _ in range(1000)]

t1 = Timer(lambda: find_duplicate_integers1(numberList))  # Mine
t2 = Timer(lambda: find_duplicate_integers2(numberList))  # caenyon's
print(t1.timeit(number=1000))  # => 0.7377041084807044
print(t2.timeit(number=1000))  # => 16.82846828367938

Il devient progressivement plus lent à mesure que la taille augmente.

0
Goodies 10 mars 2016 à 05:08