Partage
  • Partager sur Facebook
  • Partager sur Twitter

Aide complexité d'un algorithme

    1 juillet 2020 à 10:08:53

    • Bonjour, pouvez-vous m'expliquer davantage(par rapport a l'enoncé) le fonctionnement de l'algorithme pour que je puisse réussir mon exercice svp.

    -
    Edité par Rdmanonymous 1 juillet 2020 à 10:23:17

    • Partager sur Facebook
    • Partager sur Twitter
      1 juillet 2020 à 12:43:31

      tu as un tableau t de n valeurs; on veut savoir combien de fois chaque valeur unique apparaît dans t, donc pour ça on créé le dictionnaire ht qui aura pour clé les valeurs uniques et pour valeur de ces clés le nombre d'apparition de la valeur dans t.
      exemple: si t[]=[1,2,3,2,5,4,2,3,4,8], on doit avoir ht={1:1, 2:3, 3:2, 4:2, 5:1, 8:1} (la valeur 1 apparaît 1 fois dans t, la valeur 2 apparaît 3 fois, etc etc) et comme on veut vmax (la valeur qui est présente le plus de fois) ici 2, on regarde à chaque fois la valeur qui est apparu (on pourrait aussi ne le regarder qu'à la fin du parcours de t)

      • Partager sur Facebook
      • Partager sur Twitter
        2 juillet 2020 à 1:23:13

        Comment peux-tu savoir la fréquence des éléments avant la fin du parcours de la liste?

        Si c'est le maximum qu'on cherche, voici un petit essai:

        -

        L=[1,2,3,2,5,4,2,3,4,8]

        D={}

        for k in L: D[k]=D.get(k,0)+1

        T=max((v,k) for k,v in D.items())

        print(f'Le nombre {T[1]} apparait {T[0]} fois.')

        -
        Edité par PierrotLeFou 2 juillet 2020 à 3:32:29

        • Partager sur Facebook
        • Partager sur Twitter

        Le Tout est souvent plus grand que la somme de ses parties.

          2 juillet 2020 à 10:25:27

          l'algo donné indique de garder en mémoire la plus grande valeur des compteurs cmax et sa clé vmax à chaque itération (on veut peut-être pouvoir savoir à chaque itération, quel est l'élément qui a la fréquence max )
          • Partager sur Facebook
          • Partager sur Twitter
            2 juillet 2020 à 14:02:42

            PierrotLeFou a écrit:

            L=[1,2,3,2,5,4,2,3,4,8]

            D={}

            for k in L: D[k]=D.get(k,0)+1

            T=max((v,k) for k,v in D.items())

            print(f'Le nombre {T[1]} apparait {T[0]} fois.')


            ou un poil plus court

            L=[1,2,3,2,5,4,2,3,4,8]
            D=dict.fromkeys(L,0)
            for k in L: D[k]+=1
            T=max(D,key=D.get)
            print(f'Le nombre {T} apparait {D[T]} fois.')



            -
            Edité par josmiley 2 juillet 2020 à 16:23:10

            • Partager sur Facebook
            • Partager sur Twitter

            Python c'est bon, mangez-en. 

              2 juillet 2020 à 18:55:23

              @josmiley:
              Merci pour les astuces. J'ai encore quelques croûtes de Python à manger. :)
              • Partager sur Facebook
              • Partager sur Twitter

              Le Tout est souvent plus grand que la somme de ses parties.

                3 juillet 2020 à 12:50:51

                josmiley a écrit:

                PierrotLeFou a écrit:

                L=[1,2,3,2,5,4,2,3,4,8]

                D={}

                for k in L: D[k]=D.get(k,0)+1

                T=max((v,k) for k,v in D.items())

                print(f'Le nombre {T[1]} apparait {T[0]} fois.')


                ou un poil plus court

                L=[1,2,3,2,5,4,2,3,4,8]
                D=dict.fromkeys(L,0)
                for k in L: D[k]+=1
                T=max(D,key=D.get)
                print(f'Le nombre {T} apparait {D[T]} fois.')

                Avec Counter on fait encore plus court

                • Partager sur Facebook
                • Partager sur Twitter

                Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
                La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

                  3 juillet 2020 à 14:28:12

                  fred1599 a écrit:

                  josmiley a écrit:

                  PierrotLeFou a écrit:

                  L=[1,2,3,2,5,4,2,3,4,8]

                  D={}

                  for k in L: D[k]=D.get(k,0)+1

                  T=max((v,k) for k,v in D.items())

                  print(f'Le nombre {T[1]} apparait {T[0]} fois.')


                  ou un poil plus court

                  L=[1,2,3,2,5,4,2,3,4,8]
                  D=dict.fromkeys(L,0)
                  for k in L: D[k]+=1
                  T=max(D,key=D.get)
                  print(f'Le nombre {T} apparait {D[T]} fois.')

                  Avec Counter on fait encore plus court

                  oui mais là c'est trop court ^^

                  • Partager sur Facebook
                  • Partager sur Twitter

                  Python c'est bon, mangez-en. 

                    3 juillet 2020 à 14:58:16

                    Quelque chose du genre?
                    -
                    from collections import Counter
                    L=[1,2,3,2,5,4,2,3,4,8]
                    D=Counter(L)
                    T=max(D,key=D.get)
                    print(f'Le nombre {T} apparait {D[T]} fois.')
                    -
                    Ou mieux encore:
                    -
                    from collections import Counter
                    L=[1,2,3,2,5,4,2,3,4,8]
                    T=max((v,k) for k,v in Counter(L).items())
                    print(f'Le nombre {T[1]} apparait {T[0]} fois.')

                    -
                    Edité par PierrotLeFou 3 juillet 2020 à 15:30:16

                    • Partager sur Facebook
                    • Partager sur Twitter

                    Le Tout est souvent plus grand que la somme de ses parties.

                      3 juillet 2020 à 17:47:09

                      et pourquoi pas avec most_common(1) ?
                      from collections import Counter
                      L=[1,2,3,2,5,4,2,3,4,8]
                      T=Counter(L).most_common(1)
                      print(f'Le nombre {T[0][0]} apparait {T[0][1]} fois.')
                      • Partager sur Facebook
                      • Partager sur Twitter
                        3 juillet 2020 à 17:47:34

                        PierrotLeFou a écrit:

                        Ou mieux encore:
                        -
                        from collections import Counter
                        L=[1,2,3,2,5,4,2,3,4,8]
                        T=max((v,k) for k,v in Counter(L).items())
                        print(f'Le nombre {T[1]} apparait {T[0]} fois.')

                        mais tu perds le dictionnaire là, faut déplacer Counter.
                        • Partager sur Facebook
                        • Partager sur Twitter

                        Python c'est bon, mangez-en. 

                          3 juillet 2020 à 18:20:02

                          from collections import Counter
                          
                          maxi = lambda d: list(d.keys())[list(d.values()).index(max(list(d.values())))]
                          
                          L = [1, 2, 3, 2, 5, 4, 2, 3, 4, 8]
                          D = Counter(L)
                          T = maxi(D)
                          
                          print(f'Le nombre {T} apparait {D[T]} fois.')
                          • Partager sur Facebook
                          • Partager sur Twitter

                          Celui qui trouve sans chercher est celui qui a longtemps cherché sans trouver.(Bachelard)
                          La connaissance s'acquiert par l'expérience, tout le reste n'est que de l'information.(Einstein)

                            3 juillet 2020 à 19:12:36

                            josmiley a écrit:
                            > mais tu perds le dictionnaire là, faut déplacer Counter.
                            Ça dépend si on veut garder le dictionnaire ou pas.
                            @fred1599:
                            Ce qu'on perd en longueur, on le gagne en largeur, semble-t-il ... :)
                            Il semble qu'on a perdu de vue notre ami Rdmanonymous :)
                            @umfred: Je garde aussi ta suggestion:
                            T=Counter(L).most_common(1)

                            • Partager sur Facebook
                            • Partager sur Twitter

                            Le Tout est souvent plus grand que la somme de ses parties.

                            Aide complexité d'un algorithme

                            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                            × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                            • Editeur
                            • Markdown