Partage
  • Partager sur Facebook
  • Partager sur Twitter

Exercice et algorithm

    8 mai 2020 à 9:01:29

    bonjour , je vous donne cette exercice si c'est pas dejà fait : 

    vous savez pour la méthode sort qu trie une  liste  et vous allez la remplacer:ex:

    entrer des nombre avec espace:3 9 7 2 7
    la liste trier est : [1,2,7,7,9]

    sans utiliser la méthode sort bien sûr :)

    -
    Edité par Le programmeur solitaire 8 mai 2020 à 9:34:48

    • Partager sur Facebook
    • Partager sur Twitter

    le code FAIT le bonheur (pour moi en tous cas)

      8 mai 2020 à 9:32:27

      Bonjour,

      L'exemple est érroné ...

      • Partager sur Facebook
      • Partager sur Twitter
      • J'aime les bananes, le python, le gnu, le pingouin.
        • Vive le libre !
        8 mai 2020 à 9:35:18

        non moi je ne vois d'erreur dans mon exemple
        • Partager sur Facebook
        • Partager sur Twitter

        le code FAIT le bonheur (pour moi en tous cas)

          8 mai 2020 à 10:07:21

          Pas compris
          • Partager sur Facebook
          • Partager sur Twitter

          "il vaut mieux vivre en France qu'en Italie, la France a de plus jolies prisons"

            8 mai 2020 à 10:09:07

            Ben la list triée serait: [2, 3, 7, 9] .

            édit:

            sans utiliser sort, ça pourrait donner un truc du genre:

            from itertools import *
            c = [1, 4, 6, 2, 3]
            l = set()
            for a,b in product(c,repeat=2):
                if a<=b:
                    l.add(a)
            l = list(l)
            print(l)
            

            -
            Edité par __fabien 8 mai 2020 à 10:22:13

            • Partager sur Facebook
            • Partager sur Twitter
            • J'aime les bananes, le python, le gnu, le pingouin.
              • Vive le libre !
              8 mai 2020 à 10:21:22

              a oui tu as raison:

              josmiley a écrit:

              Pas compris

              pourtant c'est facile tu remplace la methodes sort par une de tes fonctions

              -
              Edité par Le programmeur solitaire 8 mai 2020 à 10:23:02

              • Partager sur Facebook
              • Partager sur Twitter

              le code FAIT le bonheur (pour moi en tous cas)

                8 mai 2020 à 10:34:02

                from itertools import *
                c = [1, 4, 6, 2, 3]
                l = list( set( a for a,b in product(c, repeat=2) if a<=b))
                print(l)



                -
                Edité par __fabien 8 mai 2020 à 10:35:11

                • Partager sur Facebook
                • Partager sur Twitter
                • J'aime les bananes, le python, le gnu, le pingouin.
                  • Vive le libre !
                  8 mai 2020 à 10:43:41

                  Pas compris l'exemple [1,2,7,7,9]
                  • Partager sur Facebook
                  • Partager sur Twitter

                  "il vaut mieux vivre en France qu'en Italie, la France a de plus jolies prisons"

                    8 mai 2020 à 17:01:28

                    sans utiliser le module  itertools:

                    sinon j'ai un autre exercice :

                    entre un nombres : 55 
                    entre les nombres à utiliser : 6 3 7
                    entre les opérateurs à utiliser : *
                    il n' y pas de solution avec les chiffres ou nombre:6 3 7 et avec le(s) opérateur(s) : *
                    
                    entre un nombre: 58
                    entre les nombres à utiliser : 7 7 9
                    entre les opérateurs à utiliser : + *
                    la solution est: (7*7) + 9

                    je l'ai repris de l'exercice c++ d'openclasseromme (des chiffres)

                    pour ce qui ne connaissent pas:

                     cela consiste à trouver le résultats(nombre donnes) avec les opérateurs normaux et des chiffres donnée (ici c'est le joueur qui choisit les opérateurs  )

                    bien sur prenne votre temps

                    -
                    Edité par Le programmeur solitaire 9 mai 2020 à 16:50:33

                    • Partager sur Facebook
                    • Partager sur Twitter

                    le code FAIT le bonheur (pour moi en tous cas)

                      8 mai 2020 à 18:06:50

                      Avant de faire un autre exercice tu devrais donner la correction.

                      Pour ceux qui ont du mal avec l'algorithmie, voici l'implémentation la plus lisible possible du célèbre algorithme quicksort en version récursive :

                      def qs(_):
                          if len(_)>1:a,b,c=[],[],[];[[{d<e:a,d>e:b,d==e:c}[True].append(d)for d in _
                          ]for e in _[:1]];return qs(a)+c+qs(b)
                          return _



                      • Partager sur Facebook
                      • Partager sur Twitter
                        8 mai 2020 à 19:26:52

                        je pense que les autres lecteurs y compris moi ne comprend pas ce code: vous pouvez expliquer le code s'il vous plait
                        • Partager sur Facebook
                        • Partager sur Twitter

                        le code FAIT le bonheur (pour moi en tous cas)

                          8 mai 2020 à 19:44:29

                          Pas très aéré tout cela:

                          def qs1(_):
                              if len(_)>1:
                                  a, b, c = [], [], []
                              [[{d<e:a,d>e:b,d==e:c}[True].append(d)for d in _]for e in _[:1]]
                              return qs(a)+c+qs(b)
                              #return _ 


                          Là , c'est mieux non?

                          J'ai commenté le dernier return _ car je ne vois pas trop à quoi il sert (??)

                          Intéressant comme code. Merci.

                          • Partager sur Facebook
                          • Partager sur Twitter
                          • J'aime les bananes, le python, le gnu, le pingouin.
                            • Vive le libre !
                            8 mai 2020 à 19:53:43

                            Le programmeur solitaire a écrit:

                            je pense que les autres lecteurs y compris moi ne comprend pas ce code: vous pouvez expliquer le code s'il vous plait


                            Détecte déjà les points virgules, c'est la terminaison d'une instruction, par exemple...

                            if len(_)>1:a,b,c=[],[],[];

                            est équivalent à

                            if len(_) > 1:
                                a, b, c = [], [], []

                            qu'il aurait pu écrire 

                            if _:
                                a, b, c = [], [], []


                            et tu suis comme ça les lignes jusqu'au prochain point virgule, où tu remarqueras une "comprehension list"

                            Le plus dur c'est pas la lecture ici, c'est la notion de récursivité qu'on comprend plus ou moins bien, car ça demande de l'entraînement.

                            Des petites astuces comme True qui vaut 1, _ pour remplacer une variable nommée qui reste une variable,

                            Bref c'est amusant, ça te fera travailler les méninges. :D

                            • 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)

                              8 mai 2020 à 20:08:13

                              Ravie de voir que tout le monde est d'accord ; c'est un code vraiment ... limpide. xD

                              Toutes les instructions ont leur importance, le dernier return sert autant que la condition if len(_) > 1: qui elle-même ne peut être remplacée par if _:

                              • Partager sur Facebook
                              • Partager sur Twitter
                                8 mai 2020 à 20:13:23

                                Readability counts. a écrit:

                                Toutes les instructions ont leur importance, le dernier return sert autant que la condition if len(_) > 1: qui elle-même ne peut être remplacée par if _:


                                Je veux bien mais dans quel cas serait il utile ? Le code semble très bien marcher sans...

                                édit: Et puis, est il  même exécuté ? Par ce que normalement après un return on quitte la fonction.

                                -
                                Edité par __fabien 8 mai 2020 à 20:20:06

                                • Partager sur Facebook
                                • Partager sur Twitter
                                • J'aime les bananes, le python, le gnu, le pingouin.
                                  • Vive le libre !
                                  8 mai 2020 à 20:27:35

                                  Le dernier return sert quand la liste _ contient moins de 2 éléments. Les instructions précédentes dépendent de la condition if len(_) > 1.

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    8 mai 2020 à 20:34:14

                                    ok je vois.. Merci
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    • J'aime les bananes, le python, le gnu, le pingouin.
                                      • Vive le libre !
                                      8 mai 2020 à 20:34:35

                                      __fabien a écrit:

                                      Readability counts. a écrit:

                                      Toutes les instructions ont leur importance, le dernier return sert autant que la condition if len(_) > 1: qui elle-même ne peut être remplacée par if _:


                                      Je veux bien mais dans quel cas serait il utile ?

                                      Trier une liste avec un entier n'a pas de sens.

                                      • 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)

                                        8 mai 2020 à 20:48:15

                                        J'arrête la torture ici, voici le code dé-offusqué en 2 étapes :

                                        def qs(_):
                                            if len(_)>1:a,b,c=[],[],[];[[{d<e:a,d>e:b,d==e:c}[True].append(d)for d in _
                                            ]for e in _[:1]];return qs(a)+c+qs(b)
                                            return _
                                        
                                        def qs(_):
                                            if len(_) > 1:
                                                a, b, c = [], [], []
                                                [
                                                    [
                                                        {
                                                            d < e: a,
                                                            d > e: b,
                                                            d == e: c
                                                        }[True].append(d)
                                                        for d in _
                                                    ]
                                                    for e in _[:1]
                                                ]
                                                return qs(a) + c + qs(b)
                                            return _
                                        
                                        def quicksort(array):
                                            if len(array) > 1:
                                                less, greater, equal = [], [], []
                                                pivot = array[0]
                                                for value in array:
                                                    if value < pivot:
                                                        less.append(value)
                                                    elif value > pivot:
                                                        great.append(value)
                                                    else:
                                                        equal.append(value)
                                                return quicksort(less) + equal + quicksort(greater)
                                            return array

                                        -
                                        Edité par Readability counts. 8 mai 2020 à 20:51:28

                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          8 mai 2020 à 21:58:25

                                          Voilà la mienne,

                                          import random
                                          
                                          from ctypes import *
                                          
                                          libc = CDLL("libc.so.6")
                                          
                                          def cmp(a, b):
                                              return a[0] - b[0]
                                          
                                          compare = CFUNCTYPE(c_int, POINTER(c_int), POINTER(c_int))
                                          
                                          qsort = libc.qsort
                                          qsort.argtypes = [POINTER(c_int), c_size_t, c_size_t, compare]
                                          qsort.restype = None
                                          
                                          values = c_int * 7
                                          array = values(10, 34, 5, 20, 22, 12, 5)
                                          qsort(array, 7, sizeof(c_int), compare(cmp))
                                          print([v for v in array])



                                          • 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)

                                            8 mai 2020 à 22:25:55

                                            ctypes c'est pas un module du c++?
                                            • Partager sur Facebook
                                            • Partager sur Twitter

                                            le code FAIT le bonheur (pour moi en tous cas)

                                              8 mai 2020 à 22:35:02

                                              C'est un module Python qui permet l'emploi des types C et non C++
                                              • 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)

                                                9 mai 2020 à 0:06:19

                                                Il me semble bien que rien n'empêche que la lib ait été écrite en C++, cf. ICI par exemple.

                                                Sinon, concernant l'usage de qsort, outre que cmp peut engendrer un overflow, les performances sont très mauvaises, je viens d'essayer sur une liste de 100000 entiers et qsort met 0.700s tandis que la méthode sort met 0.025s.

                                                Readability counts. a écrit:

                                                J'arrête la torture ici, voici le code dé-offusqué en 2 étapes :


                                                Mes explications ici : la récursivité illustrée par le tri rapide. Bien noter que ça n'a guère de sens de coder un quicksort en Python,  sauf à des fins d'apprentissage et d'illustration (ou de challenge), car ce qu'on attend d'un tri rapide c'est qu'il le soit. Toutes les expressions telles que quicksort(less) + equal + quicksort(greater) seront très lentes.
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  9 mai 2020 à 1:52:25

                                                  Readability counts. a écrit:

                                                  Le dernier return sert quand la liste _ contient moins de 2 éléments. Les instructions précédentes dépendent de la condition if len(_) > 1.

                                                  Et le code doit être indenté en accord.

                                                  Ce sont des exercices intéressants même s'ils ne sont pas aussi efficace que le sort de Python.

                                                  En tout cas, moi qui suis novice, je me suis amusé.

                                                  @__fabien:

                                                  Dans un de tes tris, tu utilises 'set'. Je ne l'ai pas encore étudié, mais il me semble que dans un 'set', chaque élément ne peut se trouver qu'une fois?

                                                  Ce qui est contradictoire avec l'idée que dans une liste, on peut avoir la même valeur plus d'une fois.

                                                  Et dans ta fonction 'qs1', il y avait quelques 'qs' qui trainaient encore. :)

                                                  @Readability counts. et fred1599:

                                                  Merci d'avoir condensé les variantes.

                                                  Je constate à quel point les """ sont utiles pour 'désactiver' du code.

                                                  -
                                                  Edité par PierrotLeFou 9 mai 2020 à 3:35:11

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter

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

                                                    9 mai 2020 à 7:36:05

                                                    PierrotLeFou a écrit:

                                                    Readability counts. a écrit:

                                                        @__fabien:

                                                        Dans un de tes tris, tu utilises 'set'. Je ne l'ai pas encore étudié, mais il me semble que dans un 'set', chaque élément ne peut se trouver qu'une fois?

                                                        Ce qui est contradictoire avec l'idée que dans une liste, on peut avoir la même valeur plus d'une fois.

                                                    Oui Bien vu ! ma proposition ne traitait pas les situations d'égualités.

                                                    -
                                                    Edité par __fabien 9 mai 2020 à 12:33:39

                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    • J'aime les bananes, le python, le gnu, le pingouin.
                                                      • Vive le libre !
                                                      9 mai 2020 à 9:21:07

                                                      PascalOrtiz a écrit:

                                                      Il me semble bien que rien n'empêche que la lib ait été écrite en C++, cf. ICI par exemple.

                                                      On joue avec les mots, on sait tous les deux ce que fait extern C ;)

                                                      PascalOrtiz a écrit:

                                                      Il me semble bien que rien n'empêche que la lib ait été écrite en C++, cf. ICI par exemple.

                                                      Sinon, concernant l'usage de qsort, outre que cmp peut engendrer un overflow, les performances sont très mauvaises, je viens d'essayer sur une liste de 100000 entiers et qsort met 0.700s tandis que la méthode sort met 0.025s.

                                                      Merci pour les tests, je n'avais pas trop fait gaffe aux performances, juste le rendre déjà fonctionnel.

                                                      J'avais déjà bien compris que ce n'est pas grâce à ce module que j'aurai des performances, d'où ma préférence pour cython. Ça se confirme une nouvelle 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)

                                                        9 mai 2020 à 9:37:40

                                                        PascalOrtiz a écrit:

                                                        Il me semble bien que rien n'empêche que la lib ait été écrite en C++, cf. ICI par exemple.

                                                        Sinon, concernant l'usage de qsort, outre que cmp peut engendrer un overflow, les performances sont très mauvaises, je viens d'essayer sur une liste de 100000 entiers et qsort met 0.700s tandis que la méthode sort met 0.025s.


                                                        le but ce n'est pas d'aller le plus vite que la méthode sort. Mais de la remplacer ;)

                                                        -
                                                        Edité par Le programmeur solitaire 9 mai 2020 à 9:39:46

                                                        • Partager sur Facebook
                                                        • Partager sur Twitter

                                                        le code FAIT le bonheur (pour moi en tous cas)

                                                          9 mai 2020 à 10:38:07

                                                          Le programmeur solitaire a écrit:

                                                          le but ce n'est pas d'aller le plus vite que la méthode sort. Mais de la remplacer ;)

                                                          -


                                                          Il te suffit d'écrire un algo de tri (sélection, insertion,etc). Par exemple

                                                          def selection(L):
                                                              return [min(L)]+bool(L.remove(min(L)))*[]+selection(L) if L else []
                                                          
                                                          L=[14, 55, 62, 53, 30, 42, 92, 95, 11, 25, 41, 28, 13, 64, 82]
                                                          print(selection(L))

                                                          Le code est dégueu mais les performances ne seront pas mauvaises car il plantera pour len(L)>1000 à cause de la récursivité en Python :)

                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            9 mai 2020 à 11:55:24

                                                            3eme exe trouver le min et le max d'une liste sans utuliser sort et les fonction min et max

                                                            __fabien a écrit:

                                                            Le programmeur solitaire a écrit:

                                                            3eme exe trouver le min et le max d'une liste sans utuliser sort et les fonction min et max

                                                            Et ceci sans utiliser les mains... :-°

                                                            quels main? o_O

                                                            -
                                                            Edité par Le programmeur solitaire 9 mai 2020 à 16:57:06

                                                            • Partager sur Facebook
                                                            • Partager sur Twitter

                                                            le code FAIT le bonheur (pour moi en tous cas)

                                                              9 mai 2020 à 12:06:45

                                                              Le programmeur solitaire a écrit:

                                                              3eme exe trouver le min et le max d'une liste sans utuliser sort et les fonction min et max

                                                              Et ceci sans utiliser les mains... :-°

                                                              • Partager sur Facebook
                                                              • Partager sur Twitter
                                                              • J'aime les bananes, le python, le gnu, le pingouin.
                                                                • Vive le libre !

                                                              Exercice et algorithm

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              • Editeur
                                                              • Markdown