function isPalindrome(str){
    for(let i=0;i<str.length/2;i++){
        if(str[i]!=str[str.length-i-1])
            return false
    }
    return true
}

version: '3'
services:
  app:
    container_name: starho
    build: .
    ports:
      - '3000:3000'
    depends_on: #특정 컨테이너에 대한 의존 관계를 나타냄, 
      - db #이 항목에 명시된 컨테이너가 먼저 생성되고 실행됩니다. 

  db: # 서비스 명
    image: mysql:8.0.15 # 사용할 이미지
    container_name: db # 컨테이너 이름 설정
    ports:
      - "3306:3306" # 접근 포트 설정 (컨테이너 외부:컨테이너 내부)
    environment: # -e 옵션
      MYSQL_ROOT_PASSWORD: "boardjs"  # MYSQL 패스워드 설정 옵션
      MYSQL_DATABASE: "board_api"
      MYSQL_USER: 'node'
      MYSQL_PASSWORD: 'boardjs'
    command: # 명령어 실행
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci    
      - --default-authentication-plugin=mysql_native_password

1로 구성된 submatrix란 위 그림에서 빨간색으로 표시해놓은 1로 구성된 행렬을 의미한다.

submatrix의 합을 구하는 방법은 아래 코드와 같다

var countSquares = function(matrix) {
    let row = matrix.length;
    let column = matrix[0].length;

    for(let i=1;i<row;i++) {//(*)
        for(let j=1;j<column;j++) {
            if(matrix[i][j] && matrix[i-1][j] && matrix[i][j-1] && matrix[i-1][j - 1]) {
                matrix[i][j] = Math.min(matrix[i-1][j - 1], matrix[i][j-1], matrix[i-1][j]) + 1;
            }
        }
    }
    let sum = 0;

    for(let i=0;i<row;i++) {
        sum += matrix[i].reduce((a,b) => a + b, 0);
    }

    return sum;
};

(*)표시된 반복문이 핵심이니 이부분만 설명한다. [1,1]부터 시작해서 [1,1]'(현재위치), [0,1]'(위), [1,0]'(왼쪽), [0,0]'(왼쪽위)이 모두 0이 아니면 [0,1], [1,0], [0,0]의 최소값+1을 반환한다.

참고 https://leetcode.com/problems/count-square-submatrices-with-all-ones/discuss/643329/Javascript-solution

i에서 j까지의 합 계산시에는 (1부터 i까지의 합) - (1부터 j까지의 합)

중학교 수학인거 같은데... 무턱대고 반복문을 돌렸다 생각하며 풀자!

    let rangesum=(i,j)=>{
        return ((j*((j+1))/2)-(i*(i+1)/2))
    }

d2라이브러리를 사용하는 것이 좋지만, 코딩테스트에서 d2라이브러리를 사용 못하는 상황에서 유용할것이다.

사용예

let arr=[1,2,3,4,5]


console.log(bysect.left(arr,3))//2

bysect코드

var bysect=bisector(ascending)

function bisector(f) {
    let delta = f;
    let compare = f;

    if (f.length === 1) {
      delta = (d, x) => f(d) - x;
      compare = ascendingComparator(f);
    }

    function left(a, x, lo, hi) {
      if (lo == null) lo = 0;
      if (hi == null) hi = a.length;
      while (lo < hi) {
        const mid = (lo + hi) >>> 1;
        if (compare(a[mid], x) < 0) lo = mid + 1;
        else hi = mid;
      }
      return lo;
    }

    function right(a, x, lo, hi) {
      if (lo == null) lo = 0;
      if (hi == null) hi = a.length;
      while (lo < hi) {
        const mid = (lo + hi) >>> 1;
        if (compare(a[mid], x) > 0) hi = mid;
        else lo = mid + 1;
      }
      return lo;
    }

    function center(a, x, lo, hi) {
      if (lo == null) lo = 0;
      if (hi == null) hi = a.length;
      const i = left(a, x, lo, hi - 1);
      return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
    }

    return {left, center, right};
}



function ascending(a, b) {
    return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
  }

console.log(board)
function rotateRigth(arr){
    let n=arr[0].length
    let m=arr.length
    let result=Array.from({length:n},()=>Array.from({length:m},()=>0))
    result.forEach((_,i)=>{
            _.forEach((v,j)=>{
                result[i][j]=arr[m-j-1][i]
            })
    })
    return result
}
console.log(rotateRigth(board))    

board

[
  [ 'C', 'C', 'B', 'D', 'E' ],
  [ 'A', 'A', 'A', 'D', 'E' ],
  [ 'A', 'A', 'A', 'B', 'F' ],
  [ 'C', 'C', 'B', 'B', 'F' ]
]

result

