Oscar Picasso oscarpicasso at gmail.com
Wed Aug 31 22:09:36 CEST 2011

```Very interesting. But for my taste I would do a cosmetic change. I
tend to find it more readable when function calls are written
vertically when they have with a great number of parameters or a lot
of parens like here.

listof4tuples xs = zip4
xs
(tail xs)
(tail (tail xs))
(tail (tail (tail xs)))

On Tue, Aug 30, 2011 at 1:41 PM, KC <kc1956 at gmail.com> wrote:
> You might like this zipping & folding version.
>
> Explicit recursion has the disadvantage that one has to read the
> entire function in order to figure out what's going on; whereas using
> the higher order functions makes things much easier to grasp.
>
> listof4tuples xs = (zip4 xs (tail xs) (tail (tail xs)) (tail (tail (tail xs))))
>
> prods xs = map prods4 (listof4tuples xs)
>
> prods4 (t,u,v,w) = t*u*v*w
>
> maxprods4 xs = maximum \$ prods xs
>
> On Mon, Aug 29, 2011 at 9:40 AM, Oscar Picasso <oscarpicasso at gmail.com> wrote:
>> Got it.
>>
>> f :: [Int] -> Int
>> f (t:u:v:xs) = helper t u v xs
>>
>> helper :: Int -> Int -> Int -> [Int] -> Int
>> helper t u v (w:ws)
>>  | ws == []  = t*u*v*w
>>  | otherwise = max (t*u*v*w) (f (u:v:w:ws))
>>
>> I tend to overlook mutual recursion in my toolbox.
>>
>> Thanks for the nnlightenment.
>>
>> On Sun, Aug 28, 2011 at 4:54 PM, KC <kc1956 at gmail.com> wrote:
>>> Try something like the following:
>>>
>>> -- Project Euler 11
>>>
>>> -- In the 20×20 grid below, four numbers along a diagonal line have
>>> been marked in red.
>>>
>>> -- <snip>
>>>
>>> -- The product of these numbers is 26 × 63 × 78 × 14 = 1788696.
>>>
>>> -- What is the greatest product of four adjacent numbers in any
>>> direction (up, down, left, right, or diagonally) in the 20×20 grid?
>>>
>>>
>>> import Data.List
>>>
>>> -- Doing the one dimensional case.
>>> f011 :: [Int] -> Int
>>> f011 (t:u:v:xs) = f011helper t u v xs
>>>
>>> f011helper :: Int -> Int -> Int -> [Int] -> Int
>>> f011helper t u v (w:ws)
>>>    | ws == []  = t*u*v*w
>>>
>>>
>>> -- The 20x20 grid case will become:
>>> f0112D :: [[Int]] -> Int
>>> -- where [[Int]] is a list of lists of rows, columns, major diagonals,
>>> & minor diagonals.
>>>
>>>
>>>
>>>
>>> On Sun, Aug 28, 2011 at 5:10 AM, Oscar Picasso <oscarpicasso at gmail.com> wrote:
>>>> No. The answer I posted is not good.
>>>> It worked, by chance, on a couple of small examples I tried but it
>>>> could end up comparing sequence of 4 numbers that where not initially
>>>>
>>>> On Sun, Aug 28, 2011 at 12:32 AM, Oscar Picasso <oscarpicasso at gmail.com> wrote:
>>>>> Maybe this?
>>>>>
>>>>> f x@(a:b:c:d:[]) = x
>>>>> f (a:b:c:d:e:ys)  = if e >= a
>>>>>                   then f (b:c:d:e:ys)
>>>>>                   else f (a:b:c:d:ys)
>>>>>
>>>>> On Sat, Aug 27, 2011 at 8:26 PM, KC <kc1956 at gmail.com> wrote:
>>>>>> Think of the simplest version of the problem that isn't totally trivial.
>>>>>>
>>>>>> e.g. A one dimensional list of numbers.
>>>>>>
>>>>>> What would you do?
>>>>>>
>>>>>> Note: you only want to touch each element once.
>>>>>>
>>>>>> The 2 dimensional case could be handled by putting into lists: rows,
>>>>>> columns, major diagonals, and minor diagonals.
>>>>>>
>>>>>> This isn't the fastest way of doing the problem but it has the
>>>>>>
>>>>>>
>>>>>> On Fri, Aug 26, 2011 at 6:15 PM, Oscar Picasso <oscarpicasso at gmail.com> wrote:
>>>>>>> Like:
>>>>>>> 20*19*21*18
>>>>>>> is bigger than
>>>>>>> 100*100*3*2
>>>>>>> ?
>>>>>>>
>>>>>>> If so I need to think about how to formalize it.
>>>>>>>
>>>>>>> Thanks for the hint.
>>>>>>>
>>>>>>> On Fri, Aug 26, 2011 at 8:55 PM, KC <kc1956 at gmail.com> wrote:
>>>>>>>> Is Problem 11 the 4 consecutive #'s problem?
>>>>>>>>
>>>>>>>> If so what must be true for 4 #'s to have a large product?
>>>>>>>>
>>>>>>>> Hint: x * y * z * 2 is that going to be larger?
>>>>>>>>
>>>>>>>> --
>>>>>>>> --
>>>>>>>> Regards,
>>>>>>>> KC
>>>>>>>>
>>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> --
>>>>>> --
>>>>>> Regards,
>>>>>> KC
>>>>>>
>>>>>
>>>>
>>>
>>>
>>>
>>> --
>>> --
>>> Regards,
>>> KC
>>>
>>
>
>
>
> --
> --
> Regards,
> KC
>

```