# Difference between revisions of "H-99: Ninety-Nine Haskell Problems"

From HaskellWiki

(Added 3 & 4 from prelude, and a trivial definition of 5) |
(added simpler definition for #5) |
||

Line 84: | Line 84: | ||

reverse :: [a] -> [a] |
reverse :: [a] -> [a] |
||

reverse = foldl (flip (:)) [] |
reverse = foldl (flip (:)) [] |
||

+ | </haskell> |
||

+ | |||

+ | The standard definition is concise, but not very readable. Another way to define reverse is: |
||

+ | |||

+ | <haskell> |
||

+ | reverse :: [a] -> [a] |
||

+ | reverse [] = [] |
||

+ | reverse (x:xs) = reverse xs ++ [x] |
||

</haskell> |
</haskell> |
||

## Revision as of 04:48, 12 December 2006

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 (:)) []
```

The standard definition is concise, but not very readable. Another way to define reverse is:

```
reverse :: [a] -> [a]
reverse [] = []
reverse (x:xs) = reverse xs ++ [x]
```

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