Haskell列表推导列表A listB-> listC

Question

I have two lists with elements ListA ([String]) and sample positions ListB([Int]) how to create a new ListC ([String]) using list comprehensions ?

for example:

the left number is always more right (see ListB)

Step 1: get elem 1, add the head of the ListC
      ListC = ["a"]
Step 2: get elem 2, add the head of the ListC
      ListC = ["c","a"]
Step 3: get elem 1, add the head of the ListC
      ListC = ["b","c","a"]

so the full chain:
a b c -> 1 2 1 -> a -> c a -> b c a

more templates:

ListA::[String]
ListB::[int]
ListC::[String]

ListA    ListB    ListC
a b c -> 3 2 1 -> a b c
a b c -> 2 2 1 -> a c b
a b c -> 3 1 1 -> b a c
a b c -> 1 2 1 -> b c a
a b c -> 2 1 1 -> c a b
a b c -> 1 1 1 -> c b a

this function is to generate valid numeric sequences (note each left element, it is more than the previous one, at least per 1, ie. head is the greatest element)

module Main ( main ) where

import System.Random

main :: IO ()

randomList :: Int -> [Int] -> StdGen -> [Int]
randomList 0 xlist _ = reverse xlist
randomList n xlist gen = randomList (n-1) (randomVal : xlist) gen'
    where (randomVal, gen') = randomR (1,n) gen

shuffle :: [Int] -> [String] -> [String] -> [String]
shuffle [] _ deckB = deckB
shuffle pl deckA deckB = shuffle (tail pl) (hs ++ tail ts) (head ts : deckB)
    where (hs, ts) = splitAt (pos-1) deckA
          pos = head pl

ranks = ["2","3","4","5","6","7","8","9","T","J","Q","K","A"]
suits = ["C","D","H","S"]
deck = [rank ++ suit | suit <- suits, rank <- ranks]

main = do
    gen <- newStdGen
    let len = 52 :: Int
    let permutationList = randomList len [] gen
    let newDeck = shuffle permutationList deck []
    print permutationList
    print deck
    print "-------------------------------------"
    print newDeck

Answer 1

You chose a complicated way to create the permutations but perhaps that's what the problem domain dictates.

The required permutation cannot be created by list comprehensions but can be written with some simple utility functions

first write a drop element function

dropAt :: Int -> [a] -> [a]
dropAt _ [] = []
dropAt n x  = let (h,t) = splitAt n x in (init h) ++ t

now using this your own picking function

pickAt :: [Int] -> [a] -> [a]
pickAt _ [] = []
pickAt [] _ = []
pickAt (n:ns) xs = xs!!(n-1) : pickAt ns (dropAt n xs)

gives you the reverse order though, run through reverse

> reverse $ pickAt [2,1,1] ['a','b','c']
"cab"

> reverse $ pickAt [1,1,1] ['a','b','c']
"cba"