[FP/HW3] Added comments

1 files changed, 17 insertions, 0 deletions

diff --git a/Year 2/Functional Programming/hw3.hs b/Year 2/Functional Programming/hw3.hs
index f05dcb9..3192d90 100644
--- a/Year 2/Functional Programming/hw3.hs
+++ b/Year 2/Functional Programming/hw3.hs
@@ -2,10 +2,25 @@
 
 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)]]
   where
+    -- Създава лист, където елементите на четни индекси са от a, нечетните са от b, и всички са в растящ ред
+    -- cn се използва за осигуряване на растящия ред, така че първоначалната му стойност ще премахне всички елементи по-малки от него
+    -- accum е резултатния списък, понеже имплементацията използва опашкова рекурсия
     alterconif :: Int -> [Int] -> [Int] -> [Int] -> [Int]
     alterconif cn a [] accum = accum
     alterconif cn [] b accum = accum
@@ -16,6 +31,8 @@ generate as bs = [x : take (takelen - skiplen) (drop skiplen alx) | x <- as,
 
 -- Задача 2
 
+-- Пропускаме всичко до "|" (включително), преобразуваме стринговете в дължини, оставяме само тези,
+-- които отговарят на желаните цифри (1, 4, 7, 8) и бройм
 countUniques :: String -> Int
 countUniques inpt = length (filter (\v -> elem v [2, 3, 4, 7]) (map length (drop 11 (words inpt))))