Putain personne a un moyen efficace de vérifier si une liste de nombres contient des nombres positifs et négatifs alternativement?

Je galère depuis tout à l'heure sur ce truc de merde

Genre qui renvoie vrai si j'ai

[1,-1,2,-4] ou [-1,1,-3,1] mais faux si j'ai [-1,-1,1,1,1]

en courant*

Heureusement y'a une interface « Skype pour bureau Windows » qui est acceptable, mais c'est pas plus simple à installer que Pidgin.

Si en multipliant deux nombre consécutif t'obtiens un nombre positif c'est que ça alterne pas

@JameaGourmand assert((tab[i] > 0 && tab[i - 1] < 0) || tab [i - 1] > 0)

Mon code passe pas les tests en fait, /ignore. (Je parle décidément trop vite aujourd'hui.)

assert(tab[i] > 0 ? tab[i - 1] < 0 : tab[i - 1] > 0);

Ou pour pas faire le -1 deux fois :

assert(tab[i - 1] > 0 ? tab[i] < 0 : tab[i] > 0);

Ouais mais tu vérifies que les bornes là, si j'ai un nombre impair d'élements ça ne fonctionne pas tout le temps

Ouais je crois que je vais faire ça, encore faudrait-il pouvoir grouper deux élements consécutifs entre eux (je le fais en Haskell )

@JameaGourmand Comment ça vérifier que les bornes ?

Ah oui j'ai oublié de préciser, pour ma version faut sauter le premier élément (puisqu'il est checké avec le i-1).

Et c'est pas ce qu'on fait de plus opti non plus vu qu'on vérifie à chaque fois le signe du nombre précédent, ça pourrait être gardé en mémoire.

assert(length > 0);

bool positive = tab[0] > 0; // Ou >= selon tes critères
size_t i;

for (i = 1; i < length; i++) {
assert(positive ? tab[i] < 0 : tab[i] > 0);
positive = !positive;
}

Bah en langage impératif c'est immédiat en effet, j'ai réussi à faire un truc qui fonctionne mais qui est très très sale

http://pastebin.com/X0C30sAR

Bah dans ton truc tu vérifiais que les bornes de la liste, sauf là ou tu fais une boucle

ça y est, la fibre est passée en phase de commercialisation pour mon village \ /

Ya une réunion de présentation le 28 \ /

J'vais pouvoir shitposter à vitesse grand V.

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