Haskell List Comprehensions listA listB -> listC - list

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"