[
  [ 'C', 'A', 'A', 'C' ],
  [ 'C', 'A', 'A', 'C' ],
  [ 'B', 'A', 'A', 'B' ],
  [ 'B', 'B', 'D', 'D' ],
  [ 'F', 'F', 'E', 'E' ]
]

*반시계방향으로 돌리기 *

console.log(board)
function rotateLeft(arr){
    let n=arr[0].length
    let m=arr.length
    let result=Array.from({length:n},()=>Array.from({length:m},()=>0))
    result.forEach((_,i)=>{
            _.forEach((v,j)=>{
                result[i][j]=arr[j][m-i]
            })
    })
    return result
}
console.log(rotateLeft(board))      

board

[
  [ 'C', 'C', 'B', 'D', 'E' ],
  [ 'A', 'A', 'A', 'D', 'E' ],
  [ 'A', 'A', 'A', 'B', 'F' ],
  [ 'C', 'C', 'B', 'B', 'F' ]
]

result

[
  [ 'E', 'E', 'F', 'F' ],
  [ 'D', 'D', 'B', 'B' ],
  [ 'B', 'A', 'A', 'B' ],
  [ 'C', 'A', 'A', 'C' ],
  [ 'C', 'A', 'A', 'C' ]
]

//_.compact(array)
_.compact([0, 1, false, 2, '', 3]);
=> [1, 2, 3]

without value값을 제외한 나머지값을 리턴

//_.without(array, *values)
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
=> [2, 3, 4]

union 전달 된 모든 배열의 각 개별 요소의 집합을 포함하는 배열을 제공한다.

//_.union(*arrays)
_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2, 3, 101, 10]

intersection 교집합

//_.intersection(*arrays)
_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]

difference 차집합

//_.difference(array, *others)
_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]

zip 서로 상응하는 값끼리 묶어준다

//_.zip(*arrays)
_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]

unzip zip의 반대개념

//_.unzip(array)
_.unzip([["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]);
=> [['moe', 'larry', 'curly'], [30, 40, 50], [true, false, fals

where list의 각 value에서 리스트에서 key-value값이 맞는 모든 properties를 반환

//_.where(list, properties)
_.where(listOfPlays, {author: "Shakespeare", year: 1611});
=> [{title: "Cymbeline", author: "Shakespeare", year: 1611},
    {title: "The Tempest", author: "Shakespeare", year: 1611}]

every list내 모든게 참이여야 true를 반환 되도록 ES5 filter를 쓰도록하자.

//_.every(list, [predicate], [context])
_.every([2, 4, 5], function(num) { return num % 2 == 0; });
=> false

some 하나라도 참이면 true!

//_.some(list, [predicate], [context])
_.some([null, 0, 'yes', false]);
=> true

sortBy sorting 용

//_.sortBy(list, iteratee, [context])
_.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });
=> [5, 4, 6, 3, 1, 2]

var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
_.sortBy(stooges, 'name');
=> [{name: 'curly', age: 60}, {name: 'larry', age: 50}, {name: 'moe', age: 40}];

groupBy 리턴값이 같은것끼리 array로 묶음

//_.groupBy(list, iteratee, [context])
_.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); });
=> {1: [1.3], 2: [2.1, 2.4]}

_.groupBy(['one', 'two', 'three'], 'length');
=> {3: ["one", "two"], 5: ["three"]}

indexBy 배열들을 index값을 기준으로 mapping

//_.indexBy(list, iteratee, [context])
var stooges = [{name: 'moe', age: 40}, {name: 'larry', age: 50}, {name: 'curly', age: 60}];
_.indexBy(stooges, 'age');
=> {
  "40": {name: 'moe', age: 40},
  "50": {name: 'larry', age: 50},
  "60": {name: 'curly', age: 60}
}

https://harrythegreat.tistory.com/entry/%EC%96%B8%EB%8D%94%EC%8A%A4%EC%BD%94%EC%96%B4-%EC%A0%95%EB%A6%AC

writable – true이면 값을 수정할 수 있습니다. 그렇지 않다면 읽기만 가능합니다. enumerable – true이면 반복문을 사용해 나열할 수 있습니다. 그렇지 않다면 반복문을 사용해 나열할 수 없습니다. configurable – true이면 프로퍼티 삭제나 플래그 수정이 가능합니다. 그렇지 않다면 프로퍼티 삭제와 플래그 수정이 불가능합니다.

let descriptor = Object.getOwnPropertyDescriptor(obj, propertyName);

obj 정보를 얻고자 하는 객체 propertyName 정보를 얻고자 하는 객체 내 프로퍼티

let user = {
  name: "John"
};

let descriptor = Object.getOwnPropertyDescriptor(user, 'name');

alert( JSON.stringify(descriptor, null, 2 ) );
/* property descriptor:
{
  "value": "John",
  "writable": true,
  "enumerable": true,
  "configurable": true
}
*/

Object.defineProperty 플래그를 변경

Object.defineProperty(obj, propertyName, descriptor)

