How can recursion be used in JavaScript to find the longest string within a nested array?

Question

How can recursion be used in JavaScript to find the longest string within a nested array?

After reviewing multiple solutions for finding the longest string in an array, I encountered a new challenge. I am now trying to find the longest string within a nested array. The nesting levels can vary from N-levels deep to just two levels deep. My initial solution is outlined below:

    let myArray = [
    'ABC',
    'ABCD',
    'ABCDE',
    [
      'ABC',
      'ABCABABA',
      [
        'ABABABABABABABABAZZ'
      ],
    'ABCABABASS',

     ],
   'ABCDEFGH',
   'ABABABABZZQ'
   ]

function longestString(arr) {
let longestStr = ''
arr.forEach(item => {
if(typeof item === 'string') {
  if(item.length > longestStr.length) {
    longestStr = item;
    console.log('Longest Item', item);
  }    
} else {
    longestString(item)
  }
})
 return longestStr;
}

console.log(longestString(myArray))

Current Output -> ABABABABZZQ

Desired Output -> 'ABABABABABABABABAZZ'

What adjustment is necessary to only display the longest string?

javascript arrays recursion

Answer 1

Answer №1

To get the desired output from the recursive call, it is important to utilize the return value effectively. Take the string returned by the recursive call and compare it against the item in the same way you compared them previously. If the returned string is longer than longestStr, update longestStr with this new value:

let myArray = [
  'ABC',
  'ABCD',
  'ABCDE', [
    'ABC',
    'ABCABABA', [
      'ABABABABABABABABAZZ'
    ],
    'ABCABABASS',

  ],
  'ABCDEFGH',
  'ABABABABZZQ'
]

function longestString(arr) {
  let longestStr = ''
  arr.forEach(item => {
    if (typeof item === 'string') {
      if (item.length > longestStr.length) {
        longestStr = item;
      }
    } else {
      const nestedLongest = longestString(item);
      if (nestedLongest.length > longestStr.length) {
        longestStr = nestedLongest;
      }
    }
  })
  return longestStr;
}

console.log(longestString(myArray))

In a more concise approach, you can avoid repetition by utilizing a helper function for comparison:

const myArray=['ABC','ABCD','ABCDE',['ABC','ABCABABA',['ABABABABABABABABAZZ'],'ABCABABASS',],'ABCDEFGH','ABABABABZZQ']

function longestString(arr) {
  let longestStr = '';
  const check = str => {
    if (str.length > longestStr.length) longestStr = str;
  };
  arr.forEach(item => {
    check(typeof item === 'string' ? item : longestString(item));
  });
  return longestStr;
}

console.log(longestString(myArray))

Another approach involves using an inner function that maintains a persistent longestStr variable throughout the scope of the longestString function. This eliminates the need to handle recursive call results separately:

const myArray=['ABC','ABCD','ABCDE',['ABC','ABCABABA',['ABABABABABABABABAZZ'],'ABCABABASS',],'ABCDEFGH','ABABABABZZQ']

function longestString(input) {
  let longestStr = '';
  const check = str => {
    if (str.length > longestStr.length) longestStr = str;
  };
  function recursiveFn(arr) {
    arr.forEach((item) => {
      if (typeof item === 'string') check(item)
      else recursiveFn(item);
    });
  }
  recursiveFn(input);
  return longestStr;
}

console.log(longestString(myArray))

Answer 2

To get the desired output from the recursive call, it is important to utilize the return value effectively. Take the string returned by the recursive call and compare it against the item in the same way you compared them previously. If the returned string is longer than longestStr, update longestStr with this new value:

let myArray = [
  'ABC',
  'ABCD',
  'ABCDE', [
    'ABC',
    'ABCABABA', [
      'ABABABABABABABABAZZ'
    ],
    'ABCABABASS',

  ],
  'ABCDEFGH',
  'ABABABABZZQ'
]

function longestString(arr) {
  let longestStr = ''
  arr.forEach(item => {
    if (typeof item === 'string') {
      if (item.length > longestStr.length) {
        longestStr = item;
      }
    } else {
      const nestedLongest = longestString(item);
      if (nestedLongest.length > longestStr.length) {
        longestStr = nestedLongest;
      }
    }
  })
  return longestStr;
}

