207 lines
3.7 KiB
Text
Executable file
207 lines
3.7 KiB
Text
Executable file
#lang racket
|
|
;(define (fib n) (
|
|
; if (= n 0)
|
|
; 0
|
|
; (
|
|
; if (= n 1)
|
|
; 1
|
|
; (+ (fib (- n 1)) (fib (- n 2)))
|
|
; )
|
|
;))
|
|
;
|
|
;(fib 10)
|
|
|
|
|
|
;(define (fib n) (
|
|
; (cond
|
|
; [(= n 0) 0]
|
|
; [(= n 1) 1]
|
|
; [else
|
|
; (+ (fib (- n 1)) fib (- n 2))
|
|
; ]
|
|
; )
|
|
;))
|
|
;
|
|
;(fib 10)
|
|
|
|
;(define list1 ( list 1 2 3 4 ))
|
|
;
|
|
;(define (sum list) (
|
|
; if (empty? list)
|
|
; 0
|
|
; ;else
|
|
; (
|
|
; +
|
|
; (first list)
|
|
; ( sum(rest list) )
|
|
; )
|
|
;))
|
|
;
|
|
;(sum list1)
|
|
|
|
;(define (list-with-length len) (
|
|
; if (= len 0)
|
|
; empty
|
|
; (
|
|
; cons 0 (list-with-length (- len 1) )
|
|
; )
|
|
;))
|
|
;
|
|
;(list-with-length 10)
|
|
|
|
;(filter (lambda (x) (> x 10) ) (list 0 5 10 15 20) )
|
|
|
|
;(map (lambda (x) (+ x 10)) (list 0 1 2 3) )
|
|
|
|
;(define (repeat fct times) (
|
|
;
|
|
;))
|
|
|
|
;(define-struct abc (a b))
|
|
;
|
|
;;; Type: abc -> list
|
|
;;; Returns: bla bla
|
|
;(define (foo p) (
|
|
; ;(
|
|
; if (abc? p)
|
|
; (
|
|
; if (list? (abc-b p))
|
|
; ;(
|
|
; (list (abc-a p) (abc-b p))
|
|
; ;)
|
|
; ;else
|
|
; ;(
|
|
; #f
|
|
; ;)
|
|
; )
|
|
; ; else
|
|
; #f
|
|
; ;)
|
|
;))
|
|
;
|
|
;;(define test (make-abc ("asdf" (list 1 2 3 4))))
|
|
;
|
|
;(foo (make-abc 123 (list 1 2 3 4)))
|
|
;
|
|
;(foo 123)
|
|
;
|
|
;(foo (make-abc 123 1234))
|
|
;
|
|
|
|
;(define (contains-x? liste x) (
|
|
; cond
|
|
; [(list? x) #f]
|
|
; [(not (list? liste)) #f]
|
|
; [(empty? liste) #f]
|
|
; [
|
|
; (= (first liste) x)
|
|
; #t
|
|
; ]
|
|
; [
|
|
; else
|
|
; (contains-x? (rest liste) x)
|
|
; ]
|
|
;
|
|
;))
|
|
;
|
|
;(contains-x? (list 12) (list 12 5))
|
|
|
|
|
|
;(define (contains-x? liste x) (
|
|
; cond
|
|
; [(list? x) #f]
|
|
; [(not (list? liste)) #f]
|
|
; [(empty? liste) #f]
|
|
; [
|
|
; (= (first liste) x)
|
|
; #t
|
|
; ]
|
|
; [
|
|
; else
|
|
; (contains-x? (rest liste) x)
|
|
; ]
|
|
;
|
|
;))
|
|
;
|
|
;(define (duplicate? lst) (
|
|
; cond
|
|
; [(not (list? lst)) #f]
|
|
; [(empty? lst) #f]
|
|
; [
|
|
; (contains-x? (rest lst) (first lst))
|
|
; #t
|
|
; ]
|
|
; [
|
|
; else
|
|
; (duplicate? (rest lst))
|
|
; ]
|
|
;))
|
|
;
|
|
;(duplicate? (list 1 2 3 4 5 6 7 3))
|
|
|
|
|
|
;(define (contains-x? liste x) (
|
|
; cond
|
|
; [(list? x) #f]
|
|
; [(not (list? liste)) #f]
|
|
; [(empty? liste) #f]
|
|
; [
|
|
; (= (first liste) x)
|
|
; #t
|
|
; ]
|
|
; [
|
|
; else
|
|
; (contains-x? (rest liste) x)
|
|
; ]
|
|
;
|
|
;))
|
|
;
|
|
;(define (duplicate? lst) (
|
|
; cond
|
|
; [(not (list? lst)) #f]
|
|
; [(empty? lst) #f]
|
|
; [
|
|
; (contains-x? (rest lst) (first lst))
|
|
; #t
|
|
; ]
|
|
; [
|
|
; else
|
|
; (duplicate? (rest lst))
|
|
; ]
|
|
;))
|
|
;
|
|
;(define (collect lst oracle) (
|
|
; cond
|
|
; [(empty? lst) oracle]
|
|
; [
|
|
; else
|
|
; (if (list? (first lst))
|
|
; (collect (rest lst) (collect (first lst) oracle))
|
|
; (
|
|
; collect (rest lst) (cons (first lst) oracle)
|
|
; ))
|
|
; ]
|
|
;))
|
|
;
|
|
;(collect (list 1 2 3 (list 1 4 6)) empty)
|
|
;
|
|
;;(define (duplicates-deep? deep-lst) (
|
|
;;
|
|
;;))
|
|
;
|
|
;
|
|
;;; Type: ( list of ANY ) -> number
|
|
;;; Returns: the sum of the fees of all student in the list
|
|
;( define ( sum-of-student-fees list )
|
|
;( my-fold
|
|
;( lambda ( x y ) ( + x y ) )
|
|
;0
|
|
;( my-map
|
|
;( lambda ( stud ) ( student-fee stud ) )
|
|
;( my-filter ( lambda ( x ) ( student? x ) ) list ) ) ) )
|
|
|
|
|
|
(define asdf 10)
|
|
|
|
(check-expect asdf 10)
|
|
|