Определите функцию, которая порождает множество всех непустых подпоследовательностей для заданной строки

setOfSets :: String -> [String]
setOfSets s | ((length s) == 1) = [[],s]
            | otherwise = ss ++ map (\ x -> cs : x) ss
              where ss = setOfSets (tail s) ; cs = (head s)
 
Main> setOfSets "abc"
["","c","b","bc","a","ac","ab","abc"]
 
Main> setOfSets "abcde"
["","e","d","de","c","ce","cd","cde","b","be","bd","bde","bc","bce","bcd","bcde"
,"a","ae","ad","ade","ac","ace","acd","acde","ab","abe","abd","abde","abc","abce
","abcd","abcde"]

data Chess_fig = Queen Int Int deriving (Show, Eq)
 
check_pos_q :: Chess_fig -> [Chess_fig] -> Bool
check_pos_q _ [] = False
check_pos_q (Queen a b) ((Queen c d):xs) = (((a == c) || (b == d)) || (((a - b) == (c-d)) || ((a + b) == (c + d)))) || (check_pos_q (Queen a b) xs)

import Data.List
 
 
createsubseq :: (Eq a) => [a] -> [[a]]
createsubseq [] = error "Zero-list";
createsubseq xs = nub(nonzerocreatesubseq xs);
 
 
nonzerocreatesubseq :: [a] -> [[a]]
nonzerocreatesubseq [] = []
nonzerocreatesubseq a = [a]  ++ nonzerocreatesubseq (take ((length a) - 1) a) ++ nonzerocreatesubseq (drop 1 a)

data Chess_fig = Queen Int Int deriving (Show, Eq)
type Choice a = [a]
 
choose :: [a] -> Choice a
choose xs = xs
 
mzero :: Choice a
mzero = choose []
 
guard :: Bool -> Choice ()
guard True = return ()
guard False = mzero
 
check_pos_q :: Chess_fig -> [Chess_fig] -> Bool
check_pos_q _ [] = False
check_pos_q (Queen a b) ((Queen c d):xs) = (((a == c) || (b == d)) || ((abs(a - c) == abs(b - d)))) || (check_pos_q (Queen a b) xs)
 
 
create_all_var :: Int -> Int -> [Chess_fig]
create_all_var size vert = [(Queen a vert) | a <- [0..(size-1)]]
 
get_part_sol size n acc = do
  x <- choose acc
  y <- choose $ create_all_var size n
  guard(not (check_pos_q y x))
  return (x,y)

import Control.Monad
 
data Chess_fig = Queen Int Int deriving (Show, Eq)
 
 
 
check_pos_q :: Chess_fig -> [Chess_fig] -> Bool
check_pos_q _ [] = False
check_pos_q (Queen a b) ((Queen c d):xs) = (((a == c) || (b == d)) || ((abs(a - c) == abs(b - d)))) || (check_pos_q (Queen a b) xs)
 
 
create_all_var :: Int -> Int -> [Chess_fig]
create_all_var size vert = [(Queen a vert) | a <- [0..(size-1)]]
 
 
get_part_sol size n acc = do
  x <- acc
  y <- create_all_var size n
  guard(not (check_pos_q y x))
  return (x:y)
 
queens_xxx :: Int -> Int -> [[Chess_fig]] -> [[Chess_fig]]
queens_xxx g size pos_list = 
    if g == (size-1) then pos_list
    else queens_xxx (g+1) size (get_part_sol size g pos_list)
 
queen :: Int -> [[Chess_fig]]
queen size = queens_xxx 0 size [[]]

{-# LANGUAGE TupleSections #-}
 
import Control.Monad
import Data.Functor
 
type Pos = (Int, Int)
type Solution = [Pos]
 
isSafe :: Pos -> Pos -> Bool
isSafe (x1, y1) (x2, y2) =
    x1 /= x2 && y1 /= y2 && abs (x1 - x2) /= abs (y1 - y2)
 
queens :: Int -> [Solution]
queens n = queens' 1 [[]]
    where queens' k sols | k > n     = sols
                         | otherwise = queens' (succ k) $ do
            queen <- (k,) <$> [1..n]
            solution <- sols
            guard $ all (isSafe queen) solution
            return $ queen : solution

import Control.Monad
 
data Chess_fig = Elephant Int Int deriving (Show, Eq)
 
check_pos_el :: Chess_fig -> [Chess_fig] -> Bool
check_pos_el _ [] = False
check_pos_el (Elephant a b) ((Elephant c d):xs) = ((abs(a - c) == abs(b - d)) || (check_pos_el (Elephant a b) xs))
 
create_all_var_el :: Int -> Int -> [Chess_fig]
create_all_var_el size vert = [(Elephant a b) | a <- [0..(size-1)], b <- [vert..(size-1)]]
 
 
get_part_sol_el size n acc = do
  x <- acc
  y <- create_all_var_el size n
  guard(not (check_pos_el y x))
  return (x ++ [y])
 
elephants_xxx :: Int -> Int -> [[Chess_fig]] -> [[Chess_fig]]
elephants_xxx g size pos_list =
    if g == size then pos_list
    else elephants_xxx (g+1) size (get_part_sol_el size g pos_list)
 
elephant :: Int -> [[Chess_fig]]
elephant size = elephants_xxx 0 size [[]]