Topic: Parse a list of integers

[David Bethel]

Greetings

Using vanilla Autolisp :

Given a sorted list of integers that always starts with 1

Code: [Select]

(setq lst '(1 12 16 21 26 32 40 42 56 66 74))

A function to parse the list with a  maximum difference between values of a specified number of units ie 24

Code: [Select]

(parsel lst 24)

And return a list of lists with the start and end positions:

Code: [Select]

'((1 21) (21 42) (42 66) (66 74))

(1 25) would be valid

Code: [Select]

(<= (- 25 1) 24) ->  T

Any ideas ?  Thanks  -David

PS I haven't figured out what to do if the difference is greater than 24 for 2 adjacent atoms.

Here's where I'm at and it aint working !

Code: [Select]

(defun parsel (lst q / s ) ;i  rl)
  (setq s (car lst))
  (while (< s (last lst))
     (setq i 0)
     (repeat (length lst)
        (if (> (+ s q) (- (nth i lst) s))
            (setq i (1+ i))))
     (setq rl (cons (list s (nth (1- i) lst)) rl)
            s (nth (1- i) lst)))
  (setq rl (cons (list s (last lst)) rl))
  (prin1 (reverse rl)))
Any ideas ?  Thanks  -David

[ronjonp]

Not pretty but seems to work with your example   
Guess I should have read a bit closer    .. does not account for adjacent atoms.

Code - Auto/Visual Lisp: [Select]

