module Autolib.Util.Wort where

-- -- $Id$

import Autolib.Util.Sort
import Autolib.Util.Uniq

import Autolib.Set
import System.Random

import Data.List ( inits, tails )

zerlegungen :: [a] -> [([a], [a])]
zerlegungen :: forall a. [a] -> [([a], [a])]
zerlegungen [] = [ ([], []) ]
zerlegungen (a
x : [a]
xs) = ([], a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
xs) ([a], [a]) -> [([a], [a])] -> [([a], [a])]
forall a. a -> [a] -> [a]
:
    do (vorn, hinten) <- [a] -> [([a], [a])]
forall a. [a] -> [([a], [a])]
zerlegungen [a]
xs
       return (x : vorn, hinten)

alle :: [a] -> Int -> [[a]]
alle :: forall a. [a] -> Int -> [[a]]
alle [a]
sigma Int
0 = [[]]
alle [a]
sigma Int
n = do
    w <- [a] -> Int -> [[a]]
forall a. [a] -> Int -> [[a]]
alle [a]
sigma (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
    x <- sigma
    return $ x : w

alles :: [a] -> Int -> [[a]]
alles :: forall a. [a] -> Int -> [[a]]
alles [a]
sigma Int
n = do s <- [Int
0 .. Int
n]; alle sigma s

factors :: [a] -> [[a]]
factors :: forall a. [a] -> [[a]]
factors [a]
w = do
    u <- [a] -> [[a]]
forall a. [a] -> [[a]]
tails [a]
w
    inits u

someIO :: [a] -> Int -> IO [a]
someIO :: forall a. [a] -> Int -> IO [a]
someIO [a]
sigma Int
0 = [a] -> IO [a]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return []
someIO [a]
sigma Int
n = do
    w <- [a] -> Int -> IO [a]
forall a. [a] -> Int -> IO [a]
someIO [a]
sigma (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
    k <- randomRIO (0, length sigma-1)
    let x = [a]
sigma [a] -> Int -> a
forall a. HasCallStack => [a] -> Int -> a
!! Int
k
    return $ x : w

shuffle :: Ord a => [a] -> [a] -> [[a]]
shuffle :: forall a. Ord a => [a] -> [a] -> [[a]]
shuffle [a]
xs [] = [ [a]
xs ]
shuffle [] [a]
ys = [ [a]
ys ]
shuffle ( a
x : [a]
xs ) ( a
y : [a]
ys ) = [[a]] -> [[a]]
forall a. Eq a => [a] -> [a]
uniq ([[a]] -> [[a]]) -> [[a]] -> [[a]]
forall a b. (a -> b) -> a -> b
$
     do w <- [a] -> [a] -> [[a]]
forall a. Ord a => [a] -> [a] -> [[a]]
shuffle [a]
xs (a
y a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
ys); return $ x : w
  [[a]] -> [[a]] -> [[a]]
forall a. [a] -> [a] -> [a]
++ do w <- [a] -> [a] -> [[a]]
forall a. Ord a => [a] -> [a] -> [[a]]
shuffle (a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
xs) [a]
ys; return $ y : w

hint :: Show [a] => [ a ] -> String
hint :: forall a. Show [a] => [a] -> String
hint [a]
xs = 
    let 
	([a]
erst, [a]
dann) = Int -> [a] -> ([a], [a])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
5 [a]
xs
    in	[a] -> String
forall a. Show a => a -> String
show [a]
erst
	String -> String -> String
forall a. [a] -> [a] -> [a]
++ if [a] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
dann then String
""
	   else String
"... noch " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show ([a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
dann) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" Stueck"