Partage
  • Partager sur Facebook
  • Partager sur Twitter

Exercice et algorithm

    9 mai 2020 à 12:17:00

    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


    Montre nous ce que tu proposes.
    • Partager sur Facebook
    • Partager sur Twitter
      9 mai 2020 à 13:37:39

      Le mien c'est le plus mieux beau. ( ͡° ͜ʖ ͡°)

      def     min___max (           list ):
       _ =    min = max =           list [0]
       for                object in list :
        if    min >       object :
              min =       object
        elif        max < object :
                    max = object
       return     (
              min , max )

      -
      Edité par Readability counts. 9 mai 2020 à 13:41:24

      • Partager sur Facebook
      • Partager sur Twitter
        9 mai 2020 à 14:20:16

        __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... :-°

        Bon j'ai triché mais j'utilise ma main gauche:

        from itertools import *
        c = [1, 1, 2, 2, 4, 6, 2, 3]
        
        def mini(L):
            l=[]
            for i in set( a for a,b in product(L, repeat=2)):
                l=l+[i]*L.count(i)
            return l
        print(mini(c))
        from itertools import *
        c = [1, 1, 2, 2, 4, 6, 2, 3]
        
        def maxi(L):
            l=[]
            for i in set( a for a,b in product(L, repeat=2)):
                l=l+[i]*L.count(i)
            l.reverse()
            return l
        print(maxi(c))





        -
        Edité par __fabien 9 mai 2020 à 14:54:09

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

          Readability counts. a écrit:

          Le mien c'est le plus mieux beau. ( ͡° ͜ʖ ͡°)

          def     min___max (           list ):
           _ =    min = max =           list [0]
           for                object in list :
            if    min >       object :
                  min =       object
            elif        max < object :
                        max = object
           return     (
                  min , max )

          -

          Le but c'est qu'il y ait le plus d'orange possible ;)

          Je reviens au tri par sélection, j'avais donné un one-liner récursif mais on peut aussi le faire en itératif :

          def selection(L):
              return [(min(L), L.remove(min(L)))[0] for _ in range(len(L)-1)]+[L[0]]
          
          L=[14, 55, 62, 53, 30, 42, 92, 95, 11, 25, 41, 28, 13, 64, 82]
          print(selection(L))
          





          • Partager sur Facebook
          • Partager sur Twitter
            9 mai 2020 à 15:13:31

            PascalOrtiz a écrit:

            Je reviens au tri par sélection, j'avais donné un one-liner récursif mais on peut aussi le faire en itératif :

            def selection(L):
                return [(min(L), L.remove(min(L)))[0] for _ in range(len(L)-1)]+[L[0]]
            
            L=[14, 55, 62, 53, 30, 42, 92, 95, 11, 25, 41, 28, 13, 64, 82]
            print(selection(L))
            

            En plus concis :

            selection = lambda ls: [ls.pop(ls.index(min(ls))) for _ in ls[:]]

            -
            Edité par Readability counts. 9 mai 2020 à 15:16:57

            • Partager sur Facebook
            • Partager sur Twitter
              9 mai 2020 à 16:47:06

              je vois que vous avez fait l'exercice trés vite.

              -
              Edité par Le programmeur solitaire 9 mai 2020 à 16:48:55

              • Partager sur Facebook
              • Partager sur Twitter

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

                9 mai 2020 à 17:11:12

                Readability counts. a écrit:

                selection = lambda ls: [ls.pop(ls.index(min(ls))) for _ in ls[:]]

                -
                Edité par Readability counts. il y a environ 1 heure


                Très instructif, merci ! ! Très court, lisible et surtout très efficace, plus rapide qu'un tri par sélection multiliner, par exemple 2.5 fois plus rapide que le code de GeeksforGeeks, 2 fois plus rapide que celui de rosetta. Alors que des méthodes comme list.index ou list.remove sont des hérésies algorithmiques, comme quoi en Python, il faut se méfier !
                • Partager sur Facebook
                • Partager sur Twitter
                  9 mai 2020 à 17:49:13

                  En voici une autre,

                  import heapq
                  
                  L = [14, 55, 62, 53, 30, 42, 92, 95, 11, 25, 41, 28, 13, 64, 82]
                  
                  k_smallest = heapq.nsmallest(len(L), L)
                  print(k_smallest)



                  • 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 à 18:06:18

                    exe 4: 

                    <exe nb="4">
                        <niveau>intermédiaire </niveau>
                        <titre>le Chiffrement de césar </titre>
                        <commentaire type="string">
                            vous connaissez  surement le 
                            chiffrement de césar  : où on melange les lettres 
                            donnes avec des clés : exe: <example>
                            entre une phrase: coucou les Zeros
                            entre une clés : 2
                            le code chiffrer est : eqweqw ngu bgtqu
                            </example>
                        </commentaire> 
                    </exe>



                    -
                    Edité par Le programmeur solitaire 9 mai 2020 à 18:07:12

                    • Partager sur Facebook
                    • Partager sur Twitter

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

                      9 mai 2020 à 18:30:53

                      PascalOrtiz a écrit:

                      Readability counts. a écrit:

                      selection = lambda ls: [ls.pop(ls.index(min(ls))) for _ in ls[:]]

                      -
                      Edité par Readability counts. il y a environ 1 heure


                      Très instructif, merci ! ! Très court, lisible et surtout très efficace, plus rapide qu'un tri par sélection multiliner, par exemple 2.5 fois plus rapide que le code de GeeksforGeeks, 2 fois plus rapide que celui de rosetta. Alors que des méthodes comme list.index ou list.remove sont des hérésies algorithmiques, comme quoi en Python, il faut se méfier !

                      Je pense que ce code est plus rapide et en plus il préserve la liste d'origine :

                      def selection(iterable):
                          def f(ls):
                              while ls:
                                  yield ls.pop(ls.index(min(ls)))
                          return list(f(list(iterable)))

                      fred1599 a écrit:

                      En voici une autre,

                      import heapq
                      
                      L = [14, 55, 62, 53, 30, 42, 92, 95, 11, 25, 41, 28, 13, 64, 82]
                      
                      k_smallest = heapq.nsmallest(len(L), L)
                      print(k_smallest)

                      heapq.nsmallest() utilise la fonction sorted() ou selon les arguments la méthode list.sort(). Il y a hors-jeu monsieur l'arbitre!

                      • Partager sur Facebook
                      • Partager sur Twitter
                        9 mai 2020 à 18:33:48

                        fred1599 a écrit:

                        import heapq
                        
                        L = [14, 55, 62, 53, 30, 42, 92, 95, 11, 25, 41, 28, 13, 64, 82]
                        
                        k_smallest = heapq.nsmallest(len(L), L)
                        print(k_smallest)



                        Bien vu, en effet, il fait un tri par tas et il est très rapide, presque autant que sorted.

                        • Partager sur Facebook
                        • Partager sur Twitter
                          9 mai 2020 à 18:34:40

                          Readability counts. a écrit:

                          PascalOrtiz a écrit:

                          Readability counts. a écrit:

                          selection = lambda ls: [ls.pop(ls.index(min(ls))) for _ in ls[:]]

                          -
                          Edité par Readability counts. il y a environ 1 heure


                          Très instructif, merci ! ! Très court, lisible et surtout très efficace, plus rapide qu'un tri par sélection multiliner, par exemple 2.5 fois plus rapide que le code de GeeksforGeeks, 2 fois plus rapide que celui de rosetta. Alors que des méthodes comme list.index ou list.remove sont des hérésies algorithmiques, comme quoi en Python, il faut se méfier !

                          Je pense que ce code est plus rapide et en plus il préserve la liste d'origine :

                          def selection(iterable):
                              def f(ls):
                                  while ls:
                                      yield ls.pop(ls.index(min(ls)))
                              return list(f(list(iterable)))

                          fred1599 a écrit:

                          En voici une autre,

                          import heapq
                          
                          L = [14, 55, 62, 53, 30, 42, 92, 95, 11, 25, 41, 28, 13, 64, 82]
                          
                          k_smallest = heapq.nsmallest(len(L), L)
                          print(k_smallest)

                          heapq.nsmallest() utilise la fonction sorted() ou selon les arguments la méthode list.sort(). Il y a hors-jeu monsieur l'arbitre!


                          c'est vrais : non mais dit donc:colere:
                          • Partager sur Facebook
                          • Partager sur Twitter

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

                            9 mai 2020 à 19:09:11

                            Readability counts. a écrit:

                            Je pense que ce code est plus rapide et en plus il préserve la liste d'origine :

                            def selection(iterable):
                                def f(ls):
                                    while ls:
                                        yield ls.pop(ls.index(min(ls)))
                                return list(f(list(iterable)))


                            Personnellement, le tri par sélection le plus rapide auquel j'arrive et qui préserve la liste est ceci :

                            def selection_yield(iterable):
                                def f(ls):
                                    while ls:
                                        mini=min(ls)
                                        ls.remove(mini)
                                        yield mini
                                return list(f(list(iterable)))

                            Sur les listes de 50000 éléments, c'est très légèrement plus rapide (moins de 2%), ce qui ne me paraît pas anormal vu qu'il n'y a pas de gestion di'indice.

                            Readability counts. a écrit:

                            heapq.nsmallest() utilise la fonction sorted() ou selon les arguments la méthode list.sort(). Il y a hors-jeu monsieur l'arbitre!


                            Tiens ? le module heapq gère une file de priorité laquelle permet de faire un tri par tas, cf. mon exemple ici. La fonction sorted ou la méthode sort, à ma connaissance,  utilisent un algorithme complètement différent, le timsort (mix d'un tri fusion et d'un tri par insertion).
                            • Partager sur Facebook
                            • Partager sur Twitter
                              9 mai 2020 à 19:17:17

                              Readability counts. a écrit:

                              heapq.nsmallest() utilise la fonction sorted() ou selon les arguments la méthode list.sort(). Il y a hors-jeu monsieur l'arbitre!


                              Ah c'était un jeu ? Bon ben je sors...
                              • 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 à 19:20:14

                                non RESTE!!!!:'( c'est pas un jeu c'est pour s'entrainer

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

                                • Partager sur Facebook
                                • Partager sur Twitter

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

                                  9 mai 2020 à 19:29:34

                                  PascalOrtiz a écrit:

                                  Readability counts. a écrit:

                                  heapq.nsmallest() utilise la fonction sorted() ou selon les arguments la méthode list.sort(). Il y a hors-jeu monsieur l'arbitre!


                                  Tiens ? le module heapq gère une file de priorité laquelle permet de faire un tri par tas, cf. mon exemple ici. La fonction sorted ou la méthode sort, à ma connaissance,  utilisent un algorithme complètement différent, le timsort (mix d'un tri fusion et d'un tri par insertion).

                                  Le module heapq est écrit en Python, pas en C. Son code source est très intéressant et on peut y voir l'usage de sorted() ou de list.sort() dans la fonction nsmallest().

                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    9 mai 2020 à 19:30:19

                                    fred1599 a écrit:

                                    Readability counts. a écrit:

                                    heapq.nsmallest() utilise la fonction sorted() ou selon les arguments la méthode list.sort(). Il y a hors-jeu monsieur l'arbitre!


                                    Ah c'était un jeu ? Bon ben je sors...


                                    Moi j'aimerai bien courir après la baballe... mais je ne peux pas.

                                    Dur dur d'être un bébé.

                                    En attendant de grandir, je vous applaudis de mes mains gauches  :p

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

                                      Readability counts. a écrit:

                                      PascalOrtiz a écrit:

                                      Readability counts. a écrit:

                                      heapq.nsmallest() utilise la fonction sorted() ou selon les arguments la méthode list.sort(). Il y a hors-jeu monsieur l'arbitre!


                                      Tiens ? le module heapq gère une file de priorité laquelle permet de faire un tri par tas, cf. mon exemple ici. La fonction sorted ou la méthode sort, à ma connaissance,  utilisent un algorithme complètement différent, le timsort (mix d'un tri fusion et d'un tri par insertion).

                                      Le module heapq est écrit en Python, pas en C. Son code source est très intéressant et on peut y voir l'usage de sorted() ou de list.sort() dans la fonction nsmallest().


                                      Autant pour moi effectivement et ça explique pourquoi le temps d'exécution est justement si proche de sorted. Et il se trouve que si n est inférieur aux nombres d'éléments de la liste alors utiliser une heap queue est plus efficace.

                                      Mais tout n'est pas perdu :) cela nous donne une nouvelle façon de trier sans sorted :

                                      def heapsort(L):
                                          L=L[:]
                                          heapify(L)
                                          return [heappop(L) for _ in range(len(L))]
                                      
                                      L=[14, 55, 62, 53, 30, 42, 92, 95, 11, 25, 41, 28, 13, 64, 82]
                                      print(heapsort(L))



                                      -
                                      Edité par PascalOrtiz 9 mai 2020 à 20:41:38

                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                        10 mai 2020 à 7:57:55

                                        voila la solution pour min et max:

                                        def mini(liste):
                                            x = 0
                                            y = 0
                                            liste2 = 0
                                            for i in liste:
                                                liste2 = liste[x]
                                                if i >= liste2:
                                                    y = i
                                                    x += 1
                                            
                                            return y
                                        def maxi(liste):
                                            x = 0
                                            y = 0
                                            liste2 = liste[0]
                                            for i in liste:
                                                liste2 = liste[x]
                                                if i <= liste2:
                                                    y = i
                                                    x += 1
                                            
                                            return y
                                        print(mini([4,1,0.5]))
                                        print(maxi([2,0.5,9,1]))
                                                

                                        et ca affiche:

                                        0.5
                                        9




                                        -
                                        Edité par Le programmeur solitaire 10 mai 2020 à 8:53:58

                                        • Partager sur Facebook
                                        • Partager sur Twitter

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

                                          10 mai 2020 à 8:20:53

                                          Pourquoi faire:
                                              liste2 =  liste[0]
                                          Si on le redéfinit dans la boucle for.
                                          • Partager sur Facebook
                                          • Partager sur Twitter

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

                                            10 mai 2020 à 8:54:16

                                            voila c'est corriger :ange:
                                            • Partager sur Facebook
                                            • Partager sur Twitter

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

                                              10 mai 2020 à 9:43:23

                                              Le programmeur solitaire a écrit:

                                              voila la solution pour min et max:

                                              def mini(liste):
                                                  x = 0
                                                  y = 0
                                                  liste2 = 0
                                                  for i in liste:
                                                      liste2 = liste[x]
                                                      if i >= liste2:
                                                          y = i
                                                          x += 1
                                                  
                                                  return y
                                              



                                              -
                                              Edité par Le programmeur solitaire il y a 30 minutes

                                              Il y a énormément de choses à reprendre. J'espère que quelqu'un aura la patience de t'expliquer pas à pas. Prends un cours basique et lis, parce que même un programme aussi simple que de calculer la somme ou le max d'une liste de nombres n' a en fait rien de naturel.
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                10 mai 2020 à 9:49:22

                                                PascalOrtiz a écrit:

                                                Le programmeur solitaire a écrit:

                                                voila la solution pour min et max:

                                                def mini(liste):
                                                    x = 0
                                                    y = 0
                                                    liste2 = 0
                                                    for i in liste:
                                                        liste2 = liste[x]
                                                        if i >= liste2:
                                                            y = i
                                                            x += 1
                                                    
                                                    return y
                                                



                                                -
                                                Edité par Le programmeur solitaire il y a 30 minutes

                                                Il y a énormément de choses à reprendre. J'espère que quelqu'un aura la patience de t'expliquer pas à pas. Prends un cours basique et lis, parce que même un programme aussi simple que de calculer la somme ou le max d'une liste de nombres n' a en fait rien de naturel.

                                                bon alors explique moi le minimum. S'il vous plait>_< 

                                                • Partager sur Facebook
                                                • Partager sur Twitter

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

                                                  10 mai 2020 à 9:53:54

                                                  Le programmeur solitaire a écrit:

                                                  bon alors explique moi le minimum. S'il vous plait>_< 


                                                  Je t'explique ICI (sauf que c'est le maximum et pas le minimum)

                                                  -
                                                  Edité par PascalOrtiz 10 mai 2020 à 9:54:14

                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    10 mai 2020 à 10:18:26

                                                    Le programmeur solitaire a écrit :

                                                    voila la solution pour min et max:

                                                    def mini(liste):
                                                        x = 0
                                                        y = 0
                                                        liste2 = 0
                                                        for i in liste:
                                                            liste2 = liste[x]
                                                            if i >= liste2:
                                                                y = i
                                                                x += 1
                                                        
                                                        return y
                                                    def maxi(liste):
                                                        x = 0
                                                        y = 0
                                                        liste2 = liste[0]
                                                        for i in liste:
                                                            liste2 = liste[x]
                                                            if i <= liste2:
                                                                y = i
                                                                x += 1
                                                        
                                                        return y
                                                    print(mini([4,1,0.5]))
                                                    print(maxi([2,0.5,9,1]))
                                                            

                                                    et ca affiche:

                                                    0.5
                                                    9

                                                    L'algorithme (pour mini et maxi) n'est pas correct, les deux fonctions renvoient toujours le dernier élément de la liste, d'ailleurs ton résultat n'est pas bon, il devrait retourner 1 et pas 9, ce qui se confirme par test.

                                                    Plus haut c'était le plus important : La réflexion.

                                                    Maintenant les détails importants, mais pas forcément pour un débutant je le conçois.

                                                    • Mettre des noms de variables adaptés au problème, en l'occurrence ici, liste2 devrait être n ou valeur, mini à la place de y et get_mini à la place de mini pour le nom de fonction.
                                                    • Essayer de traduire (peut-être pas au début) ses variables en anglais, sans faire de mélange français - anglais
                                                    • 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)

                                                      10 mai 2020 à 15:10:47

                                                      Et ce qui suit ne fonctionne pas?
                                                      def mini(liste):
                                                          mmm = liste[0]
                                                          for nxt in liste:
                                                              if nxt < mmm:
                                                                  mmm = nxt
                                                          return mmm
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter

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

                                                        10 mai 2020 à 18:47:06

                                                        <exe nb="5">
                                                            <niveau>Dure-Intermédiaire</niveau>
                                                            <niveau-exe nb="1">
                                                                écrire un mini langage de programmation:
                                                                à partir d'un fichier .xml |.yaml | .ini ou .json
                                                                exe(xml):<example lang="xml">
                                                                     <affiche>coucou</affiche>
                                                                </example> 
                                                                exe(yaml):<example lang="yaml">
                                                                      affiche: "coucou"
                                                                </example>
                                                                exe(ini):<example lang="ini">
                                                                     [io]
                                                                     affiche = "coucou"
                                                                exe(json):<example lang="json">
                                                                     {
                                                                     "affiche":"coucou",
                                                                     }
                                                                </example>
                                                                puis vous executer : <example lang="bash">
                                                            python minilangage.py nomdufichier.[xml|yaml|json|ini]
                                                             </example> 
                                                              </niveau-exe> </exe>

                                                         je mettrai les prochain niveau plus tard 

                                                        Il y a quelqu'un?o_O:euh::o

                                                        -
                                                        Edité par Le programmeur solitaire 11 mai 2020 à 7:42:08

                                                        • Partager sur Facebook
                                                        • Partager sur Twitter

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

                                                          11 mai 2020 à 21:01:14

                                                          ily a quelqu'un , ne m'abandonner pas:'(:magicien: SVP

                                                          -
                                                          Edité par Le programmeur solitaire 11 mai 2020 à 21:01:34

                                                          • Partager sur Facebook
                                                          • Partager sur Twitter

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

                                                            12 mai 2020 à 1:41:04

                                                            SVP reformule autrement tes demandes ou tes suggestions.
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter

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

                                                              12 mai 2020 à 8:35:06

                                                              vous devez faire ce mini langage ci dessous en python 

                                                              definir a 2
                                                              afficher a
                                                              si a == 2 alors:
                                                                  afficher 2
                                                              a -> +2 
                                                              afficher a
                                                              a -> abs
                                                              fonction  A():
                                                                  definir b 8
                                                                  renvoyer b
                                                              fonction B(i):
                                                                  definir e 5
                                                                  globals e
                                                                  afficher i
                                                              afficher e << affiche e
                                                              afficher A
                                                              B 9
                                                              
                                                              

                                                              les commentaires sont: <<

                                                              et vous devez l'executer comme ca : 

                                                              python minilang.py test.minilang

                                                              il y a quelqu'un^^

                                                              SVP répondez moi j'espère que vous comprenez mon exercice>_<:'( 
                                                              oui c'est vrais c'est peut être trop dure pour certaine d'autre trop facile ;) même moi je n'ai pas envisager de donner une réponse mais essayer cet exercice SVP:p

                                                              -
                                                              Edité par Le programmeur solitaire 13 mai 2020 à 8:39:37

                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

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

                                                              Exercice et algorithm

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