[FP/HW3] Fixed missing generation in first exercise

1 files changed, 20 insertions, 16 deletions

diff --git a/Year 2/Functional Programming/hw3.hs b/Year 2/Functional Programming/hw3.hs
index 446c83c..90d30f5 100644
--- a/Year 2/Functional Programming/hw3.hs
+++ b/Year 2/Functional Programming/hw3.hs
@@ -1,22 +1,26 @@
 -- Задача 1
 
 generate :: [Int] -> [Int] -> [[Int]]
-generate as bs = [x : take (takelen - skiplen) (drop skiplen alx) | 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)]]
+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]]
   where
     -- Създава лист, където елементите на четни индекси са от a, нечетните са от b, и всички са в растящ ред
     -- cn се използва за осигуряване на растящия ред, така че първоначалната му стойност ще премахне всички елементи по-малки от него