J'ai un dictionnaire comme sur l'entrée. Pour chaque clé de dict, la valeur est une liste d'entiers. Tous les entiers de cette liste sont un enregistrement de temps en secondes qui montre lorsque certaines actions se sont produites. Mon objectif est de trouver pour chaque clé le nombre maximum d'actions qui a eu lieu pendant 1 minute.
J'ai écrit du code qui résout ce problème, mais cela le fait trop lentement. Il n'a pas passé le test (pas mon test, je ne sais pas ce qui l'introuvre contenue). J'ai polies mon code itératif, mais c'est encore trop lentement, alors je pense que je suis en train d'utiliser un mauvais algorithme. Pouvez-vous m'aider à trouver un bon si cela existe? Vous pouvez utiliser uniquement la bibliothèque standard uniquement! P>
largest_for_exc = {}
for key, value in seconds_for_exc.items():
val_len = len(value)
i = 0
j = 1
largest = 0
while j < val_len:
if (value[j] - value[i]) < 60:
new_largest = j - i + 1
if new_largest > largest:
largest = new_largest
j += 1
else:
i += 1
largest_for_exc[key] = largest
3 Réponses :
Voici une solution, j'espère que ça va être plus rapide. L'idée principale est d'utiliser les temps en tant que index et non de valeurs, et en utilisant [modifié après addition que seule la bibliothèque standard doit être utilisée]:
Cela peut être fait avec la compréhension de la liste - voir si elle est plus rapide: pandas .rolling () méthode pour compter chaque minute (où il y a des événements), puis prenez le maximum:
Oh, j'ai oublié de dire que cela doit être fait à l'aide de la bibliothèque standard uniquement. Pardon! Merci beaucoup!
C'est une grosse affaire! J'ai modifié pour ajouter une solution avec une bibliothèque standard uniquement.
Je n'ai pas accès à un gros jeu de données pour vérifier la vitesse maintenant, mais cela ressemble à une belle pythonique Sintax pour la même solution que j'ai écrite. La compréhension de la liste devrait augmenter de manière significative la vitesse, mais je ne sais pas si suffisamment. Et merci pour cela maintenant, je sais que la compréhension de la liste fonctionne plus rapidement que la boucle (je l'ai lu maintenant après votre commentaire).
Je vous invite à utiliser Il n'est généralement pas conseillé de concaténer de nombreuses boucles ensemble car elle augmente le nombre d'opérations parfois redondantes.
Un conseil général serait de convertir vos listes d'entiers (contenus dans votre dictionnaire) dans Cela vous aidera à vous vectoriser vos boucles et à améliorer les performances de votre code. Vérifiez ce lien: HTTPS: // hackernoon.com/speeding-up-your-code-code--vectoriser-Le-loops-with-numpy-e380e939bed3 line_profiler ( https://github.com/rkern / Line_Profiler ) Pour voir quelle ligne prend le plus de temps.
np.array . Les structures de données numpées ont besoin de vitesse et sont plus rapides que les listes.
Le temps d'exécution de votre algorithme est quadratique dans le nombre d'éléments de chaque liste. Il sera donc lent chaque fois que les listes deviennent grandes.
Au lieu de cela, vous pouvez utiliser cette approche, qui a une exécution linéaire: Utilisez deux index, un pour le début de votre intervalle, un pour la fin. Avancez le deuxième index et enregistrez la plus grande plage jusqu'à ce que la différence de temps est> = 60. Avancez l'index de démarrage jusqu'à ce que la différence soit à nouveau <60.
Répéter jusqu'à ce que vous atteigniez la fin.
Droit! Cet algorithme a-t-il un nom?
@Vladriabets, pouvez-vous s'il vous plaît poster le code, si vous êtes en mesure de mettre en œuvre cela. Parce que je ne pouvais pas comprendre cet algorithme.
@Satheesh, j'ai écrit du code pour vous et j'ai ajouté cela au bas de ma question.
Pouvez-vous poster quelques échantillons d'entrée et de sortie, pour vérification?
Sûr! Je l'ai ajouté à la fin.