May. 6, 2021
Here is another LeetCode solution for Employee Importance Problem.
/**
* 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;
}
}
May. 6, 2021
Here is my solution to this problem:
/**
* @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('');
};
May. 5, 2021
Here is my solution to this problem in PHP:
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;
}
}
May. 4, 2021
Here is my solution to New Years Chaos problem from HackerRank. The first solution had a bug:
<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 );
}
May. 3, 2021
I had to watch some YouTube videos for the solution to this problem. I am not sure if this is the best solution though, one day I will revisit it.
/**
* @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 ] == "1 ") {
$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] == "0")
return;
$grid[$i][$j] = "0";
$this- >zeroOut($grid, $i-1, $j);
$this- >zeroOut($grid, $i+1, $j);
$this- >zeroOut($grid, $i, $j-1);
$this- >zeroOut($grid, $i, $j+1);
}
}
May. 2, 2021
My solution to LeetCode 42. Trapping Rain Water in JavaScript.
/**
* @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 ;
};
May. 2, 2021
LeetCode 1089: Duplicate Zeros solution in PHP.
/**
* @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);
}
}
Apr. 30, 2021
Here is my solution to Container with Most Water in JavaScript.
/**
* @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 ;
};
Apr. 29, 2021
/**
* @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 ;
}
};
Apr. 25, 2021
Here is my solution for Merge Sorted Array problem in PHP. This is not the most efficient solution.
class Solution {
/**
* @param Integer[] $nums1
* @param Integer $m
* @param Integer[] $nums2
* @param Integer $n
* @return NULL
*/
function merge(&$nums1, $m, $nums2, $n) {
if ($n == 0) {
return;
}
if ($m == 0) {
for ($i=0; $i < $n; $i++) {
$nums1[$i] = $nums2[$i];
}
}
$i = 0;
$j = 0;
while ($i < $m && $j < $n) {
if ($nums1[$i] < =$nums2[$j]) {
$i++;
} else {
$this->array_insert($nums1, $i++, $nums2[$j]);
$m++;
$j++;
}
}
while ($j < $n) {
$nums1[$i++] = $nums2[$j++];
}
}
function array_insert( & $arr, $i, $num) {
$endArr = array_slice($arr, $i);
$arr[$i] = $num;
for ($x=$i+1; $x < count ($arr); $x++) {
$arr [$x ] = array_shift ($endArr);
}
}
}
Apr. 21, 2021
Here is my solution to Remove Duplicates from Sorted Array problem in JavaScript
/**
* @param {number[]} nums
* @return {number}
*/
var removeDuplicates = function(nums) {
let i=0;
while (i<nums.length-1) {
if (nums[i] === nums[i+1]) {
nums.splice(i+1, 1);
} else {
i++;
}
}
return nums.length;
};
Apr. 20, 2021
Here is my solution to Set Matrix Zeros
problem in PHP:
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;
}
}
}
}