알고리즘에 사용되는 Javascript

아현·2021년 8월 13일

Algorithm Note

목록 보기

15/18

Array.from

Array.from() 메서드는 유사 배열 객체(array-like object)나 반복 가능한 객체(iterable object)를 얕게 복사해 새로운Array 객체를 만듭니다.


Array.from(arrayLike[, mapFn[, thisArg]])

//배열로 변환하고자 하는유사 배열 객체나 반복 가능한 객체.
//배열의 모든 요소에 대해 호출할 맵핑 함수.
//mapFn 실행 시에 this로 사용할 값.


console.log(Array.from('foo'));
// expected output: Array ["f", "o", "o"]

console.log(Array.from([1, 2, 3], x => x + x));
// expected output: Array [2, 4, 6]


const m = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(m);
// [[1, 2], [2, 4], [4, 8]]

const mapper = new Map([['1', 'a'], ['2', 'b']]);
Array.from(mapper.values());
// ['a', 'b'];

Array.from(mapper.keys());
// ['1', '2'];



// Using an arrow function as the map function to
// manipulate the elements
Array.from([1, 2, 3], x => x + x);
// [2, 4, 6]

// Generate a sequence of numbers
// Since the array is initialized with `undefined` on each position,
// the value of `v` below will be `undefined`
Array.from({length: 5}, (v, i) => i);
// [0, 1, 2, 3, 4]


// Sequence generator function (commonly referred to as "range", e.g. Clojure, PHP etc)
const range = (start, stop, step) => Array.from({ length: (stop - start) / step + 1}, (_, i) => start + (i * step));

// Generate numbers range 0..4
range(0, 4, 1);
// [0, 1, 2, 3, 4]

// Generate numbers range 1..10 with step of 2
range(1, 10, 2);
// [1, 3, 5, 7, 9]

// Generate the alphabet using Array.from making use of it being ordered as a sequence
range('A'.charCodeAt(0), 'Z'.charCodeAt(0), 1).map(x => String.fromCharCode(x));
// ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]

2차원 배열

Array.from()


