/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var backspaceCompare = function(s, t) {
    s = processString(s);
    t = processString(t);
    //console.log({s, t})
    return s===t;
};

let processString = function(s) {
    const a = [];
    let skip = 0;
    for (let i = s.length-1; i >= 0; i--) {
        if (s[i] === '#') {
            skip++;
        } else if (skip > 0) {
            skip--;
        } else {
            a.push(s[i]);
        }
        //console.log({a, skip, i})
    }
    let re = '';
    //console.log({ a: a.length})
    while (a.length > 0) {
        re += a.pop();
        //console.log({i, re, a: a.length})
    }
    return re;
}

/**
* Definition for Employee.
* class Employee {
*     public $id = null;
*     public $importance = null;
*     public $subordinates = array();
*     function __construct($id, $importance, $subordinates) {
*         $this->id = $id;
*         $this->importance = $importance;
*         $this->subordinates = $subordinates;
*     }
* }
*/

class Solution {
/**
 * @param Employee[] $employees
 * @param Integer $id
 * @return Integer
 */

function getImportance($employees, $id) {
  if (empty($employees)) return 0;
  $emap = [];
  foreach ($employees as $e) {
    $emap[$e->id] = $e;
  }

  return $this->recurse($emap, $id);
 }

function recurse($emap, $id) {
  $e = $emap[$id];
  $ans = $e->importance;
  foreach ($e->subordinates as $sub) {
    $ans += $this->recurse($emap, $sub);
  }
  return $ans;
 }
}

/**
 * @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('');
};

    private $v = ['M' = > 1000, 'D' = > 500, 'C' = > 100, 'L' = > 50, 'X' = > 10, 'V' = > 5, 'I' = > 1];
  /**
    * @param String $s
    * @return Integer
    */
    function romanToInt($s) {
        $n = 0;
        $last = '';
        for ($i=0;$i < strlen  ($s  );   $i++)   {
             $n   +=   $this-  >v[$s[$i]];
            if (($s[$i] == 'V' || $s[$i] == 'X')  &&  $last == 'I') {
                $n = $n - 2;
            } elseif (($s[$i] == 'L' || $s[$i] == 'C')  &&  $last == 'X') {
                $n -= 20;
            } elseif (($s[$i] == 'D' || $s[$i] == 'M')  &&  $last == 'C') {
                $n -= 200;
            }
            $last = $s[$i];
        }

        return $n;
    }
}

  <pre style="color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4"><code class="language-js" data-lang="js">function minimumBribes (q ) {
    let bribes   =  0 ;

    for  (let i  = 0 ;i   <q .length  - 2 ;i++ ) {
        if  (q [i ]  -  (i  + 1 )   >  2 ) {
           console .log ( 'Too chaotic' );
            return ;
        }
         // compare index to element, works great except when a smaller element is pushed way back
           if  (q [i ]  -  (i  + 1 )   >  0 ) {
         bribes   += q [i ]  -  (i  + 1 );
        }
    }
   console .log (bribes );
}

  /**
    * @param String[][] $grid
    * @return Integer
    */
    function numIslands($grid) {
        $count = 0;

        for ($i=0; $i < count  ($grid  );   $i++)   {
           for   ($j  =  0;   $j   <count  ($grid  [$i  ]);   $j++)   {
               if   ($grid  [$i  ][$j  ]   ==   &#34;1  &#34;)   {
                     $count++;
                     // zero out rest of 1s
                     $this-  >zeroOut($grid, $i, $j);
                }
            }
        }

        return $count;
    }

    function zeroOut( & $grid, $i, $j) {
        if ($i < 0   ||   $i  >=count($grid) || $j < 0   ||   $j  >=count($grid[$i]) || $grid[$i][$j] == &#34;0&#34;)
            return;

        $grid[$i][$j] = &#34;0&#34;;

        $this- >zeroOut($grid, $i-1, $j);
        $this- >zeroOut($grid, $i+1, $j);
        $this- >zeroOut($grid, $i, $j-1);
        $this- >zeroOut($grid, $i, $j+1);
    }
}

/**
  * @param {number[]} height
  * @return {number}
  */
var trap   =  function (height ) {
    let maxLeft   =  0 ,maxRight   =  0 ;

    let left   =  0 ;
    let right   = height .length   - 1 ;
    let total   =  0 ;

    while  (left    <right ) {
        if  (height [left ]   <height [right ]) {
            if  (height [left ]  >maxLeft ) {
               maxLeft   = height [left ];
            } else  {
              total   += maxLeft  -height [left ]
            }
           left++ ;
        } else  {
            if  (height [right ]  >maxRight ) {
               maxRight   = height [right ];
            } else  {
              total   += maxRight  -height [right ]
            }
           right  -- ;
        }
    }
    return total ;
};

  /**
    * @param Integer[] $arr
    * @return NULL
    */
    function duplicateZeros( & $arr) {
        $len = count($arr);
        for ($i=0; $i   < $len; $i++) {
            if (0 === $arr[$i]) {
                array_splice($arr, $i++, 0, 0);
            }
        }
        array_splice($arr, $len);
    }
}

/**
  * @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 ;
};