obj, propertyName 설명자를 적용하고 싶은 객체와 객체 프로퍼티 descriptor 적용하고자 하는 프로퍼티 설명자

let user = {};

Object.defineProperty(user, "name", {
  value: "John"
});

let descriptor = Object.getOwnPropertyDescriptor(user, 'name');

alert( JSON.stringify(descriptor, null, 2 ) );
/*
{
  "value": "John",
  "writable": false,
  "enumerable": false,
  "configurable": false
}
 */

Object.defineProperties 프로퍼티 여러 개를 한 번에 정의

 Object.defineProperties(obj, {
  prop1: descriptor1,
  prop2: descriptor2
  // ...
});


Object.defineProperties(user, {
  name: { value: "John", writable: false },
  surname: { value: "Smith", writable: false },
  // ...
});

Object.getOwnPropertyDescriptors 프로퍼티 설명자를 전부 한꺼번에 가져옴

getter와 setter

let obj = {
  get propName() {
    // getter, obj.propName을 실행할 때 실행되는 코드
  },

  set propName(value) {
    // setter, obj.propName = value를 실행할 때 실행되는 코드
  }
};

예시

let user = {
  name: "John",
  surname: "Smith",

  get fullName() {
    return `${this.name} ${this.surname}`;
  },

  set fullName(value) {
    [this.name, this.surname] = value.split(" ");
  }
};

// 주어진 값을 사용해 set fullName이 실행됩니다.
user.fullName = "Alice Cooper";

alert(user.name); // Alice
alert(user.surname); // Cooper

접근자 프로퍼티 설명자 get – 인수가 없는 함수로, 프로퍼티를 읽을 때 동작함 set – 인수가 하나인 함수로, 프로퍼티에 값을 쓸 때 호출됨 enumerable – 데이터 프로퍼티와 동일함 configurable – 데이터 프로퍼티와 동일함

접근자 프로퍼티 예시

let user = {
  name: "John",
  surname: "Smith"
};

Object.defineProperty(user, 'fullName', {
  get() {
    return `${this.name} ${this.surname}`;
  },

  set(value) {
    [this.name, this.surname] = value.split(" ");
  }
});

alert(user.fullName); // John Smith

for(let key in user) alert(key); // name, surname

한 프로퍼티에 get과 value를 동시에 설정하면 에러가 발생

Symbol.iterator Symbol.iterator객체가 존재한다면 for..of적용 가능

let range = {
  from: 1,
  to: 5
};

// 1. for..of 최초 호출 시, Symbol.iterator가 호출됩니다.
range[Symbol.iterator] = function() {

  // Symbol.iterator는 이터레이터 객체를 반환합니다.
  // 2. 이후 for..of는 반환된 이터레이터 객체만을 대상으로 동작하는데, 이때 다음 값도 정해집니다.
  return {
    current: this.from,
    last: this.to,

    // 3. for..of 반복문에 의해 반복마다 next()가 호출됩니다.
    next() {
      // 4. next()는 값을 객체 {done:.., value :...}형태로 반환해야 합니다.
      if (this.current <= this.last) {
        return { done: false, value: this.current++ };
      } else {
        return { done: true };
      }
    }
  };
};

