These are Haskell translations of Ninety Nine Lisp Problems.

## Problem 1

```(*) Find the last box of a list.
Example:
* (my-last '(a b c d))
(D)
```

This is "last" in Prelude, which is defined as:

```last :: [a] -> a
last [x] = x
last (_:xs) = last xs
```

## Problem 2

```(*) Find the last but one box of a list.
Example:
* (my-but-last '(a b c d))
(C D)
```

This can be done by dropping all but the last two elements of a list:

```myButLast :: [a] -> [a]
myButLast list = drop ((length list) - 2) list
```

## Problem 3

```(*) Find the K'th element of a list.
The first element in the list is number 1.
Example:
* (element-at '(a b c d e) 3)
C
```

This is (almost) the infix operator !! in Prelude, which is defined as:

```(!!)                :: [a] -> Int -> a
(x:_)  !! 0         =  x
(_:xs) !! n         =  xs !! (n-1)
```

Except this doesn't quite work, because !! is zero-indexed, and element-at should be one-indexed. So:

```elementAt :: [a] -> Int -> a
elementAt list i = list !! (i-1)
```

## Problem 4

```(*) Find the number of elements of a list.
```

This is "length" in Prelude, which is defined as:

```length           :: [a] -> Int
length []        =  0
length (_:l)     =  1 + length l
```

## Problem 5

```(*) Reverse a list.
```

This is "reverse" in Prelude, which is defined as:

```reverse          :: [a] -> [a]
reverse          =  foldl (flip (:)) []
```

## Problem 6

```(*) Find out whether a list is a palindrome.
A palindrome can be read forward or backward; e.g. (x a m a x).
```

This is trivial, because we can use reverse:

```isPalindrome :: (Eq a) => [a] -> Bool
isPalindrome xs = xs == (reverse xs)
```