Haskell用于随机排序列表不能正常工作（Homework）初学者

Question

Only began using Haskell a couple of weeks ago - I am attempting to randomly shuffle a list of type Card by splitting the list into two at a random point int eh list (depending on an array of random integers produced by the randomList function) and swapping the order of these two parts a number of times, but the output is not at all random, and the parse only seems to be happening once, pretty desperate as I need it working and the deadline is tonight!

randomList :: (Random a) => (a,a) -> Int -> StdGen -> [a]
randomList bnds n = take n . randomRs bnds

randomise :: [Int] -> [Card] -> [Card]
randomise [] p = p
randomise (x : xs) p = do
                    randomise xs ((drop x p) ++ (take x p))

shuffle :: Int -> [Card] -> [Card]
shuffle r p = do
          let g = mkStdGen r
          randomise(randomList (1, (length p)-1) 500 g :: [Int]) p

Answer 1

You can just make a random number of permutations on your list. You can do it like:

import System.Random
import Data.List

shuffle xs = do
    gen <- getStdGen
    let (permNum,newGen) = randomR (0,fac (length xs) -1) gen
    return $ permutation permNum xs

permutation makes n permutations on the (assumed sorted) list xs . When randomizing, xs need not be sorted however.

fac is just an implementation of the factorial function.

shuffle makes a random number and applies that many permutations to xs .

It's a bit different from what you are trying to do, but it works wonders. I assumed you didn't need to explicitly use your proposed method. You will have to implement permutation and fac yourself though.

For help on permutation , you could look here . It's a description to solve a Project Euler Problem, but you could use the same procedure to make n permutations.

EDIT: I don't know if anyone cares anymore, but I found another way to do it WAY easier:

import System.Random

randPerm :: StdGen -> [a] -> [a]
randPerm _ []   = []
randPerm gen xs = let (n,newGen) = randomR (0,length xs -1) gen
                      front = xs !! n
                  in  front : randPerm newGen (take n xs ++ drop (n+1) xs)

Answer 2

Quite late to the party, but a small improvement over the suggested solution is to use splitAt instead of take & drop:

shuffle :: [a] -> StdGen -> [a]
shuffle []   _   = []
shuffle list generator = let (index,newGenerator) = randomR (0,length list -1) generator
                             (listUntilIndex, element:listAfterIndex) = splitAt index list
                         in  element : shuffle (listUntilIndex ++ listAfterIndex) newGenerator