Compare elements in two list and add different ones

Question

My problem is that. I have a sublist (slst1) that contains random elements from another list (lst). Then, I need to create another one (slst2) that contains the elements of lst not in slst1, but, when I compare them, the result is not what I'm expected.

A call will be:

(split 0.3 lst)

where '0.3' it's a proportion of list I want to take.

lst contains:

((a11 a12 a13 a14)(a21 a22 a32 a42) (a31 a32 a33 a34))

and, for example, slst1 contains:

((a21 a22 a23 a24))

then, slst2 should contain:

((a11 a12 a13 a14) (a31 a32 a33 a34))

but, with my code, slst2 contains always the same items that lst, not only the different ones.

This is my code:

(define (split proportion lst)
(let((ne (* proportion (length lst)))(slst1 '())(slst2 '()))
;Calculate first sublist
(when (> ne 0)
  (for ([i (inexact->exact ne)])
    (if (null? lst)
       (set! slst1 (list-ref lst (random (length lst))))
       (set! slst1 (list lst (list-ref lst (random (length lst)))))))
 ;Try to calculate second sublist 
   (for ([i (length lst)]
     #:when (not(member (list-ref lst i) slst1)))
  (set! slst2 (list slst2 (list-ref lst i)))
     )
 slst2)))

I'm a noobie in Racket, so any advice will be perfect. Thank you for reading/asking.

Answer 1

If I understood you correctly, this will do:

(define (split proportion lst)
  (define le (length lst))
  (define slst1 
    (for/list ([i (inexact->exact (round (* proportion le)))]) 
      (list-ref lst (random le))))
  (define slst2 
    (for/list ([e (in-list lst)] #:unless (member e slst1)) 
      e))
  (values slst1 slst2))

then

(split 0.5 '((a11 a12 a13 a14)(a21 a22 a32 a42) (a31 a32 a33 a34) (a41 a42 a43 a44)))
=> '((a11 a12 a13 a14) (a21 a22 a32 a42))
   '((a31 a32 a33 a34) (a41 a42 a43 a44))

Note that slst1 can contain the same member more than once, so (length slst1) + (length slst2) can be larger than (length lst). Also, you can get weird results if members appear more than once in the initial list.

If you want to avoid this, you could go for the following:

(define (split prop lst)
  (for/fold ((s1 '()) (s2 lst)) ([i (inexact->exact (round (* (length lst) prop)))])
    (define rn (random (length s2)))
    (values 
     (cons (list-ref s2 rn) s1)
     (append (take s2 rn) (drop s2 (add1 rn))))))

s1 gets initialised to null, s2 to lst. Whenever we add an element to s1 we take it away from s2.