[Haskell-beginners] Better Code

[Carlo Matteo Scalzo]

Hi Saqib,

perhaps something like this?


divide :: [Int] -> [[Int]]



divide []     = []



divide (x:xs) = divideAux xs [] [x] x







divideAux :: [Int] -> [[Int]] -> [Int] -> Int -> [[Int]]



divideAux [] result current max        = result ++ [current]



divideAux (x:xs) result current max = if x - max > 1



                                                              then
divideAux xs (result ++ [current]) [x] x


                                                              else
divideAux xs result (current ++ [x]) x


This can of course be generalised to other types (as per Joel's
requirement) just by replacing the check on line 7, i.e., 'x - max > 1'.

Happy to explain/talk about the code if you'd like me to :-)

Cheers,

Carlo

On Fri, Jan 13, 2017 at 7:14 PM, Joel Neely <joel.neely at gmail.com> wrote:

> Had a chance to chat with ghci, so earlier conjecture not confirmed:
>
> Prelude Data.List> groupBy (\x y -> x == y-1) [1,2,3,7,8,10,11,12]
>
> [[1,2],[3],[7,8],[10,11],[12]]
>
> So close but no cigar.
>
> On Fri, Jan 13, 2017 at 10:05 AM, Saqib Shamsi <shamsi.saqib at gmail.com>
> wrote:
>
>> Hi,
>>
>> The problem that I wish to solve is to divide a (sored) list of integers
>> into sublists such that each sublist contains numbers in consecutive
>> sequence.
>>
>> For example,
>> *Input:* [1,2,3,7,8,10,11,12]
>> *Output:* [[1,2,3],[7,8],[10,11,12]]
>>
>> I have written the following code and it does the trick.
>>
>> -- Take a list and divide it at first point of non-consecutive number
>> encounter
>> divide :: [Int] -> [Int] -> ([Int], [Int])
>> divide first [] = (first, [])
>> divide first second = if (last first) /= firstSecond - 1 then (first,
>> second)
>>                       else divide (first ++ [firstSecond]) (tail second)
>>                       where firstSecond = head second
>>
>>
>> -- Helper for breaking a list of numbers into consecutive sublists
>> breakIntoConsecsHelper :: [Int] -> [[Int]] -> [[Int]]
>> breakIntoConsecsHelper [] [[]] = [[]]
>> breakIntoConsecsHelper lst ans = if two == [] then ans ++ [one]
>>                                  else ans ++ [one] ++
>> breakIntoConsecsHelper two []
>>                                  where
>>                                       firstElem = head lst
>>                                       remaining = tail lst
>>                                       (one, two) = divide [firstElem]
>> remaining
>>
>>
>> -- Break the list into sublists of consective numbers
>> breakIntoConsecs :: [Int] -> [[Int]]
>> breakIntoConsecs lst = breakIntoConsecsHelper lst [[]]
>>
>> -- Take the tail of the result given by the function above to get the
>> required list of lists.
>>
>> However, I was wondering if there was a better way of doing this. Any
>> help would be highly appreciated.
>>
>> Thank you.
>> Best Regards,
>> Saqib Shamsi
>>
>> _______________________________________________
>> Beginners mailing list
>> Beginners at haskell.org
>> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>>
>>
>
>
> --
> Beauty of style and harmony and grace and good rhythm depend on
> simplicity. - Plato
>
> _______________________________________________
> Beginners mailing list
> Beginners at haskell.org
> http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners
>
>


-- 
Carlo Matteo Scalzo

Mobile: +44 (0) 7934 583582

E-mail: cmscalzo at gmail.com
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/beginners/attachments/20170113/6b9425f2/attachment.html>