(define LVal '(1 2 3 4 5 6 7 8 9 10 25 50 75 100))
(define Op '(+ * - /))

(define make-cible (lambda () (+ 100 (random 900))))
(define make-tirage (lambda ( ) (letrec ((f (lambda(x li)
                                (if (not(= 6 x))
                                    (f (+ x 1) (cons (letrec ((g (lambda (n liref)
                                                  (if (= 0 n)
                                                      (car liref)
                                                      (g (- n 1) (cdr liref))
                                                      )
                                                  )
                                                ))
                                             (g (random 14) LVal))
                                      li))
                                      li
                                    ))))
                             ( f 0 '())
                                    )
  ))

(define estDans? (lambda (x li)
                   (letrec ((f (lambda ( x li)
                               (if (not(null? li))
                                   (if (= (car li) x)
                                       #t
                                       ( f x (cdr li))
                                       )
                                   #f)
                               )
                              ))
                           (f x li)
                     )
                   )
  )
(define estValide? (lambda (a b op)
                     (if (< 0 ((eval op) a b))
                         (if (integer? ((eval op) a b))
                             #t
                             #f)
                         #f)
                     )
  )
(define opere (lambda (liop a b)
                (letrec ((f (lambda (liop lires)
                  (if (not(null? liop))
                      (if (estValide? a b (car liop))
                          (cons ((eval (car liop)) a b) (f (cdr liop) lires))
                          (if (or (eqv?(car liop) (cadddr Op)) (eqv? (car liop) (caddr Op)))
                              (if ( estValide? b a (car liop))
                                  (cons ((eval (car liop)) b a) (f (cdr liop) lires))
                                  (f (cdr liop) lires)
                                  )
                              (f (cdr liop) lires)
                              )
                          )
                      lires))))
                  (f Op '())
                  )
                )
  )
(define retire_a_b ( lambda (a b li)
                            (letrec (( f (lambda (a b li)
                              (if (not(null? li))
                                  (if (= (car li) a)
                                      (f 0 b (cdr li))
                                      (if (= (car li) b)
                                          (f a 0 (cdr li))
                                          (cons (car li) (f a b (cdr li)))
                                      ))
                                   li
                                  )
                              )
                      ))
                              (f a b li)
  )))

                                             
(define genere_plaques (lambda ( ope li)
                         (letrec ((f (lambda(li1 lires)
                                     (if (not(null? li1))
                                         (begin(letrec ((g (lambda (li1 li2 lires)
                                                       (if (not(null? li2))
                                                          (begin (letrec ((h (lambda ( ope lires )
                                                                        (if (not(null? ope))
                                                                            (if (estValide? (car li1) (car li2) (car ope))
                                                                                (h (cdr ope) (cons (cons ((eval (car ope))  (car li1) (car li2)) (retire_a_b (car li1)(car li2) li)) lires))
                                                                                (if (estValide?  (car li2) (car li1) (car ope))
                                                                                    (h (cdr ope) (cons (cons ((eval (car ope))  (car li2) (car li1)) (retire_a_b (car li1)(car li2) li)) lires))
                                                                                    (h (cdr ope) lires)
                                                                                    )
                                                                                )
                                                                            lires
                                                                            )
                                                                        )))
                                                            (set! lires (h ope lires)))                                                                 
                                                                 (g li1 (cdr li2) lires))
                                                          lires
                                                          )
                                                       )
                                                     ))
                                           (set! lires (g li1 (cdr li1) lires))
                                           )
                                            (f (cdr li1) lires))
                                         lires
                                         )
                                     )))
                           (f li '())
                           )
                         )
  )
(define cherche_dans_li ( lambda (li cible)
                           (letrec (( f (lambda (li)
                                        (if (not(null? li))
                                            (if (= (car li) cible)
                                                #t
                                                (f (cdr li)))
                                            #f)
                                        )))
                             (f li))
                           )
  )

                             
(define ceb (lambda (ope plaques cible)
              (letrec ((f(lambda(li old)
                           (if (null? li)
                               (and #t (display "Le compte n'est pas bon, au mieux :") (display old))
                                  (if (list? (car li))
                                      (begin(or(f (car li) old)(f (cdr li) old)))
                                      (if (cherche_dans_li li cible)
                                          (and #t (display "le compte est bon"))
                                          (begin (set! old (approche li cible))
                                                 (if (null? (cdr li ))
                                              (f (cdr li) old)
                                              (f (genere_plaques ope li) old)
                                          ))
                                          
                                      )
                                  )
                                   )
                               
                             )))
                           
                (f plaques (car plaques))
                
              )))
(define abso (lambda ( x)
              (if (< x 0)
                  (- x)
                  x)))
                               
 (define approche ( lambda ( li cible)
                     (letrec ((f (lambda ( li old)
                                   (if (not(null? li))
                                       (if (<(abso(- cible (car li)))(abso(- cible old)))
                                           (f (cdr li) (car li))
                                           (f (cdr li) old)
                                           )
                                       old)
                                   )))
                       (f li (car li)))))