1. (setq l '(1 12 16 21 26 32 40 42 56 66 74))
2. (defun _foo (l / i i2 out)
3.   (while (setq i (car l)
4.           l (cdr l)
5.     )
6.     (while (and l (<= (- (car l) i) 24))
7.       (setq i2 (car l)
8.        l  (cdr l)
9.       )
10.     )
11.     (setq l   (cons i2 l)
12.      out (cons (cons i i2) out)
13.     )
14.   )
15.   (reverse out)
16. )
17. (_foo l)
18.  
19.  
20. ;;;_$
21. ;;;
22. ;;;(1 12 16 21 26 32 40 42 56 66 74)
23. ;;;_FOO
24. ;;;((1 . 21) (21 . 42) (42 . 66) (66 . 74))
25. ;;;; 3 forms loaded from #<editor "<Untitled-1> loading...">
26. ;;;_$

[jvillarreal]

Greetings

Using vanilla Autolisp :

Given a sorted list of integers that always starts with 1

Code: [Select]

(setq lst '(1 12 16 21 26 32 40 42 56 66 74))

A function to parse the list with a  maximum difference between values of a specified number of units ie 24

Code: [Select]

(parsel lst 24)

And return a list of lists with the start and end positions:

Code: [Select]

'((1 21) (21 42) (42 66) (66 74))

(1 25) would be valid

Code: [Select]

(<= (- 25 1) 24) ->  T

Any ideas ?  Thanks  -David

PS I haven't figured out what to do if the difference is greater than 24 for 2 adjacent atoms.

Here's where I'm at and it aint working !

Code: [Select]

(defun parsel (lst q / s ) ;i  rl)
  (setq s (car lst))
  (while (< s (last lst))
     (setq i 0)
     (repeat (length lst)
        (if (> (+ s q) (- (nth i lst) s))
            (setq i (1+ i))))
     (setq rl (cons (list s (nth (1- i) lst)) rl)
            s (nth (1- i) lst)))
  (setq rl (cons (list s (last lst)) rl))
  (prin1 (reverse rl)))
Any ideas ?  Thanks  -David

Using your code:

Code: [Select]

(defun parsel (lst q / s i  rl)
  (setq s (car lst))
  (while (< s (last lst))
     (setq i 0)
     (repeat (length lst)
        (if (>= q (- (nth i lst) s));include equal to and adding s is not needed
            (setq i (1+ i))))
    (if (not (zerop (- (nth (1- i) lst) s)))
     (setq rl (cons (list s (nth (1- i) lst)) rl)
            s (nth (1- i) lst))
     (setq s (nth i lst))
    )
)
 ;(setq rl (cons (list s (last lst)) rl));Not sure why this is being done
  (reverse rl));Removed prin1, assuming it was placed for your testing

*Edit* - Added additional if statement in case difference between current and next number exceed maximum diff

[David Bethel]

So far so good !

I figured it was something fairly simple that I was overlooking

 Thanks!  -David

[jvillarreal]

Edited previous post for a case such as (parsel lst 12)

[David Bethel]

Thanks.  I'm still contemplating a few different scenarios that I know will crash ( or at least give my poor brain and headache.  -David

[David Bethel]

Not pretty but seems to work with your example   

I'll have to give this some thought on how it works !  Thanks  -David

[Lee Mac]

Another, not likely to be fast:

Code - Auto/Visual Lisp: [Select]

1. (defun foo ( l n )
2.     (if l (bar (car l) (+ (car l) n) n (cdr l)))
3. )
4. (defun bar ( a b n l )
5.     (if (cadr l)
6.         (if (< b (cadr l))
7.             (cons (list a (car l)) (foo l n))
8.             (bar a b n (cdr l))
9.         )
10.         (list (list a (car l)))
11.     )
12. )

Code - Auto/Visual Lisp: [Select]

1. _$ (foo lst 24)
2. ((1 21) (21 42) (42 66) (66 74))

[Lee Mac]

Another:

Code - Auto/Visual Lisp: [Select]

1. (defun foo ( l n / x y r )
2.     (setq x (car  l)
3.           y (cadr l)
4.     )
5.     (foreach z (cddr l)
6.         (if (< (+ x n) z) (setq r (cons (list x y) r) x y))
7.         (setq y z)
8.     )
9.     (reverse (cons (list x y) r))
10. )

[Lee Mac]

Another:

Code - Auto/Visual Lisp: [Select]

1. (defun foo ( l n )
2.     (if (caddr l)
3.         (if (< (+ (car l) n) (caddr l))
4.             (cons (list (car l) (cadr l)) (foo (cdr l) n))
5.             (foo  (cons (car l) (cddr l)) n)
6.         )
7.         (list l)
8.     )
9. )

[AIberto]

 
I can't understand.
(setq lst '(1 12 16 21 26 32 40 42 56 66 74))

(parsel lst 24)
why returns '((1 21) (21 42) (42 66) (66 74))

why not '((1 12) (12 16) (16 21) (21 26)..............)

(<= (- 12 1) 24) ->  T , (<= (- 16 12) 24) ->  T........

[irneb]

why not '((1 12) (12 16) (16 21) (21 26)..............)

Because

A function to parse the list with a  maximum difference between values of a specified number of units ie 24

Code: [Select]

(parsel lst 24)


A bit unclearly stated, but it seems to mean: Get pairs of values, where their difference is the maximum less than (or equal to) a specified quantizer (in this case 24).

Your scenario (i.e. simply pair consecutive items) would be very easy:

Code - Auto/Visual Lisp: [Select]

1. (mapcar 'list lst (cdr lst))

[roy_043]

What should be the result of the function in this case?:

Code: [Select]

(setq lst '(1 12 16 21 26 32 40 42 56 66 74))
(setq dif 2)

[roy_043]

My offer:

Code - Auto/Visual Lisp: [Select]

1. ; (Roy_Test_01 '(1 12 16 21 26 32 40 42 56 66 74)  2)
2. ;   => ((40 . 42))
3. ; (Roy_Test_01 '(1 12 16 21 26 32 40 42 56 66 74) 10)
4. ;   => ((12 . 21) (21 . 26) (26 . 32) (32 . 42) (56 . 66) (66 . 74))
5. ; (Roy_Test_01 '(1 12 16 21 26 32 40 42 56 66 74) 24)
6. ;   => ((1 . 21) (21 . 42) (42 . 66) (66 . 74))
7. (defun Roy_Test_01 (lst dif / itm)
8.   (setq itm (car lst))
9.   (vl-remove
10.     nil
11.     (mapcar
12.       '(lambda (cur nxt)
13.         (if (or (not nxt) (< dif (- nxt itm)))
14.           (if (< dif (- cur itm))
15.             (not (setq itm cur))
16.             (cons itm (setq itm cur))
17.           )
18.         )
19.       )
20.       (cdr lst)
21.       (append (cddr lst) '(nil))
22.     )
23.   )
24. )

[irneb]

What should be the result of the function in this case?:

Code: [Select]

(setq lst '(1 12 16 21 26 32 40 42 56 66 74))
(setq dif 2)

Agreed - most of the codes here would at worst cause an infinite loop, or need to make some assumption.


@David: Could you please specify what should happen if the quantile is smaller than the difference between some 2 consecutive items in the list?