/**
 * @param {number[]} height
 * @return {number}
 */
var maxArea = function(height) {
    let left = 0;
    let right = height.length-1;
    let maxWater = 0;
    
    while (left < right) {
        const water = (right-left) * Math.min(height[left], height[right]);

        if (water > maxWater) {
            maxWater = water;
        }
        
        if (height[left] < height[right]) {
            left++;
        } else {
            right--;
        }
    }
    
    return maxWater;
};

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    const numsToFind = {};
    
    for (let i=0; i<nums.length; i++) {
        const numToFind = nums[i];
        if (numsToFind[numToFind] >= 0) {
            return [i, numsToFind[numToFind]];
        }
        numsToFind[target - numToFind] = i;    
    }
};

/**
 * @param {string} s
 * @return {string}
 */
var minRemoveToMakeValid = function(s) {
    const stack = [];
    const charArray = s.split("");
    const rightBracketsToRemove = [];
    
    for (let i=0;i<charArray.length;i++) {
        if (charArray[i] === '(') {
            stack.push(i);
        } else if (charArray[i] === ')' && stack.length > 0) {
            stack.pop();
        } else if (charArray[i] === ')') {
            charArray[i] = '';
        }
    }

    while (stack.length > 0) {
        const i = stack.pop();
        charArray[i] = '';
    }
    
    return charArray.join('');
};

Ref: https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/

/**
 * @param {string} s
 * @return {boolean}
 */
var isValid = function(s) {
    const stack = [];
    const brackets = {
        '(': ')',
        '{': '}',
        '[': ']'
    };
    
    for (i=0; i<s.length; i++) {
        if (s.length === 0) return true;
        
        const c = s[i];
        if (brackets[c]) {
            stack.push(c);
        } else {
            const lastBracket = stack.pop(); 
            if (brackets[lastBracket] !== c) return false;
        }
    }
    
    if (stack.length > 0) return false;
    
    return true;
};

Ref: https://leetcode.com/problems/valid-parentheses/

class Solution {

    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function waysToMakeFair($nums) {
        $len = count($nums);
        $ans = 0;
        
        $leftOdd = 0;
        $rightOdd = 0;
        $leftEven = 0;
        $rightEven = 0;
        
        for ($i=0; $i<$len; $i++) {
            if ($i%2 === 0) 
                $rightEven += $nums[$i];
            else
                $rightOdd += $nums[$i];              
        }
        
        for ($i=0; $i<$len; $i++) {
            if ($i%2 === 0) 
                $rightEven -= $nums[$i];
            else
                $rightOdd -= $nums[$i];
            
            if ($leftEven + $rightOdd === $rightEven + $leftOdd) $ans++;
            
            if ($i%2 === 0)
                $leftEven += $nums[$i];
            else
                $leftOdd += $nums[$i];
        }
        
        return $ans;     
    }
}

This seems simple but initially I went down wrong path, trying to use way too many arrays. I gave up and looked at https://leetcode.com/problems/ways-to-make-a-fair-array/discuss/944567/Java-O(N)-and-constant-space-beats-100-easy-solution. My solution is basically transpilation of it in PHP.

Ref: https://leetcode.com/problems/ways-to-make-a-fair-array/

class Solution {

    /**
     * @param Integer[][] $matrix
     * @return NULL
     */
    function setZeroes(&$matrix) {
        $rowsToZeroOut = [];
        $colsToZeroOut = [];
        for ($i=0; $i<count($matrix); $i++) {
            for ($j=0; $j<count($matrix[$i]); $j++) {
                if ($matrix[$i][$j] === 0) {
                    $rowsToZeroOut[] = $i;
                    $colsToZeroOut[] = $j;
                }
            }
        }
        
        foreach($rowsToZeroOut as $r) {
            for($i=0; $i<count($matrix[$r]); $i++) {
               $matrix[$r][$i] = 0; 
            }
        }
                
        foreach($colsToZeroOut as $c) {
            for($i=0; $i<count($matrix); $i++) {
               $matrix[$i][$c] = 0; 
            }
        }
    }
}

Results:

Runtime: 52 ms, faster than 13.33% of PHP online submissions for Set Matrix Zeroes. Memory Usage: 19.8 MB, less than 80.00% of PHP online submissions for Set Matrix Zeroes.