Using map, filter, and fold (or whatever they're called in your language of choice), you can handle most things you might want to do without actually using loops or recursion.

n = 0
while (n < A.length) {
 print (A[n]);
 if (A[n] < 0) break;
 n = n+1;
}

This loop ends in two ways:  either n makes to the end of the array, or
a negative number was found in there.

n = 0
neg = false
while (n < A.length && !neg) {
 print (A[n]);
 if (A[n] < 0) neg = true
 else n = n+1;
}

I think this does the same thing but without the break statement


Consider this list:

(3 1 4 1 5 9 2 6 5 3 5 8)
(0 1 0 1 1 0 1 0 0 1 1 0)

If an entry is <= its following entry, map it to 1.  Else map it to zero.  The last entry always gets mapped to 0.

(if test x x)

The difference between mapcar and maplist is:

(mapcar #'f (list a b c d e)) ==> ((f a) (f b) (f c) (f d) (f e))

(maplist #'f (list a b c d e)) ==> ((f (list a b c d e)) (f (list b c d e)) (f (list c d e)) (f (list d e)) (f (list e)))

(defun smaller-than-next (l)
  (if (null (rest l)) 0
        (if (<= (first l) (first (rest l))) 1 0)))

(maplist #'smaller-than-next (list 3 1 4 1 5 9 2 6 5 3 5 8))
(0 1 0 1 1 0 1 0 0 1 1 0)

car ==> head of list, equ. to first
cdr ==> rest of list.  returns a list.



zip takes two collections of the same size, and return a collection of pairs.  "Takes a tuple of lists, and returns a list of tuples."

zip ( (1,2,3,4,5) , (6,7,8,9,10) ) ==> ( (1,6) , (2,7) , (3,8), (4,9), (5,10) )


What we think of as a string, simply does not exist in C.

C uses arrays of char.  If you say char c[5], c is an array containing
exactly 5 chars.

Unlike other more modern languages, arrays do not know their own length, so if you need to know the length of an array, you have to keep track of it yourself.

The strlen (c) function isn't necessarily going to return 5 because c
doesn't know its own length.  What strlen is just keep moving forward in memory until it hits a null byte (ASCII 0) and counts how many characters it hit before the null byte.

c array is "STARE".  Suppose the memory is:  STARE0%^<NUL>, strlen (c) will give a length of 8 because it counted 8 bytes before hitting the <NUL>.

If you store a "string" in C, make sure you allocate one more byte than you think you need, and make sure that your string is followed by a <NUL> that you put in there yourself just to be on the safe side.

c[0] = 'S';
c[1] = 'T';
c[2] = 'A';
c[3] = 'R';
c[4] = 'E';
c[5] = 0;

strcpy (c,"STARE");  // strcpy will automatically copy in that null byte for you.

fgets (array,array_len,stdin)