// 이제 의도한 대로 동작합니다!
for (let num of range) {
  alert(num); // 1, then 2, 3, 4, 5

range를 for..of호출 시 발생하는 일

1. for..of가 시작되자마자 for..of는 Symbol.iterator를 호출합니다(Symbol.iterator가 없으면 에러가 발생합니다). Symbol.iterator는 반드시 이터레이터(iterator, 메서드 next가 있는 객체) 를 반환해야 합니다.
2. 이후 for..of는 반환된 객체(이터레이터)만을 대상으로 동작합니다.
3. for..of에 다음 값이 필요하면, for..of는 이터레이터의 next()메서드를 호출합니다.
4. next()의 반환 값은 {done: Boolean, value: any}와 같은 형태이어야 합니다. done=true는 반복이 종료되었음을 의미합니다. done=false일땐 value에 다음 값이 저장됩니다.

위 코드보다 조금 더 간단한 코드

let range = {
  from: 1,
  to: 5,

  [Symbol.iterator]() {
    this.current = this.from;
    return this;
  },

  next() {
    if (this.current <= this.to) {
      return { done: false, value: this.current++ };
    } else {
      return { done: true };
    }
  }
};

for (let num of range) {
  alert(num); // 1, then 2, 3, 4, 5
}

이터러블과 유사 배열 이터러블(iterable) 은 위에서 설명한 바와 같이 메서드 Symbol.iterator가 구현된 객체 유사 배열(array-like) 은 인덱스와 length 프로퍼티가 있어서 배열처럼 보이는 객체

Array.from Array.from(obj[, mapFn, thisArg]) 이터러블이나 유사 배열을 받아 ‘진짜’ Array로 만듬 mapFn을 두 번째 인수로 넘겨주면 새로운 배열에 obj의 요소를 추가하기 전에 각 요소를 대상으로 mapFn을 적용 thisArg는 각 요소의 this를 지정가능

let arrayLike = {
  0: "Hello",
  1: "World",
  length: 2
};

let arr = Array.from(arrayLike); // (*)
alert(arr.pop()); // World (메서드가 제대로 동작합니다.)

 function slow(x) {
  // CPU 집약적인 작업이 여기에 올 수 있습니다.
  alert(`slow(${x})을/를 호출함`);
  return x;
}

function cachingDecorator(func) {
  let cache = new Map();

  return function(x) {
    if (cache.has(x)) {    // cache에 해당 키가 있으면
      return cache.get(x); // 대응하는 값을 cache에서 읽어옵니다.
    }

    let result = func(x);  // 그렇지 않은 경우엔 func를 호출하고,

    cache.set(x, result);  // 그 결과를 캐싱(저장)합니다.
    return result;
  };
}

slow = cachingDecorator(slow);

alert( slow(1) ); // slow(1)이 저장되었습니다.
alert( "다시 호출: " + slow(1) ); // 동일한 결과

alert( slow(2) ); // 
slow(2)가 저장되었습니다.
alert( "다시 호출: " + slow(2) ); // 윗줄과 동일한 결과

this를 명시적으로 고정해 함수를 호출할 수 있게 해주는 특별한 내장 함수 메서드 func.call(context, …args)

*func.call(context, arg1, arg2, ...) *메서드를 호출하면 메서드의 첫 번째 인수가 this, 이어지는 인수가 func의 인수가 된 후, func이 호출

데코레이터에 여러인수 전달하는 방법 두 값을 하나로 합치기. 맵의 키로 문자열 "min,max"를 사용합니다. 여러 값을 하나로 합치는 코드는 해싱 함수(hashing function) 에 구현해 유연성을 높입니다.

let worker = {
  slow(min, max) {
    alert(`slow(${min},${max})을/를 호출함`);
    return min + max;
  }
};

function cachingDecorator(func, hash) {
  let cache = new Map();
  return function() {
    let key = hash(arguments); // (*)
    if (cache.has(key)) {
      return cache.get(key);
    }

    let result = func.call(this, ...arguments); // (**)

    cache.set(key, result);
    return result;
  };
}

function hash(args) {
  return args[0] + ',' + args[1];
}

worker.slow = cachingDecorator(worker.slow, hash);

alert( worker.slow(3, 5) ); // 제대로 동작합니다.
alert( "다시 호출: " + worker.slow(3, 5) ); // 동일한 결과 출력(캐시된 결과

func.apply func.apply(context, args) apply는 func의 this를 context로 고정해주고, 유사 배열 객체인 args를 인수로 사용할 수 있게 해줌 call과 apply의 문법적 차이는 call이 복수 인수를 따로따로 받는 대신 apply는 인수를 유사 배열 객체로 받음

func.call(context, ...args); // 전개 문법을 사용해 인수가 담긴 배열을 전달하는 것과
func.apply(context, args);   // call을 사용하는 것은 동일합니다.

위 줄은 같은역할

차이는 아래와 같다 전개 문법 ...은 이터러블 args을 분해 해 call에 전달할 수 있도록 해줍니다. apply는 오직 유사 배열 형태의 args만 받습니다.

위 그래프를 간선리스트, 연결리스트, 인접행렬로 나타내면 아래 그림과 같다

간선리스트를 인접행렬, 연결리스트로 바꾸는 자바스크립트는 아래와 같다

간선리스트에서 연결리스트

function lineToList(node_num,line){
    let list=Array.from({length:(+node_num+1)},()=>[])
    line.forEach(v=>{
        list[v[0]].push(v[1]);
        list[v[1]].push(v[0]);
    })
    return list;
}

간선리스트에서 인접행렬

function lineToGraph(node_num,line){
    let Graph=Array.from({length:(+node_num+1)},()=>Array.from({length:(+node_num+1)},()=>0))
    line.forEach(v=>{
        Graph[v[0]][v[1]]=1
        Graph[v[1]][v[0]]=1
    })
    return Graph;
}

function sayHi() {
  alert("Hi");
}

alert(sayHi.name); // sayHi
------------------------------------------------------
let sayHi = function() {
  alert("Hi");
};

alert(sayHi.name); // sayHi (익명 함수이지만 이름이 있네요!)

‘length’ 프로퍼티 내장 프로퍼티 length는 함수 매개변수의 개수를 반환

function f1(a) {}
function f2(a, b) {}
function many(a, b, ...more) {}

alert(f1.length); // 1
alert(f2.length); // 2
alert(many.length); // 2

클로저를 함수 프로퍼티로 사용가능

function makeCounter() {

  function counter() {
    return counter.count++;
  };

  counter.count = 0;

  return counter;
}

let counter = makeCounter();

counter.count = 10;
alert( counter() ); // 10

'new Function' 문법 문자열을 함수로 바꿀 수 잇음 let func = new Function ([arg1, arg2, ...argN], functionBody);

let sum = new Function('a', 'b', 'return a + b');

alert( sum(1, 2) ); // 3

function sum(a, b) {
  return a + b;
}

alert( sum(1, 2, 3, 4, 5) );//오류 발생하지않음

...args 배열

function sumAll(...args) { // args는 배열의 이름입니다.
  let sum = 0;

  for (let arg of args) sum += arg;

  return sum;
}

alert( sumAll(1) ); // 1
alert( sumAll(1, 2) ); // 3
alert( sumAll(1, 2, 3) ); // 6

-------------------------------------------------------

function showName(firstName, lastName, ...titles) {
  alert( firstName + ' ' + lastName ); // Julius Caesar

  // 나머지 인수들은 배열 titles의 요소가 됩니다.
  // titles = ["Consul", "Imperator"]
  alert( titles[0] ); // Consul
  alert( titles[1] ); // Imperator
  alert( titles.length ); // 2
}

showName("Julius", "Caesar", "Consul", "Imperator");

‘arguments’ 변수 배열이 아닌 유사배열객체 인덱스를 사용해 모든 인수 접근가능

function showName() {
  alert( arguments.length );
  alert( arguments[0] );
  alert( arguments[1] );

  // arguments는 이터러블 객체이기 때문에
  // for(let arg of arguments) alert(arg); 를 사용해 인수를 나열할 수 있습니다.
}

// 2, Julius, Caesar가 출력됨
showName("Julius", "Caesar");

// 1, Bora, undefined가 출력됨(두 번째 인수는 없음)
showName("Bora");

화살표 함수에는 존재하지 않음 화살표 함수에서 사용시 일반함수의 arguments객체를 가져옴

function f() {
  let showArg = () => alert(arguments[0]);
  showArg();
}

f(1); // 1

spread 문법 배열을 통째로 매개변수에 넘겨주는 방법 함수를 호출할 때 ... arr를 사용하면, 이터러블 객체 arr이 인수 목록으로 확장됨

let arr = [3, 5, 1];

alert( Math.max(...arr) ); // 5 (전개 문법이 배열을 인수 목록으로 바꿔주었습니다.)

배열 복사시에도 사용가능

let arr = [1, 2, 3];
let arrCopy = [...arr]; // spread the array into a list of parameters
                        // then put the result into a new array

// do the arrays have the same contents?
alert(JSON.stringify(arr) === JSON.stringify(arrCopy)); // true

// are the arrays equal?
alert(arr === arrCopy); // false (not same reference)

// modifying our initial array does not modify the copy:
arr.push(4);
alert(arr); // 1, 2, 3, 4
alert(arrCopy); // 1, 2, 3

JSON.stringify(value[, replacer, space])

value 인코딩 하려는 값 replacer JSON으로 인코딩 하길 원하는 프로퍼티가 담긴 배열. 또는 매핑 함수 function(key, value) space 서식 변경 목적으로 사용할 공백 문자 수

replacer예제

let room = {
  number: 23
};

let meetup = {
  title: "Conference",
  participants: [{name: "John"}, {name: "Alice"}],
  place: room // meetup은 room을 참조합니다.
};

room.occupiedBy = meetup; // room references meetup

alert( JSON.stringify(meetup, ['title', 'participants']) );
// {"title":"Conference","participants":[{},{}]}

space예제

alert(JSON.stringify(user, null, 2));
/* 공백 문자 두 개를 사용하여 들여쓰기함:
{
  "name": "John",
  "age": 25,
  "roles": {
    "isAdmin": false,
    "isEditor": true
  }
}
*/

JSON.parse(str, [reviver]); str JSON 형식의 문자열 reviver 모든 (key, value) 쌍을 대상으로 호출되는 function(key,value) 형태의 함수로 값을 변경시킬 수 있습니다.

let userData = '{ "name": "John", "age": 35, "isAdmin": false, "friends": [0,1,2,3] }';

let user = JSON.parse(userData);

alert( user.friends[1] ); // 1

reviver 예제

let str = '{"title":"Conference","date":"2017-11-30T12:00:00.000Z"}';

let meetup = JSON.parse(str, function(key, value) {
  if (key == 'date') return new Date(value);//(*)
  return value;
});

alert( meetup.date.getDate() ); // 이제 제대로 동작하네요!

(*)가 reviver 예제

구조 분해 할당

// 이름과 성을 요소로 가진 배열
let arr = ["Bora", "Lee"]

// 구조 분해 할당을 이용해
// firstName엔 arr[0]을
// surname엔 arr[1]을 할당하였습니다.
let [firstName, surname] = arr;

alert(firstName); // Bora
alert(surname);  // Lee

쉼표를 사용하여 요소 무시

// 두 번째 요소는 필요하지 않음
let [firstName, , title] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];

