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.

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

__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

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

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

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

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

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 !

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)

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

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!

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.

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

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

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...

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

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

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().

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 

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

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

voila c'est corriger 

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.

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 

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

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

<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?

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

ily a quelqu'un , ne m'abandonner pas SVP

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

SVP reformule autrement tes demandes ou tes suggestions.

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

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