// arr[5][2] (빈 배열 생성)
const arr1 = Array.from(Array(5), () => new Array(2)

// arr[5][2] (null로 초기화하여 생성)
const arr2 = Array.from(Array(5), () => Array(2).fill(null))

함수


function create2DArray(rows, columns) {
    var arr = new Array(rows);
    for (var i = 0; i < rows; i++) {
        arr[i] = new Array(columns);
    }
    return arr;
}

// arr[5][2]
var arr = create2DArray(5, 2);

반복문


// arr[5][2]
var arr = new Array(5);

for (var i = 0; i < arr.length; i++) {
    arr[i] = new Array(2);
}

for in, for of, forEach

참고

for in : 객체의 프로퍼티 키 열거 전용
for of : 이터러블 순회 전용
forEach(): 배열 순회 전용 메서드

for in

for in 문: 객체의 프로퍼티 키 열거 전용


for(const key in 객체){...반복 수행 코드...}

(주의)해당 객체가 상속받는 프로토타입 체인상의 모든 프로퍼티 키를 열거한다.(단, [[Enumerable]] 값이 false인 프로퍼티는 제외)


const obj = {
    name: 'curryyou',
    job: 'engineer'
}

for (const key in obj){
    console.log(`${key} : ${obj[key]}`);
}
// name : curryyou
// job : engineer

for of

for of 문: 이터러블 순회 전용

for(const item of 이터러블){...반복 수행 코드...}


const arr = [10, 20, 30];
for (const item of arr){
    console.log(item); // 10, 20, 30 출력
}

(참고) 이터러블에는 String, Array, Map, Set, DOM컬렉션(HTMLColletion, NodeList) 등이 있다.

forEach

forEach(): 배열 순회 전용 메서드


배열.forEach( function(value, index, array){...반복 수행 코드...} )

콜백함수의 매개변수로 value에 요소값, index에 인덱스, array에 원본 배열이 들어온다.


[10, 20, 30].forEach((value, index, array)=>{
    console.log(`${index} : ${value}`); // 0 : 10, 1 : 20, 2: 30 출력
})

배열 정렬

ASCII 문자 순서로 정렬되어 숫자의 크기대로 나오지 않는다.
아래와 같은 방법을 사용하면 원하는 결과를 얻을 수 있습니다.




[1,10,2,20,3,4,5].sort(function(a, b) { return a - b; }); // [1,2,3,4,5,10,20]

내림차순으로 정렬하고 싶은 경우는 아래와 같이 코드를 작성합니다.


[1,10,2,20,3,4,5].sort(function(a, b) { return b - a; }); // [1,2,3,4,5,10,20]

객체 정렬


var items = [
  { name: 'Edward', value: 21 },
  { name: 'Sharpe', value: 37 },
  { name: 'And', value: 45 },
  { name: 'The', value: -12 },
  { name: 'Magnetic', value: 13 },
  { name: 'Zeros', value: 37 }
];

// value 기준으로 정렬
items.sort(function (a, b) {
  if (a.value > b.value) {
    return 1;
  }
  if (a.value < b.value) {
    return -1;
  }
  // a must be equal to b
  return 0;
});

// name 기준으로 정렬 - 오름차순
items.sort(function(a, b) {
  var nameA = a.name.toUpperCase(); // ignore upper and lowercase
  var nameB = b.name.toUpperCase(); // ignore upper and lowercase
  if (nameA < nameB) {
    return -1;
  }
  if (nameA > nameB) {
    return 1;
  }

  // 이름이 같을 경우
  return 0;
});

배열이나 문자열에서 중복을 제거할 때


// 배열
const arr = [1,3,2,4,3,1,5,6,2,1];
const newArr = [...new Set(arr)];
console.log(newArr); // [1,3,2,4,5,6] 중복이 제거된 배열을 얻을 수 있다.

// 문자열
const str = "abcdacbe";
const newStr = [...new Set(str)].join('');
console.log(newStr); // "abcde" 중복이 제거된 문자열을 얻을 수 있다.

배열이나 문자열에서 유니크한 원소 뽑아내기

filter 메소드를 활용해 유니크한 값을 뽑아낼 수 있다.


const arr = [1,1,4,1,1]
arr.filter( el => arr.indexOf(el) === arr.lastIndexOf(el) ) // [4]

//문자열에서도 마찬가지로 split 후 filter를 사용하면 같은 결과를 얻을 수 있다.

const str = '11411'
str.split('').filter( el => str.indexOf(el) === str.lastIndexOf(el) ) // ['4']

배열로 결과값을 리턴하기 때문에 문자열을 원하면 toString()을 뒤에 붙여주면 되고, 넘버타입을 원하면 Number()로 감싸주면 된다.

배열이나 문자열에서 i 번째 인덱스 내용을 삭제하고 싶을 때

원본을 보존하면서 잘라내는 방법



const arr = [1,2,3,4,5];
const newArr1 = [...arr.slice(0,2), ...arr.slice(3)]; // 2번 인덱스 삭제

console.log(newArr1); // [1,2,4,5]
console.log(arr); // [1,2,3,4,5]

원본을 훼손하며 잘라내는 방법



const arr = [1,2,3,4,5];
arr.splice(2,1); // 2번 인덱스부터 1개를 삭제하겠다는 의미
console.log(arr); // [1,2,4,5]

배열에 규칙적인 연속된 값 할당하기


Array(5).fill(1) // [1,1,1,1,1]
Array(5).fill(1).map( (el,i) => el+i ) // [1,2,3,4,5]
 
형변환 ( 문자 > 숫자, 숫자 > 문자 )
// 문자를 숫자로 변환
const str = '1234'
const strToNum = +str
console.log(strToNum) // 1234

// 숫자를 문자로 변환
const num = 1234
const numToStr = ''+num
console.log(numToStr) // '1234'

배열에서 조합 구하기

출처


function getAllCombinations(arr, m) {
  const combinations = [];
  const picked = [];
  const used = []; //중복되는 조합이 거듭 combinations에 추가되는 것을 막기 위해 사용
  for (item of arr) used.push(0);

  function find(picked) {
    if (picked.length === m) { //종료 조건
      const rst = [];
      for (let i of picked) {
        rst.push(arr[i]);
      }
      combinations.push(rst);
      return;
    } else {
      //picked에 이미 인덱스가 있다면 그 인덱스보다 1 큰 수를, 없다면 0
      let start = picked.length ? picked[picked.length-1] + 1 : 0;
      for (let i = start; i < arr.length; i++) {
        //used[i-1]이 이미 뽑혀서 1인 경우, i를 뽑는다.
        if (i === 0 || arr[i] !== arr[i-1] || used[i-1]) {
          picked.push(i);
          used[i] = 1;
          find(picked);
          picked.pop();
          used[i] = 0;
        }
      }
    }
  }
  find(picked);
  return combinations;
}

간단한 버전



function combination(arr, selectNum) {
  const result = [];
  if (selectNum === 1) return arr.map((v) => [v]);
  arr.forEach((v, idx, arr) => {
    const fixed = v;
    const restArr = arr.slice(idx + 1);
    const combinationArr = combination(restArr, selectNum - 1);
    const combineFix = combinationArr.map((v) => [fixed, ...v]);
    result.push(...combineFix);
  });
  return result;
}

더 간단한 버전



let answer = [];

const dfs = (nums, num, arr = []) => {
  //3개를 선택한다는가정에 3개가 선택 됐다면 출력
  if (num === 3) answer.push([...arr]);
  else {
    for (let i = 0; i < nums.length; i++) {
      arr.push(nums[i]);
      dfs(nums.slice(i + 1), num + 1, arr);
      arr.pop();
    }
  }
};
dfs([1, 2, 3, 4], 0);
console.log(answer); //[ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 4 ], [ 2, 3, 4 ] ]

배열에서 순열 구하기

참조


function permutation(arr, selectNum) {
  let result = [];
  if (selectNum === 1) return arr.map((v) => [v]);

  arr.forEach((v, idx, arr) => {
    const fixer = v; //1
    const restArr = arr.filter((_, index) => index !== idx); // [2,3,4]
    const permuationArr = permutation(restArr, selectNum - 1); // [[2],[3],[4]]
    const combineFixer = permuationArr.map((v) => [fixer, ...v]); //[[1,2],[1,3],[1,4]]
    result.push(...combineFixer);
  });
  return result;
}

배열에서 중복 순열 구하기



function permutation(arr, selectNum) {
  const result = [];
  if (selectNum === 1) return arr.map((v) => [v]);

  arr.forEach((v, idx, arr) => {
    const fixed = v;
    const restArr = arr;
    const permutationArr = permutation(restArr, selectNum - 1);
    const combineFix = permutationArr.map((v) => [fixed, ...v]);
    result.push(...combineFix);
  });
  return result;
}