alert( title ); // Consul

할당 연산자 우측엔 모든 이터러블 사용가능

let [a, b, c] = "abc"; // ["a", "b", "c"]
let [one, two, three] = new Set([1, 2, 3]);

할당 연산자 좌측엔 뭐든지

let user = {};
[user.name, user.surname] = "Bora Lee".split(' ');

alert(user.name); // Bora

.entries()

let user = {
  name: "John",
  age: 30
};

// 객체의 키와 값 순회하기
for (let [key, value] of Object.entries(user)) {
  alert(`${key}:${value}`); // name:John, age:30이 차례대로 출력
}

'…'로 나머지 요소

let [name1, name2, ...rest] = ["Julius", "Caesar", "Consul", "of the Roman Republic"];

alert(name1); // Julius
alert(name2); // Caesar

// `rest`는 배열입니다.
alert(rest[0]); // Consul
alert(rest[1]); // of the Roman Republic
alert(rest.length); // 2

기본값

let [firstName, surname] = [];

alert(firstName); // undefined
alert(surname); // undefined

// 기본값
let [name = "Guest", surname = "Anonymous"] = ["Julius"];

alert(name);    // Julius (배열에서 받아온 값)
alert(surname); // Anonymous (기본값)

객체에도 사용 가능

let options = {
  title: "Menu",
  width: 100,
  height: 200
};