console.log(longestString(myArray))

In a more concise approach, you can avoid repetition by utilizing a helper function for comparison:

const myArray=['ABC','ABCD','ABCDE',['ABC','ABCABABA',['ABABABABABABABABAZZ'],'ABCABABASS',],'ABCDEFGH','ABABABABZZQ']

function longestString(arr) {
  let longestStr = '';
  const check = str => {
    if (str.length > longestStr.length) longestStr = str;
  };
  arr.forEach(item => {
    check(typeof item === 'string' ? item : longestString(item));
  });
  return longestStr;
}

console.log(longestString(myArray))

Another approach involves using an inner function that maintains a persistent longestStr variable throughout the scope of the longestString function. This eliminates the need to handle recursive call results separately:

const myArray=['ABC','ABCD','ABCDE',['ABC','ABCABABA',['ABABABABABABABABAZZ'],'ABCABABASS',],'ABCDEFGH','ABABABABZZQ']

function longestString(input) {
  let longestStr = '';
  const check = str => {
    if (str.length > longestStr.length) longestStr = str;
  };
  function recursiveFn(arr) {
    arr.forEach((item) => {
      if (typeof item === 'string') check(item)
      else recursiveFn(item);
    });
  }
  recursiveFn(input);
  return longestStr;
}

console.log(longestString(myArray))

Answer 3

Answer №2

Utilize the Array.flat() method to flatten out the array, followed by using Array.reduce() to determine the longest item:

const myArray = [
  'ABC',
  'ABCD',
  'ABCDE', [
    'ABC',
    'ABCABABA', [
      'ABABABABABABABABAZZ'
    ],
    'ABCABABASS',

  ],
  'ABCDEFGH',
  'ABABABABZZQ'
]

const result = myArray
  .flat(Infinity)
  .reduce((r, s) => s.length > r.length ? s : r);
  
console.log(result);

Answer 4

Utilize the Array.flat() method to flatten out the array, followed by using Array.reduce() to determine the longest item:

const myArray = [
  'ABC',
  'ABCD',
  'ABCDE', [
    'ABC',
    'ABCABABA', [
      'ABABABABABABABABAZZ'
    ],
    'ABCABABASS',

  ],
  'ABCDEFGH',
  'ABABABABZZQ'
]

const result = myArray
  .flat(Infinity)
  .reduce((r, s) => s.length > r.length ? s : r);
  
console.log(result);

Answer 5

Answer №3

You have the ability to achieve this using just one reduce method

const myArray = [
  'ABC',
  'ABCD',
  'ABCDE', [
    'ABC',
    'ABCABABA', [
      'ABABABABABABABABAZZ'
    ],
    'ABCABABASS',

  ],
  'ABCDEFGH',
  'ABABABABZZQ'
];

const findLongestString = array => array.reduce((result, item) => typeof item === 'string' ? item.length > result ? item : result : findLongestString(item), '');
  
console.log(findLongestString(myArray));

Answer 6

You have the ability to achieve this using just one reduce method

const myArray = [
  'ABC',
  'ABCD',
  'ABCDE', [
    'ABC',
    'ABCABABA', [
      'ABABABABABABABABAZZ'
    ],
    'ABCABABASS',

  ],
  'ABCDEFGH',
  'ABABABABZZQ'
];

const findLongestString = array => array.reduce((result, item) => typeof item === 'string' ? item.length > result ? item : result : findLongestString(item), '');
  
console.log(findLongestString(myArray));

Answer 7

Answer №4

To start, make sure you declare the variable longestStr outside of the function. Additionally, remember to use the return keyword.

return longestString(item)

let myArray = [['ABC','ABCD','ABCDE',
    ['ABC','ABCABABA',
    ['ABABABABABABABABAZZ'],
    'ABCABABASS'],
   'ABCDEFGH',
   'ABABABABZZQ']]
   
let longestStr = ''
function longestString(arr) {
  arr.forEach(item => {
    if(typeof item === 'string') {
      if(item.length > longestStr.length) {
        longestStr = item;
        console.log('Longest Item', item);
      }    
      } else {
        return longestString(item)
      }
  });
  return longestStr;
}

