Topic: -={ Challenge }=- SubStr for Lists

[Lee Mac]

The Challenge:

To construct a function to return a section of a list, with behaviour akin to the substr function (with the exception of a zero-based index)

Code: [Select]

(SubList <list> <start> [<length>])
Examples:

Code: [Select]

(SubList '(0 1 2 3 4 5) 2 3)
>> (2 3 4)


Code: [Select]

(SubList '(0 1 2 3 4 5) 2 nil)
>> (2 3 4 5)


Code: [Select]

(SubList '(0 1 2 3 4 5) 6 3)
>> nil


[T.Willey]

Code: [Select]

(defun SubList ( lst st len )
   
    (repeat st
        (setq lst (cdr lst))
    )
    (if
        (or
            (not len)
            (zerop len)
        )
        lst
        (reverse (SubList (reverse lst) (- (length lst) len) 0))
    )
)


[gile]

Hi,

this one i posted here:

Code: [Select]

;; SUBLIST
;; Returns a sub list
;;
;; Arguments
;; lst : a list
;; start : start index (first item = 0)
;; leng : the sub list length (number of items) or nil

(defun sublist (lst start leng / n r)
  (if (or (not leng) (< (- (length lst) start) leng))
    (setq leng (- (length lst) start))
  )
  (setq n (+ start leng))
  (while (< start n)
    (setq r (cons (nth (setq n (1- n)) lst) r))
  )
)
Or a recursive form:

Code: [Select]

;; SUBLST
;; Returns a sub list
;;
;; Arguments
;; lst : a list
;; start : start index (first item = 0)
;; leng : the sub list length (number of items) or nil

(defun sublst (lst start leng)
  (or leng (setq leng (length lst)))
  (if (and lst (< 0 leng))
    (if    (zerop start)
      (cons (car lst) (sublst (cdr lst) 0 (1- leng)))
      (sublst (cdr lst) (1- start) leng)
    )
  )
)

[Lee Mac]

Nice one guys!, some interesting results 

Here was mine:

Code: [Select]

(defun LM:SubList ( lst start len )
  (if lst
    (if (< 0 start)
      (LM:SubList (cdr lst) (1- start) len)
      (if len
        (if (< 0 len)
          (cons (car lst) (LM:SubList (cdr lst) start (1- len)))
        )
        lst
      )
    )
  )
)
Similar to Giles I think

[alanjt]

Code: [Select]

(defun AT:SubList (lst left lgth / _trim)

  (defun _trim (l i)
    (if (> i 0)
      (_trim (cdr l) (1- i))
      l
    )
  )

  (if lgth
    (reverse (_trim (reverse (_trim lst left)) (- (length lst) left lgth)))
    (_trim lst left)
  )
)

[T.Willey]

In case the list is long.

Code: [Select]

(defun SubList ( lst st len / tempList )
   
    (setq len
        (if (not len)
            (length lst)
            (1- (+ st len))
        )
    )
    (vl-catch-all-apply
        (function
            (lambda ( / cnt )
                (setq cnt 0)
                (foreach i lst
                    (cond
                        ((<= st cnt len)
                            (setq tempList (cons i tempList))
                        )
                        ((> cnt len)
                            (exit)
                        )
                    )
                    (setq cnt (1+ cnt))
                )
            )
        )
    )
    (reverse tempList)
)


[Kerry]

Here's one that was prepared earlier

Similar to most ..

Code - Auto/Visual Lisp: [Select]

1. ;;;-----------------------------------------------------------------------------------
2. ;;;-----------------------------------------------------------------------------------
3. ;;;
4. ;;; KDUB:sublist Return a sub-list
5. ;;;
6. ;;; Arguments
7. ;;; lst : a list
8. ;;; start : start index for the sub-list (first item = 0)
9. ;;; leng : sub-list length (or nil)
10. ;;;
11. ;;; Examples :
12. ;;; (KDUB:sublist '(1 2 3 4 5 6) 2 2) -> (3 4)
13. ;;; (KDUB:sublist '(1 2 3 4 5 6) 2 nil) -> (3 4 5 6)
14.  
15. (defun KDUB:sublist (lst start leng / n r)
16.   (if (or (not leng) (< (- (length lst) start) leng))
17.     (setq leng (- (length lst) start))
18.   )
19.   (setq n (+ start leng))
20.   (repeat leng (setq r (cons (nth (setq n (1- n)) lst) r)))
21. )

[Kerry]

Interesting ::

Excluding Tim's routine for 'Long lists'
There is a 46% range difference in speed for those posts  

using
(setq TestList '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30))
(doit:sublist TestList 9 13)

[JohnK]

This one shouldn't beat any speed records but I wanted to be different.

Code: [Select]

(defun sublist ( lst start len / iterations)
    (defun sublist-iter (sofar lis)
       (cond
         ((or (null lis) (eq (length sofar) len))
             (reverse sofar) )
         ((>= iterations start)
    (setq iterations (1+ iterations))
             (sublist-iter
     (cons (car lis) sofar)
              (cdr lis)))
         ( T (setq iterations (1+ iterations))
    (sublist-iter '() (cdr lis)))) )
   (setq iterations 0)
   (sublist-iter '() lst)
 )

EDIT: Found a mistake (extra code) and fixed it. It will still operate as was before.

[Lee Mac]

Another, iterative version...

Code: [Select]

(defun LM:SubList-iter ( lst start len / r )
  (or len (setq len (- (length lst) start)))
 
  (repeat start (setq lst (cdr lst)))
 
  (setq i -1)

  (while (and lst (< (setq i (1+ i)) len))
    (setq r (cons (car lst) r) lst (cdr lst))
  )
  (reverse r)
)

[ElpanovEvgeniy]

three sketches...

Code: [Select]

(defun f (l s n)
 (cond ((not l) nil)
       ((> s 0) (f (cdr l) (1- s) n))
       ((not n) l)
       ((> n 0) (cons (car l) (f (cdr l) 0 (1- n))))
 )
)

Code: [Select]

(defun f1 (l s n / i)
 (setq i -1
       n (if n (+ s n i) (length l))
 )
 (vl-remove-if-not (function (lambda (a) (<= s (setq i (1+ i)) n))) l)
)

Code: [Select]

(defun f2 (l s n)
 (repeat (/ s 4)
  (setq l (cddddr l))
 )
 (repeat (rem s 4)
  (setq l (cdr l))
  )
 
 (setq s nil)
 (if (and l n)
  (progn (repeat (/ n 4)
          (setq s (cons (car l) (cons (cadr l) (cons (caddr l) (cons (cadddr l) s))))
                l (cddddr l)
          )
         )
         (repeat (rem n 4)
                   (setq s (cons (car l) s)
                         l (cdr l)
                   )
                  )
         (reverse s)
  )
  l
 )
)

[Lee Mac]

Nice coding Evgeniy 

[ElpanovEvgeniy]

 

Code: [Select]

(defun f2 (l s n)
 (repeat (/ s 4)
  (setq l (cddddr l))
 )
 (repeat (rem s 4)
  (setq l (cdr l))
  )
 
 (setq s nil)
 (if (and l n)
  (progn (repeat (/ n 4)
          (setq s (cons [color=red](cadddr l) (cons (caddr l) (cons (cadr l) (cons (car l)[/color] s))))
                l (cddddr l)
          )
         )
         (repeat (rem n 4)
                   (setq s (cons (car l) s)
                         l (cdr l)
                   )
                  )
         (reverse s)
  )
  l
 )
)

[ElpanovEvgeniy]

Moscow now has one in the morning.
I go to bed...

[Kerry]

using
(setq TestList '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30))

Haven't tested with any varying length Lists

The range is about 10% to 50% difference

Code: [Select]


Benchmarking [M.P. 2005 < revised kdub 2005>] ..................
Elapsed milliseconds for 32768 iteration(s)/ relative Timing :

    (TW:L-SUBLIST TESTLIST 9 13)........2886 / 2.4987 <slowest>
    (J7:SUBLIST TESTLIST 9 13)..........1997 / 1.7290
    (EE:F TESTLIST 9 13)................1747 / 1.5126
    (GILE:SUBLST TESTLIST 9 13).........1700 / 1.4719
    (LM:SUBLIST TESTLIST 9 13)..........1607 / 1.3913
    (LM:SUBLIST-ITER TESTLIST 9 13).....1451 / 1.2563
    (EE:F1 TESTLIST 9 13)...............1404 / 1.2156
    (EE:F2 TESTLIST 9 13)...............1311 / 1.1351
    (AT:SUBLIST TESTLIST 9 13)..........1311 / 1.1351
    (GILE:SUBLIST TESTLIST 9 13)........1310 / 1.1342
    (TW:SUBLIST TESTLIST 9 13)..........1279 / 1.1074
    (KDUB:SUBLIST TESTLIST 9 13)........1155 / 1.0000 <fastest>