// { 객체 프로퍼티: 목표 변수 }
let {width: w, height: h, title} = options;

// width -> w
// height -> h
// title -> title

alert(title);  // Menu
alert(w);      // 100
alert(h);      // 200

원하는 변수만

let options = {
  title: "Menu",
  width: 100,
  height: 200
};

// title만 변수로 뽑아내기
let { title } = options;

alert(title); // Menu

중첩 구조 분해

let options = {
  size: {
    width: 100,
    height: 200
  },
  items: ["Cake", "Donut"],
  extra: true
};

// 코드를 여러 줄에 걸쳐 작성해 의도하는 바를 명확히 드러냄
let {
  size: { // size는 여기,
    width,
    height
  },
  items: [item1, item2], // items는 여기에 할당함
  title = "Menu" // 분해하려는 객체에 title 프로퍼티가 없으므로 기본값을 사용함
} = options;

alert(title);  // Menu
alert(width);  // 100
alert(height); // 200
alert(item1);  // Cake
alert(item2);  // Donut

똑똑한 함수 매개변수

// 함수에 전달할 객체
let options = {
  title: "My menu",
  items: ["Item1", "Item2"]
};

// 똑똑한 함수는 전달받은 객체를 분해해 변수에 즉시 할당함
function showMenu({title = "Untitled", width = 200, height = 100, items = []}) {
  // title, items – 객체 options에서 가져옴
  // width, height – 기본값
  alert( `${title} ${width} ${height}` ); // My Menu 200 100
  alert( items ); // Item1, Item2
}

showMenu(options);

맵의 메서드 map.keys() – 각 요소의 키를 모은 반복 가능한(iterable, 이터러블) 객체를 반환합니다. map.values() – 각 요소의 값을 모은 이터러블 객체를 반환합니다. map.entries() – 요소의 [키, 값]을 한 쌍으로 하는 이터러블 객체를 반환합니다. 이 이터러블 객체는 for..of반복문의 기초로 쓰입니다.

Object.entries 객체를 맵으로 변경

let obj = {
  name: "John",
  age: 30
};

let map = new Map(Object.entries(obj));

alert( map.get('name') ); // John

Object.fromEntries 맵을 객체로 변경

let prices = Object.fromEntries([
  ['banana', 1],
  ['orange', 2],
  ['meat', 4]
]);

// now prices = { banana: 1, orange: 2, meat: 4 }

alert(prices.orange); // 2

셋 new Set(iterable) – 셋을 만듭니다. 이터러블 객체를 전달받으면(대개 배열을 전달받음) 그 안의 값을 복사해 셋에 넣어줍니다. set.add(value) – 값을 추가하고 셋 자신을 반환합니다. set.delete(value) – 값을 제거합니다. 호출 시점에 셋 내에 값이 있어서 제거에 성공하면 true, 아니면 false를 반환합니다. set.has(value) – 셋 내에 값이 존재하면 true, 아니면 false를 반환합니다. set.clear() – 셋을 비웁니다. set.size – 셋에 몇 개의 값이 있는지 세줍니다.

let set = new Set();

let john = { name: "John" };
let pete = { name: "Pete" };
let mary = { name: "Mary" };

