> > (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)

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))))

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)