jykim16

//did not complete

/**
 * @param {number[][]} envelopes
 * @return {number}
 */
var maxEnvelopes = function(envelopes) {
    let max = 0;
    let sortedByHeightEnvelopes = envelopes.sort((a,b)=>{return a[0] < b[0]});
    let recurseHeight = (currentHeight, remainingEnvelopes, currentCount) => {

jykim16

class CashRegister {
  constructor(csv, salesTax, startingBalance) {
    this.balance = startingBalance;
    this.transactions_report = [];
    this.items_report = [];
    this.currentTransaction = {};
  }
  viewBalance () {
    //return balance
  }

jykim16

let messageBus = {};
class Channel{
  constructor() {
    this.topicSubscriptionCache = {};
  }
  publish(topic, payload) {
    if (payload) {
      //find array of callbacks for topic in cache
      if(this.topicSubscriptionCache[topic]) {

jykim16

**/Constraints

The challenge in this problem is in meeting its (arbitrary) constraints:

Do not convert into strings or manipulate strings at all.
Do not create any other data structures.
In particular, don't instantiate a new array.
The big-O of the solution should be O(n). **/

let vowelDoubler = (letters) => {

jykim16

var productExceptSelf = function(nums) {
    let zeroCount = 0;
    let productWithoutZero = 1;
    let product = nums.reduce((accum, num)=>{
        if(num === 0) {zeroCount++}
        if(num !== 0) {productWithoutZero *= num}
        return accum * num;
    }, 1);

    return nums.map((num, i)=>{

jykim16

var kthSmallest = function(root, k) {
    let kSmallestElement = NaN;
    let findLastKNodes = (node, isRightNode, parentCountFromLeftTree) => {
        var nthElement = 1; 
        if(node.left) {
            nthElement += findLastKNodes(node.left, isRightNode);
        }
        if (node.right) {
            findLastKNodes(node.right, true, nthElement);
            nthElement += 1;

jykim16

class Tree {
  constructor(name, val) {
    this.value = val;
    this.children = [];
    this.name = name;
  }
  addChild(child) {
    this.children.push(child)
  }
}

jykim16

class CashAmount{
  constructor(amount) {
    this.value = amount;
  }

//converts amount to pennies
  totalInPennies() {
    return this.value * 100;
  }

jykim16

const findLargestLevel = function(node) {
  let currLevel = [node]
  let i = 0; 
  let index = [[0, node.value]];
  while(currLevel.length > 0) {
    nextLevel = [];
    i++;
    //function that moves currlevl children to nextlevel children
    for(let parent = 0; parent < currLevel.length; parent++) {
      //nextLevel.push(children) 

jykim16

var generate = function(numRows) {
    var triangle = [];
    var counter = 0;
    while(counter < numRows){
        var lastRow = triangle[triangle.length - 1];
        var newRow = [];
        if (!lastRow) {newRow.push(1);
        } else {
         lastRow.forEach(function(num, i){
            for(var j = i; j < i + 2; j++){