# Difference between revisions of "99 questions/Solutions/25"

From HaskellWiki

< 99 questions | Solutions

(Added an alternative solution) |
|||

Line 26: | Line 26: | ||

in rnd_permu' $ ys ++ zs |
in rnd_permu' $ ys ++ zs |
||

return $ (xs!!rand):rest |
return $ (xs!!rand):rest |
||

+ | </haskell> |
||

+ | |||

+ | Or we can use the <hask>permutations</hask> function from <hask>Data.List</hask>: |
||

+ | <haskell> |
||

+ | import System.Random (getStdGen, randomRIO) |
||

+ | import Data.List (permutations) |
||

+ | |||

+ | rndElem :: [a] -> IO a |
||

+ | rndElem xs = do |
||

+ | gen <- getStdGen |
||

+ | index <- randomRIO (0, length xs - 1) |
||

+ | return $ xs !! index |
||

+ | |||

+ | rndPermutation :: [a] -> IO [a] |
||

+ | rndPermutation xs = rndElem . permutations $ xs |
||

</haskell> |
</haskell> |

## Revision as of 06:18, 15 August 2011

Generate a random permutation of the elements of a list.

```
rnd_permu xs = diff_select' (length xs) xs
```

Uses the solution for the previous problem. Choosing N distinct elements from a list of length N will yield a permutation.

Or we can generate the permutation recursively:

```
import System.Random (randomRIO)
rnd_permu :: [a] -> IO [a]
rnd_permu [] = return []
rnd_permu (x:xs) = do
rand <- randomRIO (0, (length xs))
rest <- rnd_permu xs
return $ let (ys,zs) = splitAt rand rest
in ys++(x:zs)
rnd_permu' [] = return []
rnd_permu' xs = do
rand <- randomRIO (0, (length xs)-1)
rest <- let (ys,(_:zs)) = splitAt rand xs
in rnd_permu' $ ys ++ zs
return $ (xs!!rand):rest
```

Or we can use the `permutations`

function from `Data.List`

:

```
import System.Random (getStdGen, randomRIO)
import Data.List (permutations)
rndElem :: [a] -> IO a
rndElem xs = do
gen <- getStdGen
index <- randomRIO (0, length xs - 1)
return $ xs !! index
rndPermutation :: [a] -> IO [a]
rndPermutation xs = rndElem . permutations $ xs
```