A recursive solution clear solution for Flatten a List by vnkvstnk - python coding challenges

Enable Javascript in your browser and then refresh this page, for a much enhanced experience.

A recursive solution solution in Clear category for Flatten a List by vnkvstnk

def flat_list(array):
    if not array*0 == 0:
        return [x for el in array for x in flat_list(el)]
    else:
        return [array]

May 25, 2019

Comments:

Kod_Sim on July 17, 2019, 8:18 a.m.
So difficult to understand

vnkvstnk on July 17, 2019, 10 a.m.
Maybe I can help you. 1) Since it's a recursive solution we need a base case - a case in which we know for certain what value to return. In this solution the base case is when the function is called with a number, say ```flat_list(5)```, then we return ```[5]```. 2) If the function is called with a list, for example ```flatlist([1, 2, 3])```, we return the following: ```[x for el in array for x in flatlist(el)]```. Here we do two loops: <pre class='brush: python'>2.1) First, over all the element of \`\`\`array\`\`\`, let's call them inner arrays. In our case it's just number: 1, 2, 3. 2.2) And second, over all the elements of each inner array, but first we apply our function to each of the inner arrays \`\`\`[ ... flat_list(el)]\`\`\`. Since in our case, the inner arrays are simply numbers, we know what to do - it's our base case from step one - we return \`\`\`[inner array]\`\`\`. So, in the end, we iterate over three lists: \`\`\`[1]\`\`\`, \`\`\`[2]\`\`\` and \`\`\`[3]\`\`\` and return their elements gathered together: [1, 2, 3], which, in fact, was our input, but that's okay, we'll see why we need it later. </pre> 3) Let's now consider a case when we get a more complex array as an input: ```flatlist([[1, 2, 3], [4, 5, 6]])```. So first we need to iterate over all of the inner arrays: ```[1, 2, 3]``` and ```[4, 5, 6]```, apply our function to each of the inner arrays and iterate over each element of the output and gather all the elements together. But when we apply our function to each of the inner arrays (```flatlist([1, 2, 3])```), we know what the output is, because we considered this case on step 2! That means, that we simply iterate over each element of two lists and return ```[1, 2, 3, 4, 5, 6]```. By doing this we removed one "level" of inner arrays. Now it should not be difficult to see, that each time when we call ```flat_list()``` we flatten our input array by one "level" and in the end we get the flat list. I realize, that it may not be totally clear yet, but I hope that my explanation will help you begin to understand :)

vnkvstnk on July 17, 2019, 10:07 a.m.
Maybe I can help you. 1) Since it's a recursive solution we need a base case - a case in which we know for certain what value to return. In this solution the base case is when the function is called with a number or a flat array, say ```flatlist(5)``` returns ```[5]``` and ```flatlist([1, 2, 3])``` returns ```[[1, 2, 3]]```). 2) If the function is called with a nested list, for example ```flatlist([[1, 2, 3], [4, 5, 6]])```, we return the following: ```[x for el in array for x in flatlist(el)]```. Here we do two loops: <pre class='brush: python'>2.1) First, over all the element of \`\`\`array\`\`\`, let's call them inner arrays. In our case it's \`\`\`[1, 2, 3]\`\`\` and \`\`\`[4, 5, 6]\`\`\`. 2.2) And second, over all the elements of each inner array, but first we apply our function to each of the inner arrays \`\`\`[ ... flat_list(el)]\`\`\`. Since in our case, the inner arrays are flat arrays, we know what to do - it's our base case from step one - we return \`\`\`[inner array]\`\`\`. So, in the end, we iterate over two lists: \`\`\`[1, 2, 3]\`\`\` and \`\`\`[4, 5, 6]\`\`\`, and return their elements gathered together: [1, 2, 3, 4, 5, 6]. By doing this we removed one "level" of inner arrays. </pre> Now it should not be difficult to see, that each time when we call ```flat_list()``` we flatten our input array by one "level" and in the end we get a flat array. I realize, that it may not be totally clear yet, but I hope that my explanation will help you begin to understand :)

O'Reilly

0 %

New Island