우크라이나어 하는 개발자

leetcode.com/problems/number-of-good-pairs/

javascript

/**
 * @param {number[]} nums
 * @return {number} 
 */
const numIdenticalPairs = (nums) => {
  const pairs = {}
  for (let i = 0; i < nums.length; i++) {
    pairs[nums[i]] ? pairs[nums[i]] += 1 : pairs[nums[i]] = 1
  }
  let numGoodPairs = 0
  const pairNums = Object.values(pairs)
  for (let i = 0; i < pairNums.length; i++) {
    numGoodPairs += (pairNums[i] * (pairNums[i] - 1)) / 2
  }
  return numGoodPairs
}

typescript

interface Pairs {
  [key: string]: number
}

const numIdenticalPairsTS = (nums: number[]): number => {
  const pairs: Pairs = {}
  for (let i = 0; i < nums.length; i++) {
    pairs[nums[i]] ? pairs[nums[i]] += 1 : pairs[nums[i]] = 1
  }
  let numGoodPairs: number = 0
  const pairNums = Object.keys(pairs)
  for (let i = 0; i < pairNums.length; i++) {
    numGoodPairs += (pairs[pairNums[i]] * (pairs[pairNums[i]] - 1)) / 2
  }
  return numGoodPairs
}

golang

func numIdenticalPairs(nums []int) int {
	goodPairs := 0
	pairs := make([]int, 101)
	for _, num := range nums {
		pairs[num]++
	}
	for _, pairsNum := range pairs {
		if pairsNum > 1 {
			goodPairs += pairsNum * (pairsNum - 1) / 2
		}
	}
	return goodPairs
}

leetcode.com/problems/defanging-an-ip-address/

javascript

/**
 * @param {string} address
 * @return {string}
 */
const defangIPaddr = (address) => {
  return address.replace(/\./g, '[.]')
  // address.split('.').join('[.]')
};

typescript

const defangIPaddrTS = (address: string): string => {
  return address.replace(/\./g, '[.]')
  // address.split('.').join('[.]')
};

golang

func defangIPaddr(address string) string {
	return strings.Replace(address, ".", "[.]", -1)
}

leetcode.com/problems/jewels-and-stones/

javascript

/**
 * @param {string} J
 * @param {string} S
 * @return {number}
 */
const numJewelsInStones = function (J, S) {
  const stons = [...S]
  let numJewelsInStone = 0
  for (let i = 0; i < stons.length; i++) {
    if (J.includes(stons[i])) {
      numJewelsInStone++
    }
  }
  return numJewelsInStone
};

typescript

const numJewelsInStonesTS = function (J: string, S: string): number {
  const stons: string[] = [...S]
  let numJewelsInStone: number = 0
  for (let i = 0; i < stons.length; i++) {
    if (J.includes(stons[i])) {
      numJewelsInStone++
    }
  }
  return numJewelsInStone
};

golang

func numJewelsInStones(J string, S string) int {
	jewels := make(map[rune]bool)
	for _, jewel := range J {
		jewels[jewel] = true
	}
	numJewelsInStone := 0
	for _, stone := range S {
		if jewels[stone] {
			numJewelsInStone++
		}
	}
	return numJewelsInStone
}

/*
func numJewelsInStones(J string, S string) int {
	num := 0
	for _, jewel := range J {
		for _, stone := range S {
			if jewel == stone {
				num++
			}
		}
	}
	return num
}
*/

leetcode.com/problems/shuffle-the-array/

nums 배열이 [1, 2, 3, 1, 2, 3] 이고

n 이 3이면

결과값은 [1, 1, 2, 2, 3, 3] 이 되어야 합니다.

그래서 

먼저 중간 인덱스 값은 mid를 구합니다.

그리고 배열이 나누어져 있다고 생각하고 

[1, 2, 3] [1, 2, 3]

새로운 빈 배열에 하나씩 넣습니다.

javascript

/**
 * @param {number[]} nums
 * @param {number} n
 * @return {number[]}
 */
const shuffle = (nums, n) => {
  if (nums.length <= 2) return nums
  const shuffled = []
  const mid = Math.floor(nums.length / 2)
  for (let i = 0; i < mid; i++) {
    shuffled.push(nums[i])
    shuffled.push(nums[i + n])
  }
  return shuffled
};

typescript

function shuffleTS(nums: number[], n: number): number[] {
  if (nums.length <= 2) return nums
  const shuffled: number[] = []
  const mid: number = Math.floor(nums.length / 2)
  for (let i = 0; i < mid; i++) {
    shuffled.push(nums[i])
    shuffled.push(nums[i + n])
  }
  return shuffled
};

golang

func shuffle(nums []int, n int) []int {
	if len(nums) <= 2 {
		return nums
	}
	result := make([]int, len(nums))
	mid := int(len(nums) / 2)

	i := 0
	j := 0
	for i < mid {
		result[j] = nums[i]
		result[j+1] = nums[i+n]
		i++
		j += 2
	}
	return result
}

https://leetcode.com/problems/kids-with-the-greatest-number-of-candies/

candies 양의 정수 배열은 각 index 별로 아이들이 가지고 있는 캔디 수를 의미합니다.

아이에게 extraCandies를 주면 아이들 중에 가장 많은 캔디를 가질 수 있는지 없는지를 판별하여

boolean 배열을 반환합니다.

javascript

/**
 * @param {number[]} candies
 * @param {number} extraCandies
 * @return {boolean[]}
 */
const kidsWithCandies = (candies, extraCandies) => {
  const greatestNum = Math.max(...candies)
  const result = candies.map(kid => kid + extraCandies >= greatestNum)
  return result
}

