CODEWITHSUNDEEP
javascriptecmascript-6
wuno
wuno

Reputation: 9885

Expanding use of Javascript array.reduce helper method

Background

I am following a course on Udemy which goes over all of the ES6 features. In one of the lessons the instructor talks about using the reduce helper method to solve the popular balance parenthesis interview question.

I can solve this without the reduce method. Although with the reduce method it does get the job done in less code. I have been asked to find the depth of the parenthesis in an interview before and was wondering if this could all be done in the same method using reduce.

I do not know why this addition to the question confuses me so much but I would like to learn.

Problem

I have been trying to figure it out for a while and it might be my lack of understanding how reduce works.

Example

This uses reduce to return true of false regarding if the parenthesis or open and closed evenly. 

function balanceParens(string) {
    return !string.split("").reduce((counter, char) => {
        // Handle if parens open and close out of order
        if (counter < 0) { return counter; }
        // Add 1 for each open in order
        if (char === "(") { return ++counter; }
        // subtract 1 for each close in order
        if (char === ")") { return --counter; }
        // handle use case if char is not a paren
        return counter;
    }, 0);
}
console.log(balanceParens("((()))"));

Question

How would I return the max depth of the parenthesis using the reduce helper method.

Upvotes: 3

Views: 417

Answers (3)

trincot
trincot

Reputation: 350770

Here is a compact version that returns NaN when the parentheses are not balanced. It uses nested functions in a functional style:

function maxDepth(string) {
    return ( ([depth, max]) => depth ? NaN : max )
        ([...string].reduce(([depth, max], ch) => 
            (newDepth => [newDepth, newDepth < 0 ? NaN : Math.max(max, newDepth)])
                 (depth + (ch === "(") - (ch === ")"))
        , [0, 0]));
}
console.log(maxDepth("(((()))(((())))()(((((()))))))"));

Upvotes: 1

Yury Tarabanko
Yury Tarabanko

Reputation: 45121

You could maintain current depth and max depth while reducing.

function maxDepth(string) {
    return string.split("").reduce(({current, max}, char) => {
        // Handle if parens open and close out of order
        if (current < 0) return {current, max}
        // Add 1 for each open in order
        if (char === "(") return { current: current + 1, max: Math.max(max, current + 1)}
        // subtract 1 for each close in order
        if (char === ")") return { current: current - 1, max}
        return {current, max}
    }, {current: 0, max: 0}).max;
}
console.log(maxDepth("(((()))(((())))()(((((()))))))"));

Upvotes: 3

Aftab Khan
Aftab Khan

Reputation: 3923

This should answer it!

function balanceParens(string) {
    let max = 0;
    let res = string.split("").reduce((counter, char) => {
        // Handle if parens open and close out of order
        if (counter < 0) { 
          return counter;
        }
        // Add 1 for each open in order
        if (char === "(") {
          if(++counter > max) {
            max = counter;
          }
          return counter;
        }
        // subtract 1 for each close in order
        if (char === ")") {
          return --counter;
        }
        // handle use case if char is not a paren
        return counter;
    }, 0);
    console.log("Max depth was :", max);
    return !res;
}
console.log(balanceParens("((()(((())))))((((()))))"));

Upvotes: 0

Related Questions