pythonfunctional-programming

How do I use lambda to replace for loop and still maintained functional programming?


this is the original code

def cage_cats(S): 
    maxtemp = 0
    temp = list(set(S))
    for i in range(len(temp)-1):
        for j in range(len(S)-1):
            if temp[i] == S[j]:
                if S[j] == S[j+1]:
                    break
                else:
                    maxtemp = max(S[j], maxtemp)

    return maxtemp 

And below is the code I'm attempting to make to replicate the code above with different method

def cage_cats(S):
    temp = list(set(S))
    maxtemp = max(
        list(
            map(
                lambda i : (
                    lambda j : (
                        S[j] if temp[i] == S[j] and S[j] == S[j+1] else "None"
                    ),range(len(S)-1)
                ),range(len(temp)-1)
            )
        )
    , 0)

Where do I go wrong in my code? I'm kinda lost on what to do. Is there a method I can use to make the result the same as the original code but still maintain the functional programming part of it?

Edit :

This code is to find the maximum element that is not next to each other.

The length of input will always be even and also every number in the list will only appear 2 times.

For example:

[1, 1, 2, 2, 5, 3, 3, 5] the answer would be 5

[1, 2, 2, 3, 1, 5, 5, 3] the answer would be 3

[1, 1, 2, 2, 3, 3] it would be 0 ( default value )


Solution

  • Here's a solution using only max and some list comprehension to replace the 2 for loops by only 1.

    It works by comparing all the elements in your list with the one before and after and checking if its different to both or no

    S = [1, 2, 2, 3, 1, 5, 5, 3]
    S = ["", *S, ""] # pad with values that you're sure aren't in your list
    filtered_S = [b for a, b, c in zip(S, S[1:], S[2:]) if a != b != c]
    sol = max(filtered_S, default=0)
    # sol = 3
    

    Edit :

    If you want to completely replace for loops, you can also use filter and map to build filtered_S (filter does the filtering using the zipped list, and map takes back the element that interests us)

    filtered_S = map(
        lambda t: t[1], 
        filter(
            lambda t: t[0] != t[1] != t[2], zip(S, S[1:], S[2:])
        )
    )