1337

1337.js

May Challenge: https://gist.github.com/wovalle/a86a76bc20d8c886342040f54875f291

// https://leetcode.com/problems/find-duplicate-file-in-system
/**
 * @param {string[]} paths
 * @return {string[][]}
 */
var findDuplicate = function(paths) {
  const tree = {}
  
  paths.forEach(p => {
    const [folder, ...files] = p.split(' ')
    
    for(let file of files) {
      const [name, content] = file.split('(')
      const key = content.slice(0,-1)
      
      tree[key] = (tree[key] || []).concat(`${folder}/${name}`) 
    }
  })
  
  console.log(tree)
  return Object.entries(tree).filter(e => e[1].length > 1).map(e => e[1])
};

// https://leetcode.com/problems/minimum-path-sum/submissions/
var minPathSum = function (grid) {
  const columns = Array.from({ length: grid[0].length }, () => Infinity);
  const answers = Array.from({ length: grid.length }, () => [...columns]);
  
  answers[0][0] = grid[0][0];

  for (let y = 0; y < answers.length; y++) {
    for (let x = 0; x < answers[0].length; x++) {
      if (y < answers.length - 1)
        answers[y + 1][x] = Math.min(answers[y + 1][x], answers[y][x] + grid[y + 1][x]);
      if (x < answers[0].length - 1)
        answers[y][x + 1] = Math.min(answers[y][x + 1], answers[y][x] + grid[y][x + 1]);
    }
  }

  return answers[answers.length -1][answers[0].length -1];
};

// https://leetcode.com/problems/game-of-life/submissions/
/**
 * @param {number[][]} board
 * @return {void} Do not return anything, modify board in-place instead.
 */
const countNeighbors = (arr, y, x) => {
  let count = 0;

  for (let yp = Math.max(y - 1, 0); yp <= Math.min(y + 1, arr.length - 1); yp++) {
    for (let xp = Math.max(x - 1, 0); xp <= Math.min(x + 1, arr[0].length - 1); xp++) {
      if (yp === y && xp === x) continue;
      if (arr[yp][xp] === 1 || arr[yp][xp] === -1) {
        count++;
      }
    }
  }

  return count;
};

var gameOfLife = function (arr) {
  // -1 was 1 now 0
  // 0 was 0 now 0
  // 1 was 1 now 1
  // 2 was 0 now 1

  for (let y = 0; y < arr.length; y++) {
    for (let x = 0; x < arr[0].length; x++) {
      const neighbors = countNeighbors(arr, y, x);

      if (neighbors < 2) {
        arr[y][x] = arr[y][x] === 1 ? -1 : 0;
      } else if (neighbors <= 3) {
        // if alive and n === 2 or 3, stay alive
        if (arr[y][x] === 0 && neighbors === 3) {
          arr[y][x] = 2;
        }
      } else if (neighbors > 3) {
        arr[y][x] = arr[y][x] === 1 ? -1 : 0;
      }
    }
  }

  for (let y = 0; y < arr.length; y++) {
    for (let x = 0; x < arr[0].length; x++) {
      arr[y][x] = arr[y][x] > 0 ? 1 : 0;
    }
  }

  return arr;
};

// https://leetcode.com/problems/design-phone-directory
class PhoneDirectory {
  constructor(maxNumbers) {
    this.currentNumber = 0;
    this.maxNumber = maxNumbers;
    this.released = [];
  }

  get = function () {
    if (this.currentNumber < this.maxNumber) {
      this.currentNumber++;
      return this.currentNumber - 1;
    } else if (this.released.length > 0) {
      return this.released.pop();
    }

    return -1;
  };

  check = function (number) {
    return (
      this.released.indexOf(number) > -1 ||
      (number >= this.currentNumber && number < this.maxNumber)
    );
  };

  release = function (number) {
    if (number < this.currentNumber && this.released.indexOf(number) === -1) {
      this.released.push(number);
      this.released.sort((a, b) => b - a);
    }
  };
}

// https://leetcode.com/problems/letter-combinations-of-a-phone-number/solution/
const letterCombinations = (str) => {
  if (str.trim() === '') return []
  
  const map = {
    1: '',
    2: 'abc',
    3: 'def',
    4: 'ghi',
    5: 'jkl',
    6: 'mno',
    7: 'pqrs',
    8: 'tuv',
    9: 'wxyz',
    0: " ",
    "#": "^",
    "*": "+"
  }
  
  const phoneNumbersArray = str.split('')
  const phoneNumbersMap = phoneNumbersArray.map(n => map[n])
  let result = ['']
  
  for (const position of phoneNumbersMap) {
    let localResult = []
    
    for (const resultCombination of result) {
      for (const currentLetter of position) {
          localResult.push(resultCombination + currentLetter)
      }
    }
    
      
    result = localResult
  }
  
  return result
}

// https://leetcode.com/problems/lru-cache
class LRUCache {
    constructor(capacity) {
        this.capacity = capacity
        this.keys = new Set()
        this.store = new Map()
    }

    get(key) {
        if (this.keys.has(key)) {
            this.keys.delete(key)
            this.keys.add(key)
            return this.store.get(key)
        }
        else {
            return -1
        }

    }

    put(key, value) {
        if (this.get(key) !== -1) {
            this.store.set(key, value)
            return;
        }
        
        if (this.keys.size === this.capacity) {
            const nextKey = this.keys.values().next().value
            this.keys.delete(nextKey)
            this.store.delete(nextKey)
        }
        
        this.keys.add(key)
        this.store.set(key, value)
    }
}