[FP/HW3] Finally created a work solution for exercise 1

1 files changed, 13 insertions, 31 deletions

diff --git a/Year 2/Functional Programming/hw3.hs b/Year 2/Functional Programming/hw3.hs
index 90d30f5..041c24d 100644
--- a/Year 2/Functional Programming/hw3.hs
+++ b/Year 2/Functional Programming/hw3.hs
@@ -1,37 +1,19 @@
 -- Задача 1
 
 generate :: [Int] -> [Int] -> [[Int]]
-generate as bs = [x : take (takelen - skiplen) (head dropped : dropped !! trailingStart : (drop (1 + trailingStart + trailingContinue) dropped)) |
-                    x <- as,
-                    -- Най-дългата последователност от редуващи се числа, започвайки от x, без x
-                    -- Примерно: [20, 25, 30, 35, 40]
-                    let alx = tail (alterconif x as bs []),
-                    -- Вземаме първите няколко от тях за да образуваме по-къса редуваща се последователност
-                    -- Вземаме нечетен брой, понеже x винаги го долепяме в началото
-                    -- Примерно ще вземем: [20], [20, 25, 30], [20, 25, 30, 35, 40]
-                    takelen <- [1,3..(length alx)],
-                    -- За всяка по-къса редуваща се последователност, взимаме брой елементи от края,
-                    -- за да изброим всички възможности, при които числото от bs е по-голямо от x
-                    -- (може да има повече от едно число от bs > x и може да има достатъчно числа в
-                    --  bs и as за да се продължи построението)
-                    -- Примерно: за [20] взимаме само [20]
-                    --           за [20, 25, 30] взимаме [20, 25, 30] и [30]
-                    --           за [20, 25, 30, 35, 40] взимаме [20, 25, 30, 35, 40], [30, 35, 40] и [40]
-                    skiplen <- [0,2..(takelen - 1)],
-                    let dropped = drop skiplen alx,
-                    trailingStart    <- if takelen >= 5 then [1,3..(takelen - skiplen - 1)] else [1],
-                    trailingContinue <- if takelen >= 5 then [0,2..(takelen - skiplen - 1 - trailingStart)] else [0]]
+generate as bs = asiter as bs (head as)
   where
-    -- Създава лист, където елементите на четни индекси са от a, нечетните са от b, и всички са в растящ ред
-    -- cn се използва за осигуряване на растящия ред, така че първоначалната му стойност ще премахне всички елементи по-малки от него
-    -- accum е резултатния списък, понеже имплементацията използва опашкова рекурсия
-    alterconif :: Int -> [Int] -> [Int] -> [Int] -> [Int]
-    alterconif cn a [] accum = accum
-    alterconif cn [] b accum = accum
-    alterconif cn a b accum
-      | (head a) < cn = alterconif cn       (tail a) b        accum
-      | (head b) < cn = alterconif cn       a        (tail b) accum
-      | otherwise     = alterconif (head b) (tail a) (tail b) (accum ++ [head a, head b])
+    asiter [] _ _  = []
+    asiter as bs minm
+      | head as < minm = asiter (tail as) bs minm
+      | otherwise = bsiter as bs (head as) ++ asiter (tail as) bs (head as)
+
+    bsiter _ [] _ = []
+    bsiter as bs minm
+      | head bs < minm = bsiter as (tail bs) minm
+      | otherwise = [[head as, head bs]]
+                    ++ (map (\x -> [head as, head bs] ++ x) (asiter (tail as) (tail bs) (head bs)))
+                    ++ bsiter as (tail bs) (head bs)
 
 -- Задача 2
 
@@ -42,7 +24,7 @@ countUniques inpt = length (filter (\v -> elem v [2, 3, 4, 7]) (map length (drop
 
 main :: IO()
 main = do
-    print(generate [10, 15, 25, 35] [1, 5, 20, 30, 40])
+    print(generate [10, 15, 25, 35, 45] [1, 5, 20, 30, 40, 50])
 
     inpt <- readFile "input.txt"
     print(foldr (\el accum -> accum + (countUniques el)) 0 (lines inpt))