console.log(longestString(myArray));

UPDATE - You can now pass the parameter longestStr to the longestString function

let myArray = [['ABC','ABCD','ABCDE',
    ['ABC','ABCABABA',
    ['ABABABABABABABABAZZ'],
    'ABCABABASS'],
   'ABCDEFGH',
   'ABABABABZZQ']]

function longestString(arr,longestStr) {
  arr.forEach(item => {
    if(typeof item === 'string') {
      if(item.length > longestStr.length) {
        longestStr = item;
        console.log('Longest Item', item);
      }    
      } else {
        var value = longestString(item,longestStr);
        if(value.length > longestStr.length){
           longestStr = value;
        }
        return longestStr;
      }
  });
  return longestStr;
}

console.log(longestString(myArray,''));

Answer 8

To start, make sure you declare the variable longestStr outside of the function. Additionally, remember to use the return keyword.

return longestString(item)

let myArray = [['ABC','ABCD','ABCDE',
    ['ABC','ABCABABA',
    ['ABABABABABABABABAZZ'],
    'ABCABABASS'],
   'ABCDEFGH',
   'ABABABABZZQ']]
   
let longestStr = ''
function longestString(arr) {
  arr.forEach(item => {
    if(typeof item === 'string') {
      if(item.length > longestStr.length) {
        longestStr = item;
        console.log('Longest Item', item);
      }    
      } else {
        return longestString(item)
      }
  });
  return longestStr;
}

console.log(longestString(myArray));

UPDATE - You can now pass the parameter longestStr to the longestString function

let myArray = [['ABC','ABCD','ABCDE',
    ['ABC','ABCABABA',
    ['ABABABABABABABABAZZ'],
    'ABCABABASS'],
   'ABCDEFGH',
   'ABABABABZZQ']]

function longestString(arr,longestStr) {
  arr.forEach(item => {
    if(typeof item === 'string') {
      if(item.length > longestStr.length) {
        longestStr = item;
        console.log('Longest Item', item);
      }    
      } else {
        var value = longestString(item,longestStr);
        if(value.length > longestStr.length){
           longestStr = value;
        }
        return longestStr;
      }
  });
  return longestStr;
}

console.log(longestString(myArray,''));

Answer 9

Answer №5

By utilizing recursive calls, the function findLongestStr can determine the longest string within an input array while keeping track of the current maximum value.

let myArray = [
    'ABC',
    'ABCD',
    'ABCDE',
    [
      'ABC',
      'ABCABABA',
      [
        'ABABABABABABABABAZZ'
      ],
    'ABCABABASS',

     ],
   'ABCDEFGH',
   'ABABABABZZQ'
   ];

function findLongestStr(input){
  return input.reduce(function(o,i){
     if(i.constructor === Array){
        var value = findLongestStr(i);
        console.log("value array => ",value);
        if(o.length < value.length){
          o = value;
        }
     }else{
           console.log("value i => ",i);
        if(o.length < i.length){
          o = i;
        }
     }
     return o;
  },"");
}

console.log("max length => ",findLongestStr(myArray));

To see this code in action, refer to the jsFiddle demo - https://jsfiddle.net/k4yo35hb/1/

Answer 10

By utilizing recursive calls, the function findLongestStr can determine the longest string within an input array while keeping track of the current maximum value.

let myArray = [
    'ABC',
    'ABCD',
    'ABCDE',
    [
      'ABC',
      'ABCABABA',
      [
        'ABABABABABABABABAZZ'
      ],
    'ABCABABASS',

     ],
   'ABCDEFGH',
   'ABABABABZZQ'
   ];

function findLongestStr(input){
  return input.reduce(function(o,i){
     if(i.constructor === Array){
        var value = findLongestStr(i);
        console.log("value array => ",value);
        if(o.length < value.length){
          o = value;
        }
     }else{
           console.log("value i => ",i);
        if(o.length < i.length){
          o = i;
        }
     }
     return o;
  },"");
}

console.log("max length => ",findLongestStr(myArray));

