Discussion :

[Erwane]

Bonsoir , je réfléchis depuis quelques minutes à un probleme , je souhaite créer une fonction qui prend en paramètre une liste et qui rend sous forme de doublet le nombre de nombres pairs et celui des impairs , par exemple :

(fonction (list 1 2 3)) -> (1 2)

Donc comme algorithme j'ai pensé à ceci :

Si la liste n'est pas vide et si le nombre est pair , on construit une liste qui itère les nombres pairs , sinon on construit une liste qui itère les nombres impairs .

Avant d'entrer dans le code ( comme tu conseilles garu ) je voudrais vous demander si mon algo tient la route , j'ai pas l'impression , ya une sorte de contradiction . Mon idée c'est de créer 2 listes qui logiquement s'itèrent vu que le nombre est soit pair ou impair .

Voilà , si quelqu'un possède un avis..merci bien .

[jmi23]

(define (paire l)
(if (pair? l)
(if (even? (car l))
(+ 1 (paire (cdr l)))
(paire (cdr l)))
0)
)

ça c'est pour calculer le nombre de chiffres pairs, ensuite il suffit de soustraire ce résultat au nombre d'éléments de la liste et du obtiens le nombre de chiffres impairs.

[Erwane]

le résultat il est sous quelle donnée dans ton programme principal ?

[jmi23]

> (paire '(1 2 3 8))
2
>

[Erwane]

non mais ça je le sais bien , je savais calculer les nombres pairs depuis longtemps , là n'est pas la question , relis moi bien

[jmi23]

j'essaie de voir

[Jedai]

Un petit foldl ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
(define (even-odd-count xs)
  (foldl (lambda (x counts)
           (let ([evens (car counts)]
                 [odds (cadr counts)])
             (if (even? x)
                 (list (+ evens 1) odds)
                 (list evens (+ odds 1))
                 )
             )
           ) '(0 0) xs)
  )

Mais je dois dire que la proposition de jmi23 a ses mérites, même si elle demande deux parcours de la liste au lieu d'un :

ça c'est pour calculer le nombre de chiffres pairs, ensuite il suffit de soustraire ce résultat au nombre d'éléments de la liste et du obtiens le nombre de chiffres impairs.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
(define (even-count xs)
  (foldl (lambda (x evens) (if (even? x) (+ evens 1) evens)) 0 xs)
  )

(define (even-odd-count xs)
  (let ([evens (even-count xs)]) (list evens (- (length xs) evens)))
  )

--
Jedaï

[GnuVince]

Avec une fonction récursive simple.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
(define (count-evens-odds xs)
  (define (count-evens-odds-aux xs evens odds)
    (if (null? xs)
        (list evens odds)
        (if (even? (car xs))
            (count-evens-odds-aux (cdr xs) (+ 1 evens) odds)
            (count-evens-odds-aux (cdr xs) evens (+ 1 odds)))))
  (count-evens-odds-aux xs 0 0))

[Erwane]

oui mais en fait j'ai oublié de préciser une chose , vos réponses sont trop complexes , elles utilisent pleins de choses que je n'ai pas vu en cours , count , null , aux...tout ceci est inconnu pour moi , revenons à mon algo , est il juste svp ?

merci

[GnuVince]

oui mais en fait j'ai oublié de préciser une chose , vos réponses sont trop complexes , elles utilisent pleins de choses que je n'ai pas vu en cours , count , null , aux...tout ceci est inconnu pour moi , revenons à mon algo , est il juste svp ?

merci

count est une variable, aux fait partie du nom d'une fonction. Et si t'as pas vu null?, tu peux pas résoudre ce problème.

[Erwane]

salut vince , en fait non je n'ai pas vu null et on m'a assuré qu'on pouvait écrire cette fonction avec simplement car , cdr , une récurisivité , odd , even , mais rien d'autre , est ce que mon algo tient la route , car c'est quand meme ça ma question initiale...

[GnuVince]

salut vince , en fait non je n'ai pas vu null et on m'a assuré qu'on pouvait écrire cette fonction avec simplement car , cdr , une récurisivité , odd , even , mais rien d'autre , est ce que mon algo tient la route , car c'est quand meme ça ma question initiale...

Tu as besoin de null? pour pouvoir faire arrêter ta récursivité un moment donné. Juste dans la description que tu as donné dans ton message initial montre que tu veux t'en servir.

null? retourne vrai si une liste est vide, faux autrement.

[Erwane]

malgré mon faible niveau je suis pas entièrement d'accord avec toi , pour arreter la récurisivté je peux le faire dans une alternative if au début . Je veux avoir le nombre de pairs et de impairs sous forme de doublet , donc j'aurais 1 cons e tun list pour construire ma liste (x y) .

Le début de la fonction se présente ainsi pour moi , elle prend une liste en argument :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
(define (pairs-impairs L)
  (if (pair? L)
     (if (even? car L)
       (+ 1 (pairs-impairs (cdr L))

donc arrivé ici je compte les nombres pairs tu es d'accord , mais je dois aussi compter les nombres impairs , et je me doute où et comment les compter...

[GnuVince]

on m'a assuré qu'on pouvait écrire cette fonction avec simplement car , cdr , une récurisivité , odd , even , mais rien d'autre

Tu as pas mentionné pair? dans la liste de fonctions dont tu pouvais te servir. pair? est pratiquement null? à l'envers. Il retourne vrai si la liste a au moins un élément, et faux si la liste est vide.

Mais comme tu vois, tu ne peux pas écrire une fonction récursive sans cas de base, et dans le cas des liste, le cas de base c'est si la liste est vide ou non.

Pis pour ton algorithme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Fonction compte_pairs_impairs(L, pairs, impairs)
Si L est vide:
  retourne la liste (pairs, impairs)
Sinon:
  Si le premier élément de L est pair:
    compte_pairs_impairs(reste de L, pairs + 1, impairs)
  Sinon
    compte_pairs_impairs(reste de L, pairs, impairs + 1)

[Erwane]

merci j'ai bien compris l'algo , c'est ce que je pensais au départ mais par contre vince pour cette ligne :

" compte_pairs_impairs(reste de L, pairs + 1, impairs)"

je vois pas comment la traduire , j'essaye quand meme :

compte_pairs_impairs( (cdr L) , evens + 1 , odds )

là franchement je sais pas quoi écrire car la fonction à la base ne prend qu'un argument , la liste , ici ton algo lui donne 3 arguments...

[GnuVince]

Il te faut une fonction auxilière comme j'ai fait.

[Erwane]

mais ils sont débiles ou quoi ceux qui donnent les exercices , je n'ai jamais vu ce que c'est une fonction auxiliaire ni meme une construction avec 2 define donc je suis coincé , bon pas grave merci bcp pour ton aide .

[Erwane]

ça ira j'ai trouvé des tutos sur la structure que vous proposez , je vais réussir , merci bcp encore

[Erwane]

j'ai presque réussi ya juste un petit hic de syntaxe , regardez :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
(define (P-I L)
  (define (paire L)
    (if (pair? L)
      (if (even? (car L))
        (+ 1 (paire (cdr L)))
          (paire (cdr L)))
            0))
  (cons (paire L) (cons(- (paire L) L)))

le probleme ici vient juste de ma derniere ligne , que j'emploie list ou cons j'arrive pas à contruire mon doublet...car à chaque fois cons attend un argument de type nombre , quelqu'un a une petite idée pour celà ?

[Garulfo]

Tu as besoin de null? pour pouvoir faire arrêter ta récursivité un moment donné.

En fait, Erwane peut utiliser (eq? '() liste) pour remplacer (null? liste)