Need assistance with a scheme(R5RS) coding project (I feel like I'm missing something simple)

Question

Essentially the point of the project is to define a single function sum. Sum takes in a list of integers and decides whether there are any 2 integers in the list that when added together equal any other integer in the list. Some examples : (sum ‘(1 2 3)) returns #t

(sum ‘(15 10 30 7 11 50 21)) returns #t
(sum ‘(20 7 1 10 42 15 36 10 52)) returns #t
(sum ‘(55 99 21 100 37 37 101 77 57 102 10)) returns #f
(sum ‘(15 36 16 40 82 65)) returns #f

No matter what I do I can only get the first list to return true or (#t)

I'm using R5RS in the DrRacket scheme application. The code may also only be one function "sum" no helper functions are allowed.

Here is my code so far :

(define sum(lambda (list)
    (cond
      ((null? list) #f)
      ((null? (cdr list)) #f)
      ((null? (cddr list)) #f)
      ((or (= (+ (car list) (cadr list)) (caddr list))
           (= (+ (car list) (caddr list)) (cadr list))
           (= (+ (cadr list) (caddr list)) (car list)))
       #t)
      (else (sum (cdr list))))))`

Any advice is helpful just really struggling with thanks.

I've tried changing the Cond statements and every time I always end up back here, Again I'm really struggling any advice is welcome. `

Answer 1

From your code it looks like you only compare the 3 consecutive and do that in 3 takes to cover where any of these 3 are the sum of the two other and then you're sliding so that you do it to the 3 next after the first as a sliding window until you don't have 3 elements no more. So this list here:

(sum '(1 2 3)) ; ==> #t

But this one should be #t, but your code:

(sum '(1 5 9 2 3)) ; ==> #f

In practice you can make a function sum2 that gets a list of all combinations of 2 elements and returns their sum. You then can iterate over that one and search each element in the original list. When all the sums has failed to be found in the source list the result is #f, but you have early exit with the first found.

Answer 2

You're missing some recursive cases.

The case without the first element is not enough - you also need the case with all elements except the second (i.e. still has the first element), and the case with all elements except the third (i.e. still has the first and second elements).

I would use logical operators rather than a conditional:

(define (sum ls)
    (and (not (null? ls))
         (not (null? (cdr ls)))
         (not (null? (cddr ls)))
         (or (= (+ (car ls) (cadr ls)) (caddr ls))
             (= (+ (car ls) (caddr ls)) (cadr ls))
             (= (+ (cadr ls) (caddr ls)) (car ls))
             ; (100 1 2 3 ...) -> (1 2 3 ...)
             (sum (cdr ls)) 
             ; (1 100 2 3 ...) -> (1 2 3 ...)
             (sum (cons (car ls) (cddr ls))) 
             ; (1 2 100 3 ...) -> (1 2 3 ...)
             (sum (cons (car ls) (cons (cadr ls) (cdddr ls))))))) 

Answer 3

You need a function like combine which gives you groups of n combinations from a list - in our case 3.

Then, one can write a predicate which tests whether one of the 3 numbers is the sum of the other two.

With ormap, you can short-circuit the calculation.

(define (combinations size elements)
  (cond [(zero? size)
         '(())]
        [(empty? elements)
         empty]
        [else
         (append (map (curry cons (first elements))
                      (combinations (sub1 size) (rest elements)))
                 (combinations size (rest elements)))]))

(define (triplet-sum? a b c)
  (or (= a (+ b c))
      (= b (+ a c))
      (= c (+ a b))))

(define (sum? ls)
  (let ((triplets (combinations 3 ls)))
    (ormap (lambda (triple) (apply triplet-sum? triple))
           triplets)))