5 posts tagged with "sorting"

/**
 * @param {number[]} nums
 * @return {number}
 */
var majorityElement = function (nums) {
  const element = {};

  for (const num of nums) {
    if (element[num]) {
      element[num]++;
    } else {
      element[num] = 1;
    }
  }

  let max = 0;
  let targetNum = '';

  for (let e in element) {
    if (element[e] > max) {
      max = element[e];
      targetNum = e;
    }
  }

  return Number(targetNum);
};

/**
 * @param {number} num
 * @return {number}
 */
var minimumSum = function (num) {
  const numToArr = num.toString().split('');

  for (let i = 1; i < numToArr.length; i++) {
    for (let j = 0; j < i; j++) {
      if (numToArr[i] < numToArr[j]) {
        const smallNum = numToArr[i];
        numToArr[i] = numToArr[j];
        numToArr[j] = smallNum;
      }
    }
  }

  const new1 = numToArr[0] + numToArr[2];
  const new2 = numToArr[1] + numToArr[3];

  return Number(new1) + Number(new2);
};

/**
 * @param {string} s
 * @param {string} t
 * @return {boolean}
 */
var isAnagram = function (s, t) {
  if (s.length !== t.length) {
    return false;
  }

  const hashMapS = {};
  const hashMapT = {};

  for (let i = 0; i < s.length; i++) {
    if (hashMapS[s[i]]) {
      hashMapS[s[i]] += 1;
    } else {
      hashMapS[s[i]] = 1;
    }

    if (hashMapT[t[i]]) {
      hashMapT[t[i]] += 1;
    } else {
      hashMapT[t[i]] = 1;
    }
  }

  const compareST = Object.entries(hashMapS).map(([key, value]) => {
    console.log(value, hashMapT[key]);
    console.log(value === hashMapT[key]);
    if (value === hashMapT[key]) {
      return true;
    }
    return false;
  });

  return compareST.every((b) => b);
};

/**
 * @param {string} s
 * @param {string} t
 * @return {character}
 */
var findTheDifference = function (s, t) {
  if (s.length === 0) {
    return t;
  }

  const orderedS = s.split('').sort();
  const orderedT = t.split('').sort();

  for (let i = 0; i < t.length; i++) {
    if (orderedS[i] !== orderedT[i]) {
      return orderedT[i];
    }
  }
};

/**
 * @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]