#define NELEMS(x)	((sizeof(x))/(sizeof((x)[0])))

void shell_sort(int arr[], int n)
{
	int i, j, k;
	int gap;
	int sequence[] = {1750, 701, 301, 132, 57, 23, 10, 4, 1};
	int s;

	for(i = 0, s = NELEMS(sequence); i < s; i++)
	{
		gap = sequence[i];

		for(j = gap; j < n; j++)
		{
			int key;
			for(k = j - gap, key = arr[j]; (k >= 0) && (arr[k] > key); k = k - gap)
				arr[k+gap] = arr[k];

			arr[k+gap] = key;
		}
	}
}

import Control.Monad
import Data.List
import Data.List.HT
import Data.Array.IO
import Data.Array.MArray

swap :: (MArray a e m, Ix i, Ord e) => i -> i -> a i e -> m ()
swap i j a = do x <- readArray a i
                y <- readArray a j
                when (y < x) $ writeArray a i y >> writeArray a j x

combSort :: Ord a => [a] -> IO [a]
combSort [] = return []
combSort xs = comb (s-1) =<< newListArray (1, s) xs where
    comb :: Ord a => Int -> IOArray Int a -> IO [a]
    comb 0 a = getElems a
    comb n a = mapM_ (\i -> swap i (i+n) a) [1..s-n] >> comb (n-1) a
    s = length xs

shellSort :: Ord a => [a] -> IO [a]
shellSort [] = return []
shellSort xs = return $ shell (last . takeWhile (< length xs) $
                               iterate (succ . (*3)) 1) xs where
    shell 1 = foldr insert []
    shell n = shell (div (n-1) 3) . concatMap (shell 1) . sliceHorizontal n