Dev

kyu-4/Snail/main.hs

@@ -0,0 +1,19 @@
+middle :: [a] -> a
+middle l = head . take 1 . drop len $ l
+  where
+    len = div (length l) 2
+
+getPath _ 0 = []
+getPath l 1 = [middle . middle $ l]
+getPath grid size = foldl (++) [] [ wall1
+                                  , wall2
+                                  , wall3
+                                  , wall4
+                                  , getPath grid (size - 2)
+                                  ]
+  where
+    wall1 = size + take l - 2
+    wall2 = [] -- wall2
+    wall3 = [] -- wall3
+    wall4 = [] -- wall4
+    l = length grid

kyu-4/Strings_mix/main.hs

@@ -0,0 +1,66 @@
+import Data.List (sort, sortBy, group)
+import Data.Function (on)
+import Data.Char (toLower)
+
+-- lenOrder :: Foldable f => f a -> f a -> Ordering
+-- lenOrder x1 x2
+--   | length x1 < length x2 = LT
+--   | length x1 > length x2 = GT
+--   | otherwise = EQ
+
+
+-- greater :: Ord a => [a] -> [a] -> (Char, [a])
+-- greater lx@(x:xs) ly@(y:ys)
+--   | x > y = ('1', lx)
+--   | x < y = ('2', ly)
+--   | otherwise = ('=', lx)
+
+-- longerOrGreater :: Ord a => [a] -> [a] -> (Char, [a])
+-- longerOrGreater x1 x2
+--   | x1Len == GT = ('1', x1)
+--   | x1Len == LT = ('2', x2)
+--   | otherwise = greater x1 x2
+--   where
+--     x1Len = lenOrder x1 x2 
+
+-- solve :: [String] -> [String] -> [String]
+-- solve xs  [] = map ((++) "1:") xs
+-- solve [] ys = map ((++) "2:") ys
+-- solve (x:xs) (y:ys)
+--   | index == '1' = str ++ solve xs ys
+--   | otherwise = str ++ solve xs ys
+--   where
+--     (index, value) = longerOrGreater x y
+--     str = [index : ':' : value]
+
+
+sortLengthThenLexi :: String -> String -> Ordering
+sortLengthThenLexi x y
+  | c == EQ = on compare (map toLower) x y
+  | otherwise = c
+  where
+    c = on (flip compare) length x y
+
+solve :: [String] -> [String]
+solve l = sortBy sortLengthThenLexi l
+
+
+
+
+grouping :: String -> String -> [String]
+grouping index = map ((++) index)
+               . filter (\x -> length x > 1)
+               . group
+               . sort
+               . filter (\x -> x `elem` ['a'..'z'])
+
+main :: IO ()
+main = do
+  let s1 = "my&friend&Paul has heavy hats! &"
+  let s2 = "my friend John has many many friends &a"
+
+  let l1 = grouping "1:" s1
+  let l2 = grouping "2:" s2
+  print l1
+  print l2
+  print . solve . (++) l1 $ l2

kyu-5/Can_you_get_the_loop/main.hs

@@ -0,0 +1,14 @@
+
+-- -- next :: Node a -> Node a
+
+
+
+-- node1 = Node 1 node2
+-- node2 = Node 2 node3
+-- node3 = Node 3 node4
+-- node4 = Node 4 node2
+
+
+-- loopSize :: Eq a => Node a -> Int
+-- loopSize = undefined
+