typescript

const kidsWithCandiesTS = (candies: number[], extraCandies: number): boolean[] => {
  const greatestNum: number = Math.max(...candies)
  const result: boolean[] = candies.map(kid => kid + extraCandies >= greatestNum)
  return result
}

golang

func kidsWithCandies(candies []int, extraCandies int) []bool {
	var result = make([]bool, len(candies))
	var greatestNum int = candies[0]
	for i := 0; i < len(candies); i++ {
		if greatestNum < candies[i] {
			greatestNum = candies[i]
		}
	}
	for index, kid := range candies {
		if kid+extraCandies >= greatestNum {
			result[index] = true
		}
	}
	return result
}

Merge Sort

병합정렬

시간 복잡도: O(nlogn)

공간 복잡도: O(n)

merge 함수는 두 배열을 합쳐 한 배열로 정렬합니다.

mergeSort 함수는 재귀적으로 배열을 나누고 merge 함수로 합칩니다.

/**
 * @param {int[]} leftArr 
 * @param {int[]} rightArr 
 */
const merge = (leftArr, rightArr) => {
  let result = []
  let leftIndex = 0
  let rightIndex = 0
  while (leftIndex < leftArr.length && rightIndex < rightArr.length) {
    if (leftArr[leftIndex] < rightArr[rightIndex]) {
      result.push(leftArr[leftIndex])
      leftIndex++
    } else {
      result.push(rightArr[rightIndex])
      rightIndex++
    }
  }
  while (leftIndex < leftArr.length) {
    result.push(leftArr[leftIndex])
    leftIndex++
  }
  while (rightIndex < rightArr.length) {
    result.push(rightArr[rightIndex])
    rightIndex++
  }
  return result
}

/**
 * 
 * @param {int[]} arr 
 */
const mergeSort = (arr) => {
  if (arr.length <= 1) return arr
  let mid = Math.floor(arr.length / 2)
  let left = mergeSort(arr.slice(0, mid))
  let right = mergeSort(arr.slice(mid))

  let result = merge(left, right)
  return result
}

버블 정렬

시간 복잡도: O(n2)

공간 복잡도: O(1)

const swap = (arr, index, nextIndex) => {
  [arr[index], arr[nextIndex]] = [arr[nextIndex], arr[index]]
}

const bubbleSort = (arr) => {
  for (let i = arr.length; i >= 0; i--) {
    let noSwap = true
    for (let j = 0; j < i; j++) {
      if (arr[j] > arr[j + 1]) {
        swap(arr, j, j + 1)
        noSwap = false
      }
    }
    if (noSwap) break
  }
  return arr
}

선택 정렬

시간 복잡도: O(n2)

공간 복잡도: O(1)

const swap = (arr, index, nextIndex) => {
  [arr[index], arr[nextIndex]] = [arr[nextIndex], arr[index]]
}

const selectionSort = (arr) => {
  for (let i = 0; i < arr.length - 1; i++) {
    let lowest = i
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[lowest] > arr[j]) {
        lowest = j
      }
    }
    if (i !== lowest) {
      swap(arr, i, lowest)
    }
  }
  return arr
}

삽입 정렬

시간 복잡도: O(n2)

공간 복잡도: O(1)

const insertionSort = (arr) => {
  for (let i = 1; i < arr.length; i++) {
    console.log(arr)
    let currentValue = arr[i]
    for (let j = i - 1; j >= 0 && arr[j] > currentValue; j--) {
      arr[j + 1] = arr[j]
      arr[j] = currentValue
    }
  }
  return arr
}

expect().toBe() 함수 형태를 어떻게 만들기 고민하였습니다.

이 형태는 then, catch를 사용하는 Promise 형태가 아니기 때문입니다.

function expect() {
  const trial = Function('"use strict";return (' + arguments[0] + ')')();
  return {
    toBe: (answer) => {
      const isEuqual = trial === answer
      if (isEuqual) {
        return console.log(`결과가 동일합니다. expect: ${trial} result: ${answer}`)
      }
      return console.log(`결과가 다릅니다. expect: ${trial} result: ${answer}`)
    }
  }
}

function add(a, b) {
  return a + b
}
expect("2+5").toBe(7)
expect("2*5").toBe(10)
expect("2/5").toBe(0.3)
expect(add(2, 3)).toBe(5)
expect(2 + 5).toBe(7)

/**
 * 결과가 동일합니다. expect: 7 result: 7
 * 결과가 동일합니다. expect: 10 result: 10
 * 결과가 다릅니다. expect: 0.4 result: 0.3
 * 결과가 동일합니다. expect: 5 result: 5
 * 결과가 동일합니다. expect: 7 result: 7
 */

그래서 toBe 함수가 있는 객체를 반환하고자 하였습니다.

jest Expect 문서에서 toBe()는 '==='를 의미하여

isEqual boolean 변수에 trial과 answer 비교 결과를 담았습니다.

trial은 expect 문에서 받은 arguments 을 실행한 결과를 가집니다.

처음에는 eval() 함수를 사용하려 하였으나 인자로 받은 코드를 caller 권한으로 수행하는 보안상 위험한 함수이고

최신 JS 엔진에서 여러 코드 구조를 최적화하는 것과 달리 eval()은 JS 인터프리터를 사용해야 하기 때문에 다른 대안들보다 느리기 때문에 Function 으로 대체하였습니다

<참조>

MDN eval() 절대 사용하지 말 것!

https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/eval

Jest Expect API reference

https://jestjs.io/docs/en/expect