59 posts tagged with "easy"

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isSubsequence = function (s, t) {
  let k = 0;

  for (let i = 0; i < t.length; i++) {
    if (s[k] === t[i]) {
      k++;
    }
  }

  return k === s.length;
};

/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLastWord = function (s) {
  let start;
  let end;

  for (let i = s.length - 1; i >= 0; i--) {
    if (s[i] !== ' ') {
      start = i;
      break;
    }
  }

  for (let j = start; j >= 0; j--) {
    if (s[j] === ' ') {
      end = j;
      break;
    }
  }

  if (end === undefined) {
    return start + 1;
  }
  return start - end;
};

/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function (digits) {
  for (let i = digits.length - 1; i >= 0; i--) {
    digits[i] += 1;

    if (digits[i] === 10) {
      digits[i] = 0;
      if (i === 0) {
        digits.unshift(1);
        return digits;
      }
    } else {
      return digits;
    }
  }
};

/**
 * @param {string} a
 * @param {string} b
 * @return {string}
 */
var addBinary = function (a, b) {
  return (BigInt(`0b${a}`) + BigInt(`0b${b}`)).toString(2);
};

/**
 * @param {number} x
 * @return {number}
 */
var mySqrt = function (x) {
  let result = 0;

  if (x === 0) {
    return 0;
  }

  if (x <= 2) {
    return 1;
  }

  for (let i = 0; i < x; i++) {
    if (i * i > x) {
      result = i - 1;
      break;
    }
  }

  return result;
};

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function (n) {
  if (n === 1) {
    return 1;
  }

  const cache = {
    0: 1,
    1: 1,
  };

  for (let i = 2; i <= n; i++) {
    cache[i] = cache[i - 1] + cache[i - 2];
  }

  return cache[n];
};

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
var deleteDuplicates = function (head) {
  if (!head) {
    return null;
  }

  let curr = head;
  let next = head.next;

  while (next) {
    if (curr.val === next.val) {
      curr.next = next.next;
    } else {
      curr = curr.next;
    }
    next = next.next;
  }

  return head;
};

/**
 * @param {number[]} nums1
 * @param {number} m
 * @param {number[]} nums2
 * @param {number} n
 * @return {void} Do not return anything, modify nums1 in-place instead.
 */
var merge = function (nums1, m, nums2, n) {
  while (n > 0) {
    // 뒤에서 부터 도는게 핵심

    if (nums1[m - 1] > nums2[n - 1]) {
      // nums1이 nums2보다 클 경우, nums1의 자리를 뒤로 배치
      nums1[m + n - 1] = nums1[m - 1];
      m--;
    } else {
      // nums1이 nums2보다 작을 경우, nums1의 자리에 num2 배치
      nums1[m + n - 1] = nums2[n - 1];
      n--;
    }
  }
};

const nums1 = [4, 5, 6, 0, 0, 0];
const m = 3;
const nums2 = [1, 2, 3];
const n = 3;

merge(nums1, m, num2, n);

// 풀이
// [4, 5, 6, 0, 0, 6]
// [4, 5, 6, 0, 5, 6]
// [4, 5, 6, 4, 5, 6]
// [4, 5, 3, 4, 5, 6]
// [4, 2, 3, 4, 5, 6]
// [1, 2, 3, 4, 5, 6]

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var inorderTraversal = function (root) {
  let stack = [];
  let result = [];

  while (root !== null || stack.length !== 0) {
    while (root !== null) {
      stack.push(root);
      root = root.left;
    }
    root = stack.pop();
    result.push(root.val);
    root = root.right;
  }
  return result;
};