To see this code in action, refer to the jsFiddle demo - https://jsfiddle.net/k4yo35hb/1/

Answer 11

Answer №6

Your code has a key issue where the variable longestStr is redefined every time the recursive function is called, preventing you from comparing the longest string from each recursive call effectively.

One solution is to utilize the reduce() method, which is perfect for finding the maximum value in a regular un-nested array. By incorporating some recursion and still using reduce(), you can maintain state between recursions as all the recursive calls unwind within the reduce function:

let myArray = ['ABC','ABCD','ABCDE',['ABC','ABCABABA',['ABABABABABABABABAZZ'],'ABCABABASS',],'ABCDEFGH','ABABABABZZQ']


function longestString(arr) {
  return arr.reduce((longest, item) => {
    if (Array.isArray(item)) {
      let rec = longestString(item)
      if (rec.length > longest.length) longest = rec
    } else if (item.length > longest.length) longest = item;

    return longest
  }, '')
}

console.log(longestString(myArray))

Answer 12

Your code has a key issue where the variable longestStr is redefined every time the recursive function is called, preventing you from comparing the longest string from each recursive call effectively.

One solution is to utilize the reduce() method, which is perfect for finding the maximum value in a regular un-nested array. By incorporating some recursion and still using reduce(), you can maintain state between recursions as all the recursive calls unwind within the reduce function:

let myArray = ['ABC','ABCD','ABCDE',['ABC','ABCABABA',['ABABABABABABABABAZZ'],'ABCABABASS',],'ABCDEFGH','ABABABABZZQ']


function longestString(arr) {
  return arr.reduce((longest, item) => {
    if (Array.isArray(item)) {
      let rec = longestString(item)
      if (rec.length > longest.length) longest = rec
    } else if (item.length > longest.length) longest = item;

    return longest
  }, '')
}

console.log(longestString(myArray))

Answer 13

Answer №7

In reference to @Adrian Brand's detailed response, the following is the proposed solution:

function getMaxStringLengthInArray(arr, initialMax = '') {
    return arr.reduce((currentMax, item) => {
        if (typeof item === 'string') {
            return item.length > currentMax.length ? item : currentMax;
        } else {
            return getMaxStringLengthInArray(item, currentMax);
        }
    }, initialMax);
}

Answer 14

In reference to @Adrian Brand's detailed response, the following is the proposed solution:

function getMaxStringLengthInArray(arr, initialMax = '') {
    return arr.reduce((currentMax, item) => {
        if (typeof item === 'string') {
            return item.length > currentMax.length ? item : currentMax;
        } else {
            return getMaxStringLengthInArray(item, currentMax);
        }
    }, initialMax);
}

How can recursion be used in JavaScript to find the longest string within a nested array?

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Answer №6

Answer №7

Similar questions

Issue with Angular Promise ($q) functionality being non-operational

Having trouble getting multiple OR conditions in a PHP if() statement to work correctly. I've checked the array values and everything seems fine. Any idea what I

Change the size of Jive Addon Tile in a vertical orientation

Creating a personalized router with Nuxt

Triggering a Bootstrap 5 dropdown through code is only effective within the browser's developer console, rather than standard JavaScript implementation

Issue found in React Js test - TypeError: source.on does not exist as a function

Utilizing Vue.js with Electron: Establishing seamless data synchronization between backend and frontend

Steps to find the First Non Repeating Character in a PHP string

What could be causing this if statement to fail in verifying if a specific number is present within an array?

Issue with AngularJS directive: Isolated scope preventing values from being inserted into template

ES6 Conditional Import and Export: Leveraging the Power of Conditional

Toggle switch with active state

Executing a server-side Java function from client-side JavaScript or jQuery on a JSP page

The Electron application is experiencing difficulties locating the module at /resources/app/index.js

What steps can I take to create a form supported by MobX that allows for instant propagation of changes and includes an undo

Fetching dynamic JavaScript generated by PHP

Retrieve a specific string from the initial elements of the array

How to Create a Custom Callback Function for jQuery's .html

Is the execution of renderer.render() synchronous or asynchronous?

Calculate the total of the smallest values in three columns as they are updated in real-time