Question

Example input:

((a1 . b) (a1 . c)): 

I have one list with two elements, those elements are lists or pairs with two elements. And i want to check if the first element of the first pair/list is equal to the first element of the second pair/list.

output: If so, i want to create a new list with two lists, the first is the list:
while (b < c) -> (a1 . b(even)) (a1 . b+2(even))…
The other list is the same, but with the odd’s

How do I implement this in scheme:

INPUT:

((1 . 1) (1 . 7))

OUTPUT:

(((1 . 2) (1 . 4) (1 . 6)) ((1 . 3) (1 . 5) (1 . 7)))

I have one list with two elements. Each element is also a list with two elements, both integers >= 0 and < 8

I have to create this:

input ((a1 . b) (a1 . c)) 

output: (if (and (= a1 a2) (odd? b))
          While < b c
             (list (a1 . b+1) (a1 . b+3) (a1 . b+n)...)) 
             (list (a2 . b) (a2 . b+2) (a2 . b+4)...)

I had done this, but i can’t find where i’m failing, could you help me?….

;;; Verify if absissa0 = absissa1

(define (game-position input)
  (if (= (car (car j)) (cdr (cdr j)))
          (col1_col2 j)
          (error "Not valid"))))
;;; verify if absissa0 is even

(define (col1_col2 gstart)
  (if (even? (cdr (car jstart))) 
      (list (pos-start jstart))
      (list (pos-start (list (cons (car (car jstart)) (- (cdr (car jstart)) 1)) (car (cdr jstart))))))


;;; Loop that creates positions of even's and odd's

(define (pos-start j2)
  (while ( < (cdr (car j2)) (- (cdr (cdr j2)) 2))
      ((cons (car (car j2)) (+ (cdr (car j2)) 2)) (pos-start (list (cons (car (car j2)) (+ (cdr (car j2)) 2)) (car (cdr j2)))))
      (odd_2 (list (cons (car (car j2)) (+ (cdr (car j2)) 1)) (car (cdr j2)))))

(define (odd_2 j3)
  (while ( < (cdr (car j3)) (- (car (cdr j3)) 2))
      ((j3) (odd_2 (list (cons (car (car j3)) (+ (cdr (car j3)) 2)) (car (cdr j3)))
         (value)))

Answer 1

I’m a bit rusty in scheme, I’ve managed to get this solution to your problem,
it use recursion vs while, but I’m not accustomed to that construct in scheme:

(define data (list (cons 1 1) (cons 1 7)))

(define (neven n) (if (even? n) n (+ n 1)))

(define (sublist a mn mx) 
  (cond 
    ((<= mn mx ) (cons (cons a mn) (sublist a (+ mn 2) mx)))
    (else '())))

(define (game-position input)
   (if (= (caar input) (caadr input))
       (list (sublist (caar input) 
                      (neven (cdar input)) 
                      (cdadr input))
             (sublist (caar input) 
                      (+ 1 (neven (cdar input))) 
                      (cdadr input)))
       (error "no match")))

(game-position data)

edit: It works in guile and drscheme. Hope it will works in plt-scheme too.
edit: sublist inner working

First the parameters:

• a is the car of the pairs contained into the list
• mn is the cdr of the first pair
• mx is the upper limit of the serie.

the body of the function is quite simple:

if the cdr of the current pair is smaller or equal to the upper limit then return a list
composed by a pair (a . mn) and the list created by a call to sublist with the mn parameter changed to reflect the next possible pair.
if the current pair will have a cdr higher than the upper limit then return null (empty list) in order to close the cons issued by the previous invocation of sublist.