// 어떤 고객(john, mary)은 여러 번 방문할 수 있습니다.
set.add(john);
set.add(pete);
set.add(mary);
set.add(john);
set.add(mary);

// 셋에는 유일무이한 값만 저장됩니다.
alert( set.size ); // 3

for (let user of set) {
  alert(user.name); // // John, Pete, Mary 순으로 출력됩니다.
}

++ for..of나 forEach를 사용하여 반복작업 가능

위크맵 키가 반드시 객체 사용된 객체를 참조하는 것이 아무것도 없다면 해당 객체는 메모리와 위크맵에서 자동으로 삭제

let john = { name: "John" };

let weakMap = new WeakMap();
weakMap.set(john, "...");

john = null; // 참조를 덮어씀

// john을 나타내는 객체는 이제 메모리에서 지워집니다!

weakMap.get(key) weakMap.set(key, value) weakMap.delete(key) weakMap.has(key) 그냥 맵과는 다르게 위 4개의 메소드만 지원

위크셋 위크셋은 셋과 유사한데, 객체만 저장할 수 있다는 점이 다릅니다. 원시값은 저장할 수 없습니다. 셋 안의 객체는 도달 가능할 때만 메모리에서 유지됩니다. 셋과 마찬가지로 위크셋이 지원하는 메서드는 단출합니다. add, has, delete를 사용할 수 있고, size, keys()나 반복 작업 관련 메서드는 사용할 수 없습니다.

let visitedSet = new WeakSet();

let john = { name: "John" };
let pete = { name: "Pete" };
let mary = { name: "Mary" };

visitedSet.add(john); // John이 사이트를 방문합니다.
visitedSet.add(pete); // 이어서 Pete가 사이트를 방문합니다.
visitedSet.add(john); // 이어서 John이 다시 사이트를 방문합니다.

// visitedSet엔 두 명의 사용자가 저장될 겁니다.

// John의 방문 여부를 확인해보겠습니다.
alert(visitedSet.has(john)); // true

// Mary의 방문 여부를 확인해보겠습니다.
alert(visitedSet.has(mary)); // false

john = null;

// visitedSet에서 john을 나타내는 객체가 자동으로 삭제됩니다.

Symbol.iterator Symbol.iterator객체가 존재한다면 for..of적용 가능

let range = {
  from: 1,
  to: 5
};

// 1. for..of 최초 호출 시, Symbol.iterator가 호출됩니다.
range[Symbol.iterator] = function() {

  // Symbol.iterator는 이터레이터 객체를 반환합니다.
  // 2. 이후 for..of는 반환된 이터레이터 객체만을 대상으로 동작하는데, 이때 다음 값도 정해집니다.
  return {
    current: this.from,
    last: this.to,

    // 3. for..of 반복문에 의해 반복마다 next()가 호출됩니다.
    next() {
      // 4. next()는 값을 객체 {done:.., value :...}형태로 반환해야 합니다.
      if (this.current <= this.last) {
        return { done: false, value: this.current++ };
      } else {
        return { done: true };
      }
    }
  };
};

