Donc je bosse dans un collège, et la saison des subvention permet
d'acheter des poste. Et ceux de PS étant intéressant niveau prix/config,
ce sont ceux qu'on a acheté.
Résultat : Le Mandrake linux Discovery annoncé est en fait un Linpus
Linux, distribution basée Mdk, sur laquelle je n'ai pas réussit à faire
un chti urpmi, ni même à trouver un outil graphique pour maj.
Bref, moi qui espérait un peu là-dessus pour convaincre de faire migrer
la salle info sous linux, pas de pot avec cette config à 2 sous...
Ouais, je sais, on en a pour son argent. Mais quand même...
La fin de l'aventure, totalement HS ici, mais bon, c'est que j'ai tout
viré pour refoutre win98 dessus (et ouais, je sais :-(). Ai pour ça
utilisé une knoppix, et QTParted, en 2 fois (obligation de redémarrer au
milieu), pour pouvoir supprimer les partitions et préparer/formater en
fat32. Et le fin du fin, aucun pilote fourni. Heureusement qu'il y a un
site.
En bref, le prix, 350 l'UC pour 80Go, Celeron D et 512 Mo Ram se justifie.
(1) dont j'use et abuse dans le genre $page = "<html> <head><title>Hello</title></head>"; $page .= "<body>"; foreach( $machins as $m) $page .= $m -> html_code();
Moi, je n'utilise guère le foreach de PHP car il pue un peu du bec, à vrai dire... Pour moi, un foreach devrait renvoyer du premier au dernier élément, sans tenir compte de l'ordre d'insertion.
-- Jaco
In article <7zvf5lx5a2.fsf@serveur5.labri.fr>,
Michel Billaud <billaud@labri.u-bordeaux.fr> wrote:
(1) dont j'use et abuse dans le genre
$page = "<html> <head><title>Hello</title></head>";
$page .= "<body>";
foreach( $machins as $m)
$page .= $m -> html_code();
Moi, je n'utilise guère le foreach de PHP car il pue un peu du bec, à
vrai dire... Pour moi, un foreach devrait renvoyer du premier au dernier
élément, sans tenir compte de l'ordre d'insertion.
(1) dont j'use et abuse dans le genre $page = "<html> <head><title>Hello</title></head>"; $page .= "<body>"; foreach( $machins as $m) $page .= $m -> html_code();
Moi, je n'utilise guère le foreach de PHP car il pue un peu du bec, à vrai dire... Pour moi, un foreach devrait renvoyer du premier au dernier élément, sans tenir compte de l'ordre d'insertion.
-- Jaco
Emmanuel Florac
Le Sat, 14 May 2005 17:21:48 +0200, Eric Jacoboni a écrit :
Moi, je n'utilise guère le foreach de PHP car il pue un peu du bec, à vrai dire... Pour moi, un foreach devrait renvoyer du premier au dernier élément, sans tenir compte de l'ordre d'insertion.
J'ai pas compris. Si tu as un tableau, le seul ordre qui compte c'est l'ordre du tableau, et si tu insères des éléments dans un tableau, ils sont forcément numérotés par ordre d'arrivée, non? Ou bien tu es en train de dire que PHP pue tellement que les hash renvoient leurs éléments dans l'ordre d'insertion et ne sont que des tableaux déguisés? (Ah ah ah ah).
-- Les défauts n'apparaissent qu'après que le programme a passé (avec succès) la phase d'intégration. Loi de Klipstein.
Le Sat, 14 May 2005 17:21:48 +0200, Eric Jacoboni a écrit :
Moi, je n'utilise guère le foreach de PHP car il pue un peu du bec, à
vrai dire... Pour moi, un foreach devrait renvoyer du premier au dernier
élément, sans tenir compte de l'ordre d'insertion.
J'ai pas compris. Si tu as un tableau, le seul ordre qui compte c'est
l'ordre du tableau, et si tu insères des éléments dans un tableau, ils
sont forcément numérotés par ordre d'arrivée, non? Ou bien tu es en
train de dire que PHP pue tellement que les hash renvoient leurs
éléments dans l'ordre d'insertion et ne sont que des tableaux
déguisés? (Ah ah ah ah).
--
Les défauts n'apparaissent qu'après que le programme a passé (avec
succès) la phase d'intégration.
Loi de Klipstein.
Le Sat, 14 May 2005 17:21:48 +0200, Eric Jacoboni a écrit :
Moi, je n'utilise guère le foreach de PHP car il pue un peu du bec, à vrai dire... Pour moi, un foreach devrait renvoyer du premier au dernier élément, sans tenir compte de l'ordre d'insertion.
J'ai pas compris. Si tu as un tableau, le seul ordre qui compte c'est l'ordre du tableau, et si tu insères des éléments dans un tableau, ils sont forcément numérotés par ordre d'arrivée, non? Ou bien tu es en train de dire que PHP pue tellement que les hash renvoient leurs éléments dans l'ordre d'insertion et ne sont que des tableaux déguisés? (Ah ah ah ah).
-- Les défauts n'apparaissent qu'après que le programme a passé (avec succès) la phase d'intégration. Loi de Klipstein.
Eric Jacoboni
In article , Emmanuel Florac wrote:
J'ai pas compris. Si tu as un tableau, le seul ordre qui compte c'est l'ordre du tableau, et si tu insères des éléments dans un tableau, ils sont forcément numérotés par ordre d'arrivée, non?
Ben non...
$tab[0] = 'A'; $tab[2] = 'C': $tab[1] = 'B';
Maintenant, fait un foreach... Bon, faut aussi vouloir affecter un tableau de cette façon, hein.
-- Jaco
In article <pan.2005.05.14.17.11.48.33498@imaginet.fr>,
Emmanuel Florac <eflorac@imaginet.fr> wrote:
J'ai pas compris. Si tu as un tableau, le seul ordre qui compte c'est
l'ordre du tableau, et si tu insères des éléments dans un tableau, ils
sont forcément numérotés par ordre d'arrivée, non?
Ben non...
$tab[0] = 'A';
$tab[2] = 'C':
$tab[1] = 'B';
Maintenant, fait un foreach... Bon, faut aussi vouloir affecter un
tableau de cette façon, hein.
J'ai pas compris. Si tu as un tableau, le seul ordre qui compte c'est l'ordre du tableau, et si tu insères des éléments dans un tableau, ils sont forcément numérotés par ordre d'arrivée, non?
Ben non...
$tab[0] = 'A'; $tab[2] = 'C': $tab[1] = 'B';
Maintenant, fait un foreach... Bon, faut aussi vouloir affecter un tableau de cette façon, hein.
-- Jaco
Richard Delorme
Ça j'arrive à le concevoir. Les [] servent à définir des listes et non des ensembles. Programmer, ce n'est pas nécessairement faire des mathématiques,
C'est pas Dijkstra qui disait que la programmation était une des branches les plus difficiles des mathématiques appliquées ?
Dans son cas c'était plutôt une branche de la physique théorique.
A part montrer que Hope est plus verbeux et moins lisible que Haskell, je ne vois pas l'intérêt de cet exemple.
Juste que c'est pareil, à trois virgules près, donc que les différences de syntaxe on s'en tamponne grave.
Quand je vois, dans un tutorial sur Ocaml, trois pages pour expliquer quand on peut mettre zéro, un ou trois point-virgules, je trouve que ces histoires de virgules ne sont pas si anecdotiques.
Que le quicksort soit de complexité quadratique dans le pire des cas n'est pas lié à la concaténation.
Non. La concaténation foireuse augmente le temps de calcul (qui a déja pris des coups dans les plumes par deux balayages de la liste),
Ça dépend. Pour un langage interprété comme Python c'est l'interprétation du code qui est le facteur limitant. Il faut sans doute mieux plusieurs balayages de la liste par des outils du langage (comme les listes en extension ou la concaténation), qu'un seul balayage par une boucle entièrement interprétée.
pas la complexité.
Pourtant j'avais cru lire : « Un quicksort quadratique à cause de la concaténation.»
J'avoue ne pas comprendre le problème.
Que quand quelqu'un me dit que le chronométrage n'a pas l'air quadratique, je doute un peu qu'il ait vraiment testé sérieusement sur un paquet d'exemples aléatoires bien choisis !
#-------8<------------------ import time, random
def qsort(x): if len(x) > 1: lt = [i for i in x if i < x[0] ] eq = [i for i in x if i == x[0]] gt = [i for i in x if i > x[0]] return qsort(lt) + eq + qsort(gt) else: return x
if __name__ == "__main__": print "taillettemps" random.seed() for n in (10000, 20000, 40000, 80000, 160000, 320000, 640000): l = [random.randrange(1000000) for i in range(n)] t = time.clock() qsort(l) t = time.clock() - t print n, 't', t #-------8<------------------
Que le quicksort à partir d'un pivot fixe soit quadratique dans le pire des cas, je le sais ; que le quicksort soit inefficace sur les petites listes, je le sais aussi; et que Python ne brille pas par ses performances est encore une évidence. Par contre, que l'implémentation ci-dessus soit quadratique à cause de la concaténation, j'en doute.
-- Richard
Ça j'arrive à le concevoir. Les [] servent à définir des listes et non
des ensembles. Programmer, ce n'est pas nécessairement faire des
mathématiques,
C'est pas Dijkstra qui disait que la programmation était une des branches
les plus difficiles des mathématiques appliquées ?
Dans son cas c'était plutôt une branche de la physique théorique.
A part montrer que Hope est plus verbeux et moins lisible que Haskell,
je ne vois pas l'intérêt de cet exemple.
Juste que c'est pareil, à trois virgules près, donc que les
différences de syntaxe on s'en tamponne grave.
Quand je vois, dans un tutorial sur Ocaml, trois pages pour expliquer
quand on peut mettre zéro, un ou trois point-virgules, je trouve que
ces histoires de virgules ne sont pas si anecdotiques.
Que le quicksort soit de complexité quadratique dans le pire des cas
n'est pas lié à la concaténation.
Non. La concaténation foireuse augmente le temps de calcul (qui a déja
pris des coups dans les plumes par deux balayages de la liste),
Ça dépend. Pour un langage interprété comme Python c'est
l'interprétation du code qui est le facteur limitant. Il faut sans doute
mieux plusieurs balayages de la liste par des outils du langage (comme
les listes en extension ou la concaténation), qu'un seul balayage par
une boucle entièrement interprétée.
pas la complexité.
Pourtant j'avais cru lire :
« Un quicksort quadratique à cause de la concaténation.»
J'avoue ne pas comprendre le problème.
Que quand quelqu'un me dit que le chronométrage n'a pas l'air
quadratique, je doute un peu qu'il ait vraiment testé sérieusement sur
un paquet d'exemples aléatoires bien choisis !
#-------8<------------------
import time, random
def qsort(x):
if len(x) > 1:
lt = [i for i in x if i < x[0] ]
eq = [i for i in x if i == x[0]]
gt = [i for i in x if i > x[0]]
return qsort(lt) + eq + qsort(gt)
else:
return x
if __name__ == "__main__":
print "taillettemps"
random.seed()
for n in (10000, 20000, 40000, 80000, 160000, 320000, 640000):
l = [random.randrange(1000000) for i in range(n)]
t = time.clock()
qsort(l)
t = time.clock() - t
print n, 't', t
#-------8<------------------
Que le quicksort à partir d'un pivot fixe soit quadratique dans le pire
des cas, je le sais ; que le quicksort soit inefficace sur les petites
listes, je le sais aussi; et que Python ne brille pas par ses
performances est encore une évidence. Par contre, que l'implémentation
ci-dessus soit quadratique à cause de la concaténation, j'en doute.
Ça j'arrive à le concevoir. Les [] servent à définir des listes et non des ensembles. Programmer, ce n'est pas nécessairement faire des mathématiques,
C'est pas Dijkstra qui disait que la programmation était une des branches les plus difficiles des mathématiques appliquées ?
Dans son cas c'était plutôt une branche de la physique théorique.
A part montrer que Hope est plus verbeux et moins lisible que Haskell, je ne vois pas l'intérêt de cet exemple.
Juste que c'est pareil, à trois virgules près, donc que les différences de syntaxe on s'en tamponne grave.
Quand je vois, dans un tutorial sur Ocaml, trois pages pour expliquer quand on peut mettre zéro, un ou trois point-virgules, je trouve que ces histoires de virgules ne sont pas si anecdotiques.
Que le quicksort soit de complexité quadratique dans le pire des cas n'est pas lié à la concaténation.
Non. La concaténation foireuse augmente le temps de calcul (qui a déja pris des coups dans les plumes par deux balayages de la liste),
Ça dépend. Pour un langage interprété comme Python c'est l'interprétation du code qui est le facteur limitant. Il faut sans doute mieux plusieurs balayages de la liste par des outils du langage (comme les listes en extension ou la concaténation), qu'un seul balayage par une boucle entièrement interprétée.
pas la complexité.
Pourtant j'avais cru lire : « Un quicksort quadratique à cause de la concaténation.»
J'avoue ne pas comprendre le problème.
Que quand quelqu'un me dit que le chronométrage n'a pas l'air quadratique, je doute un peu qu'il ait vraiment testé sérieusement sur un paquet d'exemples aléatoires bien choisis !
#-------8<------------------ import time, random
def qsort(x): if len(x) > 1: lt = [i for i in x if i < x[0] ] eq = [i for i in x if i == x[0]] gt = [i for i in x if i > x[0]] return qsort(lt) + eq + qsort(gt) else: return x
if __name__ == "__main__": print "taillettemps" random.seed() for n in (10000, 20000, 40000, 80000, 160000, 320000, 640000): l = [random.randrange(1000000) for i in range(n)] t = time.clock() qsort(l) t = time.clock() - t print n, 't', t #-------8<------------------
Que le quicksort à partir d'un pivot fixe soit quadratique dans le pire des cas, je le sais ; que le quicksort soit inefficace sur les petites listes, je le sais aussi; et que Python ne brille pas par ses performances est encore une évidence. Par contre, que l'implémentation ci-dessus soit quadratique à cause de la concaténation, j'en doute.
-- Richard
Emmanuel Florac
Le Sat, 14 May 2005 19:28:41 +0200, Eric Jacoboni a écrit :
Maintenant, fait un foreach... Bon, faut aussi vouloir affecter un tableau de cette façon, hein.
Ça ne fait que confirmer ce que je pensais : PHP c'est vraiment de la merde en barre.
-- on passe la moitié de son temps à refaire ce que l'on n'a pas eu le temps de faire correctement. Loi de Myers.
Le Sat, 14 May 2005 19:28:41 +0200, Eric Jacoboni a écrit :
Maintenant, fait un foreach... Bon, faut aussi vouloir affecter un tableau
de cette façon, hein.
Ça ne fait que confirmer ce que je pensais : PHP c'est vraiment de la
merde en barre.
--
on passe la moitié de son temps à refaire ce que l'on n'a pas eu le
temps de faire correctement.
Loi de Myers.
Le Sat, 14 May 2005 19:28:41 +0200, Eric Jacoboni a écrit :
Maintenant, fait un foreach... Bon, faut aussi vouloir affecter un tableau de cette façon, hein.
Ça ne fait que confirmer ce que je pensais : PHP c'est vraiment de la merde en barre.
-- on passe la moitié de son temps à refaire ce que l'on n'a pas eu le temps de faire correctement. Loi de Myers.
talon
Richard Delorme wrote:
#-------8<------------------ import time, random
def qsort(x): if len(x) > 1: lt = [i for i in x if i < x[0] ] eq = [i for i in x if i == x[0]] gt = [i for i in x if i > x[0]] return qsort(lt) + eq + qsort(gt) else: return x
if __name__ == "__main__": print "taillettemps" random.seed() for n in (10000, 20000, 40000, 80000, 160000, 320000, 640000): l = [random.randrange(1000000) for i in range(n)] t = time.clock() qsort(l) t = time.clock() - t print n, 't', t #-------8<------------------
Que le quicksort à partir d'un pivot fixe soit quadratique dans le pire des cas, je le sais ; que le quicksort soit inefficace sur les petites listes, je le sais aussi; et que Python ne brille pas par ses performances est encore une évidence. Par contre, que l'implémentation ci-dessus soit quadratique à cause de la concaténation, j'en doute.
En fait en adaptant le programme se trouvant ici: http://www.hetland.org/python/quicksort.html qui certes est moins concis que celui ci-dessus, mais a l'avantage de ressembler directement au quicksort classique en C et d'éviter les concaténations de listes perpétuelles, je trouve exactement la même progression linéaire en n et un temps d'exécution divisé par 2.
--
Michel TALON
Richard Delorme <abulmo@nospam.fr> wrote:
#-------8<------------------
import time, random
def qsort(x):
if len(x) > 1:
lt = [i for i in x if i < x[0] ]
eq = [i for i in x if i == x[0]]
gt = [i for i in x if i > x[0]]
return qsort(lt) + eq + qsort(gt)
else:
return x
if __name__ == "__main__":
print "taillettemps"
random.seed()
for n in (10000, 20000, 40000, 80000, 160000, 320000, 640000):
l = [random.randrange(1000000) for i in range(n)]
t = time.clock()
qsort(l)
t = time.clock() - t
print n, 't', t
#-------8<------------------
Que le quicksort à partir d'un pivot fixe soit quadratique dans le pire
des cas, je le sais ; que le quicksort soit inefficace sur les petites
listes, je le sais aussi; et que Python ne brille pas par ses
performances est encore une évidence. Par contre, que l'implémentation
ci-dessus soit quadratique à cause de la concaténation, j'en doute.
En fait en adaptant le programme se trouvant ici:
http://www.hetland.org/python/quicksort.html
qui certes est moins concis que celui ci-dessus, mais a
l'avantage de ressembler directement au quicksort classique en C et
d'éviter les concaténations de listes perpétuelles, je trouve
exactement la même progression linéaire en n et un temps d'exécution divisé
par 2.
def qsort(x): if len(x) > 1: lt = [i for i in x if i < x[0] ] eq = [i for i in x if i == x[0]] gt = [i for i in x if i > x[0]] return qsort(lt) + eq + qsort(gt) else: return x
if __name__ == "__main__": print "taillettemps" random.seed() for n in (10000, 20000, 40000, 80000, 160000, 320000, 640000): l = [random.randrange(1000000) for i in range(n)] t = time.clock() qsort(l) t = time.clock() - t print n, 't', t #-------8<------------------
Que le quicksort à partir d'un pivot fixe soit quadratique dans le pire des cas, je le sais ; que le quicksort soit inefficace sur les petites listes, je le sais aussi; et que Python ne brille pas par ses performances est encore une évidence. Par contre, que l'implémentation ci-dessus soit quadratique à cause de la concaténation, j'en doute.
En fait en adaptant le programme se trouvant ici: http://www.hetland.org/python/quicksort.html qui certes est moins concis que celui ci-dessus, mais a l'avantage de ressembler directement au quicksort classique en C et d'éviter les concaténations de listes perpétuelles, je trouve exactement la même progression linéaire en n et un temps d'exécution divisé par 2.
--
Michel TALON
talon
Richard Delorme wrote:
#-------8<------------------ import time, random
def qsort(x): if len(x) > 1: lt = [i for i in x if i < x[0] ] eq = [i for i in x if i == x[0]] gt = [i for i in x if i > x[0]] return qsort(lt) + eq + qsort(gt) else: return x
if __name__ == "__main__": print "taillettemps" random.seed() for n in (10000, 20000, 40000, 80000, 160000, 320000, 640000): l = [random.randrange(1000000) for i in range(n)] t = time.clock() qsort(l) t = time.clock() - t print n, 't', t #-------8<------------------
Que le quicksort à partir d'un pivot fixe soit quadratique dans le pire des cas, je le sais ; que le quicksort soit inefficace sur les petites listes, je le sais aussi; et que Python ne brille pas par ses performances est encore une évidence. Par contre, que l'implémentation ci-dessus soit quadratique à cause de la concaténation, j'en doute.
En fait en adaptant le programme se trouvant ici: http://www.hetland.org/python/quicksort.html qui certes est moins concis que celui ci-dessus, mais a l'avantage de ressembler directement au quicksort classique en C et d'éviter les concaténations de listes perpétuelles, je trouve exactement la même progression linéaire en n et un temps d'exécution divisé par 2.
Le même en Java http://www.sourcecodesworld.com/articles/java/java-data-structures/Sorting_using_Quicksort.asp prend moins d'une seconde sur le tableau de taille 640000.
--
Michel TALON
Richard Delorme <abulmo@nospam.fr> wrote:
#-------8<------------------
import time, random
def qsort(x):
if len(x) > 1:
lt = [i for i in x if i < x[0] ]
eq = [i for i in x if i == x[0]]
gt = [i for i in x if i > x[0]]
return qsort(lt) + eq + qsort(gt)
else:
return x
if __name__ == "__main__":
print "taillettemps"
random.seed()
for n in (10000, 20000, 40000, 80000, 160000, 320000, 640000):
l = [random.randrange(1000000) for i in range(n)]
t = time.clock()
qsort(l)
t = time.clock() - t
print n, 't', t
#-------8<------------------
Que le quicksort à partir d'un pivot fixe soit quadratique dans le pire
des cas, je le sais ; que le quicksort soit inefficace sur les petites
listes, je le sais aussi; et que Python ne brille pas par ses
performances est encore une évidence. Par contre, que l'implémentation
ci-dessus soit quadratique à cause de la concaténation, j'en doute.
En fait en adaptant le programme se trouvant ici:
http://www.hetland.org/python/quicksort.html
qui certes est moins concis que celui ci-dessus, mais a
l'avantage de ressembler directement au quicksort classique en C et
d'éviter les concaténations de listes perpétuelles, je trouve
exactement la même progression linéaire en n et un temps d'exécution divisé
par 2.
Le même en Java
http://www.sourcecodesworld.com/articles/java/java-data-structures/Sorting_using_Quicksort.asp
prend moins d'une seconde sur le tableau de taille 640000.
def qsort(x): if len(x) > 1: lt = [i for i in x if i < x[0] ] eq = [i for i in x if i == x[0]] gt = [i for i in x if i > x[0]] return qsort(lt) + eq + qsort(gt) else: return x
if __name__ == "__main__": print "taillettemps" random.seed() for n in (10000, 20000, 40000, 80000, 160000, 320000, 640000): l = [random.randrange(1000000) for i in range(n)] t = time.clock() qsort(l) t = time.clock() - t print n, 't', t #-------8<------------------
Que le quicksort à partir d'un pivot fixe soit quadratique dans le pire des cas, je le sais ; que le quicksort soit inefficace sur les petites listes, je le sais aussi; et que Python ne brille pas par ses performances est encore une évidence. Par contre, que l'implémentation ci-dessus soit quadratique à cause de la concaténation, j'en doute.
En fait en adaptant le programme se trouvant ici: http://www.hetland.org/python/quicksort.html qui certes est moins concis que celui ci-dessus, mais a l'avantage de ressembler directement au quicksort classique en C et d'éviter les concaténations de listes perpétuelles, je trouve exactement la même progression linéaire en n et un temps d'exécution divisé par 2.
Le même en Java http://www.sourcecodesworld.com/articles/java/java-data-structures/Sorting_using_Quicksort.asp prend moins d'une seconde sur le tableau de taille 640000.
--
Michel TALON
Richard Delorme
En fait en adaptant le programme se trouvant ici: http://www.hetland.org/python/quicksort.html qui certes est moins concis que celui ci-dessus, mais a l'avantage de ressembler directement au quicksort classique en C et d'éviter les concaténations de listes perpétuelles, je trouve exactement la même progression linéaire en n et un temps d'exécution divisé par 2.
Outre la concision, on perd malheureusement une propriété intéressante de la version avec concaténation : la stabilité du tri.
Le même en Java http://www.sourcecodesworld.com/articles/java/java-data-structures/Sorting_using_Quicksort.asp prend moins d'une seconde sur le tableau de taille 640000.
Sur x86, on peut obtenir les même gains qu'avec la version Java en installant psyco¹, et en ajoutant les lignes suivantes au programme python : try: import psyco psyco.full() except: print "Installer psyco pour de meilleurs performances."
¹ http://psyco.sourceforge.net/
-- Richard
En fait en adaptant le programme se trouvant ici:
http://www.hetland.org/python/quicksort.html
qui certes est moins concis que celui ci-dessus, mais a
l'avantage de ressembler directement au quicksort classique en C et
d'éviter les concaténations de listes perpétuelles, je trouve
exactement la même progression linéaire en n et un temps d'exécution divisé
par 2.
Outre la concision, on perd malheureusement une propriété intéressante
de la version avec concaténation : la stabilité du tri.
Le même en Java
http://www.sourcecodesworld.com/articles/java/java-data-structures/Sorting_using_Quicksort.asp
prend moins d'une seconde sur le tableau de taille 640000.
Sur x86, on peut obtenir les même gains qu'avec la version Java en
installant psyco¹, et en ajoutant les lignes suivantes au programme python :
try:
import psyco
psyco.full()
except:
print "Installer psyco pour de meilleurs performances."
En fait en adaptant le programme se trouvant ici: http://www.hetland.org/python/quicksort.html qui certes est moins concis que celui ci-dessus, mais a l'avantage de ressembler directement au quicksort classique en C et d'éviter les concaténations de listes perpétuelles, je trouve exactement la même progression linéaire en n et un temps d'exécution divisé par 2.
Outre la concision, on perd malheureusement une propriété intéressante de la version avec concaténation : la stabilité du tri.
Le même en Java http://www.sourcecodesworld.com/articles/java/java-data-structures/Sorting_using_Quicksort.asp prend moins d'une seconde sur le tableau de taille 640000.
Sur x86, on peut obtenir les même gains qu'avec la version Java en installant psyco¹, et en ajoutant les lignes suivantes au programme python : try: import psyco psyco.full() except: print "Installer psyco pour de meilleurs performances."
Le même en Java http://www.sourcecodesworld.com/articles/java/java-data-structures/Sorting_using_Quicksort.asp prend moins d'une seconde sur le tableau de taille 640000.
Oui mais chacun sait que Java et PHP etc.
MB
-- Michel BILLAUD LABRI-Université Bordeaux I tel 05 4000 6922 / 05 5684 5792 351, cours de la Libération http://www.labri.fr/~billaud 33405 Talence (FRANCE)
Le même en Java
http://www.sourcecodesworld.com/articles/java/java-data-structures/Sorting_using_Quicksort.asp
prend moins d'une seconde sur le tableau de taille 640000.
Oui mais chacun sait que Java et PHP etc.
MB
--
Michel BILLAUD billaud@labri.fr
LABRI-Université Bordeaux I tel 05 4000 6922 / 05 5684 5792
351, cours de la Libération http://www.labri.fr/~billaud
33405 Talence (FRANCE)
Le même en Java http://www.sourcecodesworld.com/articles/java/java-data-structures/Sorting_using_Quicksort.asp prend moins d'une seconde sur le tableau de taille 640000.
Oui mais chacun sait que Java et PHP etc.
MB
-- Michel BILLAUD LABRI-Université Bordeaux I tel 05 4000 6922 / 05 5684 5792 351, cours de la Libération http://www.labri.fr/~billaud 33405 Talence (FRANCE)
Michel Billaud
Richard Delorme writes:
pas la complexité.
Pourtant j'avais cru lire : « Un quicksort quadratique à cause de la concaténation.»
C'est pas parce que j'écris des conneries qu'il faut les relever !
MB -- Michel BILLAUD LABRI-Université Bordeaux I tel 05 4000 6922 / 05 5684 5792 351, cours de la Libération http://www.labri.fr/~billaud 33405 Talence (FRANCE)
Richard Delorme <abulmo@nospam.fr> writes:
pas la complexité.
Pourtant j'avais cru lire :
« Un quicksort quadratique à cause de la concaténation.»
C'est pas parce que j'écris des conneries qu'il faut les relever !
MB
--
Michel BILLAUD billaud@labri.fr
LABRI-Université Bordeaux I tel 05 4000 6922 / 05 5684 5792
351, cours de la Libération http://www.labri.fr/~billaud
33405 Talence (FRANCE)
Pourtant j'avais cru lire : « Un quicksort quadratique à cause de la concaténation.»
C'est pas parce que j'écris des conneries qu'il faut les relever !
MB -- Michel BILLAUD LABRI-Université Bordeaux I tel 05 4000 6922 / 05 5684 5792 351, cours de la Libération http://www.labri.fr/~billaud 33405 Talence (FRANCE)
