Recherche:

pas trop, nan... le code asm généré par un compilateur est moche, à la limite de l'illisible, j'ai déjà donné durant mon stage :aie:

ben oui, tout pareil... mais ne te prends pas la tête pour cela, je demanderais moi-même quand je les verrais ;)

merci, mais je sais relativement bien comment calculer un temps d'exécution réaliste pour un programme donné... ;)


mon programme ne travaillait qu'en mémoire, sans aucun accès à un...

d'expérience, je peux affirmer que c'est faux... pas plus tard que cette semaine, j'ai compilé avec ocamlopt -ccopt -02, et sur une moyenne pour 1000 exécutions, j'ai gagné 1s (l'exécution durant en...

ça doit être là que je l'ai lu effectivement... où quelqu'un a parlé de ce papier pendant un de mes cours ;)




il est clair qu'ocamlopt optimise plus que ghc par défaut... ;)
mais il est vrai...

ça doit exister... mais l'algo serait NP-difficile :aie:

je parlais de la transformation d'une fonction primitive ne faisant qu'un appel récursif, et utilisant des types simples


pour ce qui...

pour l'algo je pensais à un truc du style


let rec fact n =
match n with
0 -> 1
|_ -> n * fact (n-1)
;;

let fact2 n =

pour l'algo je pensais à un truc du style


let rec fact n =
match n with
0 -> 1
|_ -> n * fact (n-1)
;;

let fact2 n =

pas cool... pourtant l'optimisation existe belle et bien, j'avais pensé qu'elle serait déjà dans ocaml :?

avec les optimisations d'un compilateur non... suffit qu'elle soit primitive :aie:

l'écriture telle que tu le fais sera en revanche bien plus performant dans la boucle d'interprétation ;)

il était tard, et j'étais énervé... donc j'ai répondu un peu vite, et donné la solution au bout de quelques minutes de reflexion. j'aurais du lui en faire baver un peu plus ;)



gni 8O ?

pas mal, c'est l'idée... j'aurais préféré que tu dises que :
1) la longueur de l'argument passé en paramètre lors des appels récursifs est strictement décroissante.
2) toute suite d'entiers...

sans doute, il est tard et j'ai eu une très mauvaise semaine... :cry:






j'ai bien compris que tu cherchais de l'aide. d'ailleurs, tu avais commencé à coder quelque chose... je t'avais...

let rec elimine_doublon l =
match l with
[] -> []
|a::q -> if (appartient a q) then elimine_doublon q else a::(elimine_doublon q)
;;



je fais avoir du mal à croire que tu aies...

étant donné que ce n'est qu'un bloc utile, je te le donne... même si avec un peu de reflexion, tu aurais du y arriver (ou alors tu as de gros soucis à te faire pour ton exam !!!)




let rec...

let rec appartient e l =
match l with
[] -> false
|a::_ where a=e -> true
|_::q -> appartient e q
;;

j'ai fait exprès de ne pas te donner la version fonctionnelle, ce qui aurait été équivalent à te donner le programme déjà coder... traduis toi-même ;)


nb: on se moque du type de l'élément, ocaml...

si tu montrais ton code, on essaierait de le corriger... mais on ne va pas te le faire ;)


l'algo simple serait de cette forme :


L = liste
res = Liste vide
tant que L non vide faire
a...