// 이제 의도한 대로 동작합니다!
for (let num of range) {
  alert(num); // 1, then 2, 3, 4, 5

range객체를 for..of호출 시 발생하는 일

1. for..of가 시작되자마자 for..of는 Symbol.iterator를 호출합니다(Symbol.iterator가 없으면 에러가 발생합니다). Symbol.iterator는 반드시 이터레이터(iterator, 메서드 next가 있는 객체) 를 반환해야 합니다.
2. 이후 for..of는 반환된 객체(이터레이터)만을 대상으로 동작합니다.
3. for..of에 다음 값이 필요하면, for..of는 이터레이터의 next()메서드를 호출합니다.
4. next()의 반환 값은 {done: Boolean, value: any}와 같은 형태이어야 합니다. done=true는 반복이 종료되었음을 의미합니다. done=false일땐 value에 다음 값이 저장됩니다.

위 코드보다 조금 더 간단한 코드

let range = {
  from: 1,
  to: 5,

  [Symbol.iterator]() {
    this.current = this.from;
    return this;
  },

  next() {
    if (this.current <= this.to) {
      return { done: false, value: this.current++ };
    } else {
      return { done: true };
    }
  }
};

for (let num of range) {
  alert(num); // 1, then 2, 3, 4, 5
}

이터러블과 유사 배열 이터러블(iterable) 은 위에서 설명한 바와 같이 메서드 Symbol.iterator가 구현된 객체 유사 배열(array-like) 은 인덱스와 length 프로퍼티가 있어서 배열처럼 보이는 객체

Array.from Array.from(obj[, mapFn, thisArg]) 이터러블이나 유사 배열을 받아 ‘진짜’ Array로 만듬 mapFn을 두 번째 인수로 넘겨주면 새로운 배열에 obj의 요소를 추가하기 전에 각 요소를 대상으로 mapFn을 적용 thisArg는 각 요소의 this를 지정가능

let arrayLike = {
  0: "Hello",
  1: "World",
  length: 2
};

let arr = Array.from(arrayLike); // (*)
alert(arr.pop()); // World (메서드가 제대로 동작합니다.)

예를 들어 스파이가 가진 옷이 아래와 같고 오늘 스파이가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야 합니다.

종류 이름 얼굴 동그란 안경, 검정 선글라스 상의 파란색 티셔츠 하의 청바지 겉옷 긴 코트 스파이가 가진 의상들이 담긴 2차원 배열 clothes가 주어질 때 서로 다른 옷의 조합의 수를 return 하도록 solution 함수를 작성해주세요.

제한사항 clothes의 각 행은 [의상의 이름, 의상의 종류]로 이루어져 있습니다. 스파이가 가진 의상의 수는 1개 이상 30개 이하입니다. 같은 이름을 가진 의상은 존재하지 않습니다. clothes의 모든 원소는 문자열로 이루어져 있습니다. 모든 문자열의 길이는 1 이상 20 이하인 자연수이고 알파벳 소문자 또는 '_' 로만 이루어져 있습니다. 스파이는 하루에 최소 한 개의 의상은 입습니다.

후기 및 풀이 푸는건 얼마 안걸렸지만 다른사람 풀이를 봤는데 코드도 짧고 시간차이가 많이 나서 쪼금 아쉬웠다. 내코드 분석보다는 잘짠 코드를 보고 정리하려 한다

잘짠 코드
function solution(clothes) {
    return Object.values(clothes.reduce((obj, t)=> {
        obj[t[1]] = obj[t[1]] ? obj[t[1]] + 1 : 1;
        return obj;
    } , {})).reduce((a,b)=> a*(b+1), 1)-1;    
}

reduce로 값을 반환하는 것이 아니라 객체를 반환한다. obj[t]값이 존재하면 1을 더해서 반환하고 존재하지 않는다면 프로퍼티를 만들어 초기화해준다(이게 메인 아이디어) 이후 만든 객체에서 값만 뽑아서 1더한후(하나만 입은 경우) 곱하고 1빼기(아무것도 입지 않은 경우)

//내풀이
function solution(clothes) {
    var answer = 0;
    let cat={};
    let arr=[];
    clothes.forEach(function(a){
        if((a[1] in cat)==0){
            cat[a[1]]=[a[0]];
            return;
        }
        cat[a[1]]=cat[a[1]].concat([a[0]]);
    })

    for(let a in cat){
        arr.push(cat[a].length)
    }
    console.log(arr)
    answer=arr.reduce((a,b)=>(a*=(b+1)),1)-1
    return answer;
}

1. 배열에서 하나 선택후 인덱스를 1감소시킨후 다시호출
2. 인덱스가 1일경우 각 요소를 배열로 만들어 리턴
3. 리턴된 값을 1에서 선택한 값과 합침

중복조합

function perm(array, length) {
    return array.flatMap((v, i) => length > 1
        ? perm(array, length - 1).map(w => [v, ...w])
        : [[v]]
    );
}
perm(['a', 'b', 'c', 'd', 'e'], 3).forEach(a => console.log(...a));

조합

1. 배열에서 하나 선택후 선택한 요소를 제외한 배열과 인덱스를 1감소시킨후 다시호출
2. 인덱스가 1일경우 각 요소를 배열로 만들어 리턴
3. 리턴된 값을 1에서 선택한 값과 합침

조합 코드

function comb(array, length) {
    return array.flatMap((v, i) => length > 1
        ? comb(array.slice(i + 1), length - 1).map(w => [v, ...w])
        : [[v]]
    );
}
comb(['a', 'b', 'c', 'd', 'e'], 3).forEach(a => console.log(...a));

순열

const perm= function (arr, len) {
    const results = [];
    if (len === 1) return arr.map((value) => [value]); // 1개씩 택할 때, 바로 모든 배열의 원소 return

    arr.forEach((fixed, index, origin) => {
      const rest = [...origin.slice(0, index), ...origin.slice(index+1)] // 해당하는 fixed를 제외한 나머지 배열 
      const permutations = perm(rest, len - 1); // 나머지에 대해 순열을 구한다.
      const attached = permutations.map((permutation) => [fixed, ...permutation]); // 돌아온 순열에 대해 떼 놓은(fixed) 값 붙이기
      results.push(...attached); // 배열 spread syntax 로 모두다 push
    });

    return results; // 결과 담긴 results return
};

https://www.python2.net/questions-777952.htm https://jun-choi-4928.medium.com/javascript%EB%A1%9C-%EC%88%9C%EC%97%B4%EA%B3%BC-%EC%A1%B0%ED%95%A9-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98-%EA%B5%AC%ED%98%84%ED%95%98%EA%B8%B0-21df4b536349