JameaGourmand C'est parce que tu ne maîtrise pas la puissance des fonctions d'ordre supérieur
http://paste.isomorphis.me/chouhartem/hF8

Sinon non, j'ai chié le concours, du coup je suis rentré sur dossier

Ouais j'ai abordé les fonctions d'ordre supérieur mais ce genre de code par exemple j'arrive pas à le comprendre

Pourquoi je suis pourri

Bon d'un côté ça fait moins d'une semaine que j'ai commencé le Haskell

T'es bon en Haskell

Absolument pas, c'est de l'OCaml que je t'ai pondu :noel.

Putain ça se ressemble

Je me disais quand j'ai vu le let rec J'imagine que les similarités sont dûes au paradigme fonctionnel

Combien d'années avant de comprendre ce code?

J'ai déjà fais de l'OCaml... mais sans jamais biter aux histoires de complexités.

O(n²) et compagnie

JamyGourmand Oui, c'est pour ça que je me suis permis de répondre avec ça

Si tu veux la traduction de mon code en Haskell, voilà un article introductif sur le sujet : http://science.raphael.poss.name/haskell-for-ocaml-programmers.html

Ya rien de compliqué dans mon code, faut juste avoir le réflexe de penser aux fonctions préétablies comme for_all pour tester si une propriété est vraie pour tout (et |> c'est l'opérateur de composition inverse, c'est juste pour la lisibilité)

Nh3xus La complexité c'est pas que de l'OCaml, tu retrouves ça partout en algorithmique

Je sais, mais c'est en cours de OCaml que j'ai été introduit à ces notions de complexité.

@JameaGourmand en Haskell j'aurais fait ça, mais on doit pouvoir faire mieux vu mon niveau dans ce langage.

https://gist.github.com/aanonymous/ed1c53aa1a2a540d31d9

@Nh3xus Pour vulgariser, la notation O() permet de calculer une relation entre la taille d'un input et un observable (temps d'exécution ou utilisation mémoire en général).

Typiquement « la quantité de mémoire utilisée sera proportionnel au nombre d'élément en entrée » (O(n)) et « la quantité de mémoire utilisée sera constante » (O(1)).

Sympa l'article j'irais lire

En effet pas mal le code vava j'aurais pas pensé comme ça, c'est déjà plus simple

Bam, one-liner trouvé basé sur le trick « tl l et l sont décalés d'une case » :

let is_alternate l = try List.for_all2 (fun a b -> a*b<=0) l (0::l) with _ -> true

En temps : O(n) (on peut pas faire mieux) et surcoût mémoire O(1) (genre précedemment ça devait évaluer la liste (l[i],l[i-1]) -> O(n) en plus en mémoire).

coloration : http://paste.isomorphis.me/Chouhartem/9xC

Nh3xus C'est dommage parce que c'est toujours utile pour évaluer les perfs de ses algos comme j'ai fait

Je sais...

J'espère raccrocher un jour là dessus.

Achète le Cormen

Il m'a rendu de fiers services la veille de partiels

GGs

Vivement que j'ai de vrais cours d'informatique

Sinon elle s'apelle comment l'opération qui consiste à prendre une liste et consiste à la regrouper en des morceaux de n élements tout en considérant toutes les possibilités?

Genre

f [1,2,3,4] 2 = [[1,2],[1,3],[1,4],[2,3],[3,4]]

?

J'en oublie volontairement car c'est pour tester toutes les possibilités d'addition et de multiplication et ce sont des opérations commutatives

Je suis en train de refaire mon algo qui résouds un polynôme par les relations coefficients-racines

J'ai oublié [2,4] d'ailleurs

Y'a combinaisons et permutations, je sais plus lequel c'est dans ce cas particulier.

Ouais voilà j'hésite entre ces deux là

RTFM.

list(itertools.combinations([1,2,3,4], 2))

[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

Okay je vais essayer de faire un truc avec les combinaisons