CODEWITHSUNDEEP
schemeracket
CompScientist
CompScientist

Reputation: 21

Compare a list of numbers with a variable

The function below is intended to compare every number in a list (2nd parameter) with the first parameter and for every num in the list that is greater than the second param, count it and return the total amount of elements in the list that were greater than the 'threshold'

The code I have doesn't run because I have tried to learn how recursion in Dr. Racket works, but I can't seem to understand. I am just frustrated so just know the code below isn't supposed to be close to working; functional programming isn't my thing, haha.

(define (comp-list threshold list-nums)
  (cond [(empty? list-nums) 0]
        [(cons?  list-nums) (let {[my-var 0]}
                              (map (if (> threshold (first list-nums)) 
                                       threshold 2) list-nums ))]))

Upvotes: 1

Views: 1705

Answers (4)

ben rudgers
ben rudgers

Reputation: 3669

A simple functional start

#lang racket

(define (comp-list threshold list-nums)
  (define (my-filter-function num)
    (<  num threshold))
  (length (filter my-filter-function list-nums)))

Replacing define with lambda

#lang racket

(define (comp-list threshold list-nums)
  (length (filter (lambda (num) (< num threshold))
                  list-nums)))

Racket's implementation of filter

In DrRacket highlighting the name of a procedure and right clicking and selecting "jump to definition in other file" will allow review of the source code. The source code for filter is instructive:

  (define (filter f list)
    (unless (and (procedure? f)
                 (procedure-arity-includes? f 1))
      (raise-argument-error 'filter "(any/c . -> . any/c)" f))
    (unless (list? list)
      (raise-argument-error 'filter "list?" list))
    ;; accumulating the result and reversing it is currently slightly
    ;; faster than a plain loop
    (let loop ([l list] [result null])
      (if (null? l)
        (reverse result)
        (loop (cdr l) (if (f (car l)) (cons (car l) result) result)))))

Upvotes: 0

Penguino
Penguino

Reputation: 2176

The following doesn't use lambda of foldl (and is recursive) - can you understand how it works?

(define (comp-list threshold list-nums)
  (cond [(empty? list-nums) 0]
        [else
         (cond [(> (car list-nums) threshold) (+ 1 (comp-list threshold (cdr list-nums)))]
               [else (comp-list threshold (cdr list-nums))])]))

Tested:

> (comp-list 1 '(1 1 2 2 3 3))
4
> (comp-list 2 '(1 1 2 2 3 3))
2
> (comp-list 3 '(1 1 2 2 3 3))
0

Upvotes: 1

Sylwester
Sylwester

Reputation: 48745

map takes a procedure as first argument and applied that to every element in the given list(s). Since you are counting something making a list would be wrong.

foldl takes a procedure as first argument, the starting value as second and one or more lists. It applies the procedure with the elements and the starting value (or the intermediate value) and the procedure get to decide the next intermediate value. eg. you can use it to count a list:

(define (my-length lst)
  (foldl (lambda (x acc) (+ acc 1))
         0
         lst))

(my-length '(a b c)) ; ==> 3

You can easily change this to only count when x is greater than some threshold, just evaluate to acc to keep it unchanged when you are not increasing the value.

UPDATE

A recursive solution of my-length:

(define (my-length lst)
  ;; auxiliary procedure since we need
  ;; an extra argument for counting
  (define (aux lst count)
    (if (null? lst)
        count
        (aux (cdr lst)
             (+ count 1))))
  ;; call auxiliary procedure
  (aux lst 0))

The same alteration to the procedure to foldl have to be done with this to only count in some circumstances.

Upvotes: 1

soegaard
soegaard

Reputation: 31147

(define (comp-list threshold list-nums)
  (cond 
    [(empty? list-nums)  ; there are 0 elements over the threshold in an empty list
     0]
    [(cons?  list-nums)  ; in a constructed list, we look at the the first number
     (cond
       [(< threshold (first list-nums)) 
        (+ 1                                        ; the first number is over
           (comp-list threshold (rest list-nums))]  ; add the rest 
       [else 
        (comp-list threshold (rest list-nums))])])) ; the first number is lower

Upvotes: 0

Related Questions