- Scheme Procedure:
**adjacent-map**¶`proc``lst` Returns a list of elements after apply

`proc`to adjacent elements.This algorithm is similar to Haskell’s

`mapAdjacent`

.Examples:

> (adjacent-map * '(1 2 3 4 5 6)) '(2 6 12 20 30) > (adjacent-map < '(1 2 1 3 4 3)) '(#t #f #t #t #f)

- Scheme Procedure:
**all?**¶`lst` Returns

`#t`

if all the elements of`lst`are`#t`

, otherwise returns`#f`

.This algorithm is similar to Python’s

`all`

.Examples:

> (all? '(#t #t #t)) #t > (all? '(#t #t #f)) #f

- Scheme Procedure:
**any?**¶`lst` Returns

`#t`

if any of the elements of`lst`is`#t`

, otherwise returns`#f`

.This algorithm is similar to Python’s

`any`

.Examples:

> (any? '(#f #t #f)) #t > (any? '(#f #f #f)) #f

- Scheme Procedure:
**chunks-of**¶`lst``k` Returns a list of lists of

`k`elements each.Note that this is a specialization of

`sliding`

where`size`is equal to`step`.This algorithms is the same as Haskell’s

`chunksOf`

.Examples:

> (chunks-of '(1 2 1 3 4 3) 2) '((1 2) (1 3) (4 3)) > (chunks-of '(1 2 1 3 4 3) 3) '((1 2 1) (3 4 3))

- Scheme Procedure:
**flatten**¶`v` Flattens an arbitrary S-expression structure of pairs into a list. More precisely,

`v`is treated as a binary tree where pairs are interior nodes, and the resulting list contains all of the non-null leaves of the tree in the same order as an inorder traversal.This algorithm is a direct port of

`racket/base`

`flatten`

, and is not coming from`racket-algorithms`

package.Examples:

> (flatten '((a) b (c (d) . e) ())) '(a b c d e) > (flatten 'a) '(a)

- Scheme Procedure:
**generate**¶`n``proc` Returns a list of

`n`elements generated from invoking`proc``n`times.This algorithm is similar to C++’s

`generate`

.Examples:

> (generate 3 *) '(1 1 1) > (generate 3 +) '(0 0 0)

- Scheme Procedure:
**increasing?**¶`lst` Returns

`#t`

if all the elements of`lst`are strictly increasing, otherwise returns`#f`

.Examples:

> (increasing? '(1 2 3 4)) #t > (increasing? '(1 2 3 5)) #t > (increasing? '(1 2 2 3)) #f

- Scheme Procedure:
**init**¶`lst` Return all the elements of a list except the last one.

This algorithm comes from Haskell’s

`init`

.Examples:

> (init '(1 2 3 4)) '(1 2 3) > (init '((1 2) (3 4) (5 6))) '((1 2) (3 4))

- Scheme Procedure:
**juxt**¶`proc`… Takes variable number of procedures and returns a procedure that is the juxtaposition of those procedures. The returned procedure takes a variable number of arguments, and returns a list containing the result of applying each procedures to the arguments.

This algorithm comes from Clojure’s

`juxt`

.Examples:

> ((juxt first last) '(1 2 3)) '(1 3) > ((juxt + *) 1 2 3 4) '(10 24) > ((juxt zip append) '(1 2 3) '(4 5 6)) '(((1 4) (2 5) (3 6)) (1 2 3 4 5 6))

- Scheme Procedure:
**product**¶`lst` Returns the product of the elements in

`lst`.Examples:

> (product '(1 2 3)) 6 > (product '(1 2 3 4)) 24

- Scheme Procedure:
**repeat**¶`n``val` Returns a list of

`val`repeated`n`times.This algorithms is the same as Clojures’s

`repeat`

and D’s`repeat`

.Note: this is in fact just alias to

`make-list`

and therefore isn’t really necessary.Examples:

> (repeat 5 #t) '(#t #t #t #t #t) > (repeat 5 '()) '(() () () () ())

- Scheme Procedure:
**replicate**¶`lst``lst2` Returns a list of of the

`lst2`values each repeated n times where n is the corresponding element in`lst`.This algorithms is the similar to APL’s

`replicate`

.Examples:

> (replicate '(1 0 1) '(a b c)) '(a c) > (replicate '(0 1 2) '(a b c)) '(b c c)

- Scheme Procedure:
**scanl**¶`proc``lst` Returns a list of successive reduced values from the left.

This algorithm originally comes from APL’s monadic

`\ scan`

operator. It is more similar to Haskell’s`scanl1`

however.Examples:

> (scanl + '(1 2 3 4)) '(1 3 6 10) > (scanl * '(1 2 3 4)) '(1 2 6 24)

- Scheme Procedure:
**scanr**¶`proc``lst` Returns a list of successive reduced values from the right.

This algorithm originally comes from APL’s monadic

`\ scan`

operator. It is more similar to Haskell’s`scanr1`

however.Examples:

> (scanr + '(1 2 3 4)) '(10 9 7 4) > (scanr * '(1 2 3 4)) '(24 24 12 4)

- Scheme Procedure:
**sliding**¶`lst``size`[`step`1] Returns a list of lists of

`size`elements each, at offset`step`apart.`step`has to be smaller than length of the`lst`.This algorithms is the same as Haskell’s

`divvy`

, Clojure’s`partition`

and D’s`slide`

.Examples:

> (sliding '(1 2 3 4) 2) '((1 2) (2 3) (3 4)) > (sliding '(1 2 3 4 5) 2 3) '((1 2) (4 5))

- Scheme Procedure:
**sorted?**¶`lst` Returns

`#t`

if all the elements of`lst`are in sorted order, otherwise returns`#f`

.This algorithm is similar to C++’s

`std::is_sorted`

.Examples:

> (sorted? '(1 2 3 4)) #t > (sorted? '(1 2 3 3)) #t > (sorted? '(1 2 3 2)) #f

- Scheme Procedure:
**sum**¶`lst` Returns the sum of the elements in

`lst`.Examples:

> (sum '(1 2 3 4)) 10 > (sum '()) 0

- Scheme Procedure:
**tail**¶`lst` Return all the elements of a list except the first one.

Name of this algorithm comes from Haskell’s

`tail`

Note: this is the same as

`cdr`

and therefore isn’t really necessary.Examples:

> (tail '(1 2 3)) '(2 3) > (tail '(1)) '()

- Scheme Procedure:
**zip-with**¶`proc``lst``lst`… Returns a list after zipping together the variadic number of

`lst`s and applying`proc`to each of the "zipped together" elements.This algorithm is similar to Haskell’s

`zipWith`

.Examples:

> (zip-with + '(1 2 3) '(4 5 6)) '(5 7 9) > (zip-with + '(1 2 3) '(4 5 6) '(7 8 9)) '(12 15 18)