• .Re: LISP PROGRAMMING

    From Robert L.@21:1/5 to All on Sat Feb 26 06:12:50 2022
    (defun odd-reverse (list)
    (let ((result
    (loop for (odd even) on list by #'cddr
    collect odd into odds
    collect even into evens
    finally (return (loop for odd in (reverse odds)
    for even in evens
    collect odd
    collect even)))))
    (subseq result 0 (list-length list))))

    Another viewpoint:

    (defun reverse-odd-elems (list)
    (loop with v = (coerce list 'simple-vector)
    with len = (length list)
    with odd-len = (if (evenp len) len (1- len))
    for i from 0 upto (floor odd-len 2)
    when (oddp i) do (rotatef (aref v i) (aref v (- odd-len i)))
    finally (return (coerce v 'list))))

    Gauche Scheme:

    (define (odd-reverse xs)
    (define rev
    (if (odd? (length xs))
    (reverse xs)
    (cdr (reverse (cons #f xs)))))
    (map
    (lambda (i a b) (if (odd? i) a b))
    (lrange 0)
    xs
    rev))

    (odd-reverse '(0 a 1 b 2 c 3))
    ===>
    (3 a 2 b 1 c 0)

    (odd-reverse '(0 a 1 b 2 c))
    ===>
    (2 a 1 b 0 c)

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Robert L.@21:1/5 to Robert L. on Sat Feb 26 09:23:07 2022
    On 2/26/2022, Robert L. wrote:

    (defun odd-reverse (list)
    (let ((result
    (loop for (odd even) on list by #'cddr
    collect odd into odds
    collect even into evens
    finally (return (loop for odd in (reverse odds)
    for even in evens
    collect odd
    collect even)))))
    (subseq result 0 (list-length list))))

    Gauche Scheme:

    "We don't need no stinkin' loops!"

    (use srfi-1) ;; for unzip2

    (define (odd-reverse seq)
    (receive (odd even) (unzip2 (slices seq 2 #t #f))
    (take (append-map list (reverse odd) even) (length seq))))

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Robert L.@21:1/5 to All on Sat Feb 26 10:14:09 2022
    Gauche Scheme:

    ;; Re-order certain slots in a vector.
    (define (reorder vec a b)
    (define cpy (vector-copy vec))
    (for-each
    (lambda (i j) (vector-set! cpy i (vector-ref vec j)))
    a b)
    cpy)

    (define (odd-reverse seq)
    (define idx (lrange 0 (length seq) 2))
    (vector->list
    (reorder (list->vector seq) idx (reverse idx))))

    Let's sort the even-numbered slots in a vector
    (the index of the first slot is 0).

    (define v #(77 2 99 0 33 8 55 6 44))
    (define idx (lrange 0 (vector-length v) 2))
    (reorder v idx
    (sort idx < (lambda (i) (vector-ref v i))))

    ===>
    #(33 2 44 0 55 8 77 6 99)

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)