๋ฐ˜์‘ํ˜•

์ˆœ์—ด Permutation


๊ฐœ๋…

์ˆœ์—ด์€ ์„œ๋กœ ๋‹ค๋ฅธ n๊ฐœ ์š”์†Œ ์ค‘์—์„œ r๊ฐœ๋ฅผ ์„ ํƒํ•˜์—ฌ ์ˆœ์„œ๋Œ€๋กœ ๋‚˜์—ดํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์˜๋ฏธํ•œ๋‹ค. ์ˆœ์—ด์—์„  ์ˆœ์„œ๊ฐ€ ๊ฒฐ๊ณผ์— ์˜ํ–ฅ์„ ๋ฏธ์น˜๊ธฐ ๋•Œ๋ฌธ์— ์ˆœ์„œ๊ฐ€ ์ค‘์š”ํ•˜๋‹ค. ๋™์ผํ•œ ์š”์†Œ๋ฅผ ์„œ๋กœ ๋‹ค๋ฅธ ์ˆœ์„œ๋กœ ๋‚˜์—ดํ•˜๋ฉด, ๊ฐ๊ฐ์„ ๋ณ„๊ฐœ์˜ ์ˆœ์—ด๋กœ ๊ฐ„์ฃผํ•œ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด A, B, C์—์„œ A, B ๋‘ ์š”์†Œ๋ฅผ ์„ ํƒํ•˜๋Š” ๊ฒฝ์šฐ AB์™€ BA๋Š” ์„œ๋กœ ๋‹ค๋ฅธ ์ˆœ์—ด์ด๋‹ค.

 

  1. A ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž B, C
    • B ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž C (2์ž๋ฆฌ ์ˆœ์—ด์ด๋ฏ€๋กœ ๋ฌด์‹œ) → AB
    • C ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž B (2์ž๋ฆฌ ์ˆœ์—ด์ด๋ฏ€๋กœ ๋ฌด์‹œ) → AC
  2. B ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž A, C
    • A ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž C (2์ž๋ฆฌ ์ˆœ์—ด์ด๋ฏ€๋กœ ๋ฌด์‹œ) → BA
    • C ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž A (2์ž๋ฆฌ ์ˆœ์—ด์ด๋ฏ€๋กœ ๋ฌด์‹œ) → BC
  3. C ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž A, B
    • A ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž B (2์ž๋ฆฌ ์ˆœ์—ด์ด๋ฏ€๋กœ ๋ฌด์‹œ) → CA
    • B ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž A (2์ž๋ฆฌ ์ˆœ์—ด์ด๋ฏ€๋กœ ๋ฌด์‹œ) → CB

 

A, B, C 3๊ฐ€์ง€ ๋ฌธ์ž(n=3)๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” 2์ž๋ฆฌ ์ˆœ์—ด(r=2)์˜ ์ˆ˜๋Š” ์ด 6๊ฐ€์ง€๋‹ค. ์ฒซ ๋ฒˆ์งธ ์ž๋ฆฌ์— ์˜ฌ ์ˆ˜ ์žˆ๋Š” ๋ฌธ์ž๋Š” A, B, C 3๊ฐ€์ง€๋ฅผ ์„ ํƒํ•  ์ˆ˜ ์žˆ๋‹ค. ๋‘ ๋ฒˆ์งธ ์ž๋ฆฌ์—๋Š” ๋‚จ์€ ๋‘ ๋ฌธ์ž๊ฐ€ ์œ„์น˜ํ•  ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ 2๊ฐ€์ง€๋ฅผ ์„ ํƒํ•  ์ˆ˜ ์žˆ๋‹ค. ๋”ฐ๋ผ์„œ ๋ชจ๋“  ์ˆœ์—ด์˜ ์ˆ˜๋Š” $3 \times 2 = 6$์ด ๋œ๋‹ค.

 

 

์ด์ฒ˜๋Ÿผ ์ˆœ์—ด์€ ๊ฐ ๋‹จ๊ณ„์—์„œ ์„ ํƒํ•  ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ์ˆ˜๋ฅผ ๊ณฑํ•œ ๊ฒƒ๊ณผ ๊ฐ™์œผ๋ฏ€๋กœ ํŒฉํ† ๋ฆฌ์–ผ์˜ ๊ฐœ๋…์„ ๋ถ€๋ถ„์ ์œผ๋กœ ํฌํ•จํ•˜์—ฌ $n \times (n-1) \times (n-2) \times ... \times (n-r+1)$ ์‹์œผ๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค. ๋งˆ์ง€๋ง‰ ์„ ํƒ์„ $n-r+1$๋กœ ํ‘œํ˜„ํ•œ ์ด์œ ๋Š” r๋ฒˆ์งธ ์š”์†Œ๋ฅผ ์„ ํƒํ•  ์‹œ์ ์€ r-1๊ฐœ์˜ ์š”์†Œ๋ฅผ ์„ ํƒํ•œ ์ƒํƒœ์ด๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

 

์˜ˆ๋ฅผ๋“ค์–ด n=5, r=3์ผ ๋•Œ r(3)๋ฒˆ์งธ ์š”์†Œ๋ฅผ ์„ ํƒํ•  ์ฐจ๋ก€์—์„  ์ด๋ฏธ r-1(2)๊ฐœ์˜ ์š”์†Œ๋ฅผ ์„ ํƒํ•œ ์ƒํƒœ์ด๋‹ค. ๋”ฐ๋ผ์„œ ๋งˆ์ง€๋ง‰ ์„ ํƒ(r๋ฒˆ์งธ)์˜ ๋‚จ์€ ์š”์†Œ์˜ ์ˆ˜๋Š” n(5)์—์„œ r-1(2)๋ฅผ ๋บ€ 3์ด ๋œ๋‹ค. ์ด๋ฅผ ์‹์œผ๋กœ ํ‘œํ˜„ํ•˜๋ฉด $n-(r-1)$์ด ๋˜๊ณ  ๋ถ„๋ฐฐ ๋ฒ•์น™์œผ๋กœ ๋‹จ์ˆœํ™”ํ•˜๋ฉด $n-r+1$์ด ๋˜๋Š” ๊ฒƒ.

 

์ˆœ์—ด์„ ์ˆ˜ํ•™์  ๊ณต์‹์œผ๋กœ ํ‘œ๊ธฐํ•˜๋ฉด $P(n,r)=\frac{n!}{(n-r)!}$ ์ด ๋œ๋‹ค. $\frac{n!}{(n-r)!}$ ์‹์„ ๊ณ„์‚ฐํ•ด๋ณด๋ฉด $(n-r)!$์— ํ•ด๋‹นํ•˜๋Š” ํ•ญ์€ ์•ฝ๋ถ„๋œ ํ›„ ์ง€์›Œ์ ธ์„œ $n \times (n-1) \times (n-2) \times ... \times (n-r+1)$ ํ˜•ํƒœ๊ฐ€ ๋˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

 

$$P(3, 2) = \frac{3!}{(3-2)!} = \frac{3 \cdot 2 \cdot \cancel{1}}{\cancel{1}} = 3 \cdot 2 = 6$$

 

$$P(5, 3) = \frac{5!}{(5-3)!} = \frac{5 \cdot 4 \cdot 3 \cdot \cancel{2 \cdot 1}}{\cancel{2 \cdot 1}} = 5 \cdot 4 \cdot 3 = 60$$

 

๐Ÿ’ก ์•ฝ๋ถ„์€ ๋ถ„์ž/๋ถ„๋ชจ๊ฐ€ ๊ณตํ†ต๋œ ์ธ์ˆ˜๋ฅผ ๊ฐ€์งˆ ๋•Œ, ์ด ์ธ์ˆ˜๋กœ ๋ถ„์ž์™€ ๋ถ„๋ชจ๋ฅผ ๋‚˜๋ˆ ์„œ ๋ถ„์ˆ˜๋ฅผ ๋” ๊ฐ„๋‹จํ•œ ํ˜•ํƒœ๋กœ ๋งŒ๋“œ๋Š” ๊ณผ์ •. โ‘ ๋ถ„์ž/๋ถ„๋ชจ์˜ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜(GCD)๋ฅผ ์ฐพ๊ณ , โ‘ก๋ถ„์ž/๋ถ„๋ชจ๋ฅผ ์ตœ๋Œ€๊ณต์•ฝ์ˆ˜๋กœ ๋‚˜๋ˆˆ ํ›„, โ‘ข๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ƒˆ๋กœ์šด ๋ถ„์ž/๋ถ„๋ชจ์— ์‚ฌ์šฉํ•˜์—ฌ ๋ถ„์ˆ˜๋ฅผ ๊ฐ„์†Œํ™”ํ•œ๋‹ค. ๋‹คํ•ญ์‹์œผ๋กœ ๋œ ๋ถ„์ˆ˜๋Š” ๋ถ„๋ชจ์™€ ๋ถ„์ž๋ฅผ ์ธ์ˆ˜๋ถ„ํ•ด(์ฃผ์–ด์ง„ ์ •์ˆ˜๋ฅผ ๋” ์ด์ƒ ๋‚˜๋ˆŒ ์ˆ˜ ์—†๋Š” ์†Œ์ˆ˜๋“ค์˜ ๊ณฑ์œผ๋กœ ํ‘œํ˜„)ํ•˜์—ฌ ๋‹คํ•ญ์‹(1๊ฐœ ์ด์ƒ์˜ ํ•ญ, e.g. 2x + 4๋Š” ํ•ญ 2๊ฐœ)์˜ ๊ณฑ์œผ๋กœ ๋‚˜ํƒ€๋‚ธ ๋’ค ๋ถ„์ž/๋ถ„๋ชจ์— ๋ชจ๋‘ ์กด์žฌํ•˜๋Š” ๋‹คํ•ญ์‹์„ ์•ฝ๋ถ„ํ•ด์„œ ์—†์•ค๋‹ค.

 

๐Ÿ’ก ์ˆœ์—ด์€ $P(n,r)$ ํ˜น์€ $_nP_r$๋กœ ํ‘œ๊ธฐํ•  ์ˆ˜ ์žˆ๋‹ค. P๋Š” ์˜๋‹จ์–ด Permutation์˜ ์ฒซ ๊ธ€์ž๋ฅผ ๊ฐ€๋ฆฌํ‚จ๋‹ค.

 

์‹ค์ƒํ™œ ์˜ˆ์‹œ

  • ์•”ํ˜ธ ์ƒ์„ฑ : 0~9๊นŒ์ง€ ์ˆซ์ž๋กœ 4์ž๋ฆฌ ์•”ํ˜ธ๋ฅผ ์„ค์ •ํ•  ๋•Œ, ๊ฐ ์ž๋ฆฌ์— ๋“ค์–ด๊ฐ€๋Š” ์ˆซ์ž์˜ ์ˆœ์„œ์— ๋”ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ€ ๋‹ฌ๋ผ์ง„๋‹ค. ์˜ˆ๋ฅผ๋“ค์–ด [1, 2, 3, 4]์™€ [4, 3, 2, 1]์€ ์„œ๋กœ ๋‹ค๋ฅธ ์•”ํ˜ธ๋‹ค.
  • ์ˆœ์œ„ ๊ฒฐ์ • : ์Šคํฌ์ธ  ๋Œ€ํšŒ์—์„œ A, B, C ์„ ์ˆ˜๊ฐ€ ๊ฐ๊ฐ 1๋“ฑ~3๋“ฑ์„ ์ฐจ์ง€ํ•˜๋Š” ๊ฒƒ๊ณผ C, B, A๊ฐ€ 1๋“ฑ~3๋“ฑ์„ ์ฐจ์ง€ํ•˜๋Š” ๊ฒƒ์€ ์ „ํ˜€ ๋‹ค๋ฅด๋‹ค. ์ฆ‰, ๊ฒฐ์Šน์„ ์— ๋จผ์ € ๋“ค์–ด์˜จ ์ˆœ์„œ์— ๋”ฐ๋ผ ๊ฒฐ๊ณผ๋Š” ๋‹ฌ๋ผ์ง„๋‹ค.

 

๊ตฌํ˜„

์ˆœ์—ด์„ ๊ตฌํ•˜๋Š” ๊ณผ์ •์„ ํŠธ๋ฆฌ ํ˜•์‹์œผ๋กœ ํ‘œํ˜„ํ•œ ์ด๋ฏธ์ง€, ์•„๋ž˜ ์ฝ”๋“œ ๋กœ์ง๊ณผ ๋น„์Šทํ•˜๋‹ค โ˜ ์ด๋ฏธ์ง€ ์ถœ์ฒ˜ geeksforgeeks

const getPermutations = (arr, permSize = arr.length, curPerm = []) => {
  // ํ˜„์žฌ ์ˆœ์—ด ๊ธธ์ด๊ฐ€ ์š”๊ตฌํ•˜๋Š” ์ˆœ์—ด ํฌ๊ธฐ์™€ ๊ฐ™์œผ๋ฉด ํ˜„์žฌ ์ˆœ์—ด ๋ฐ˜ํ™˜ (Base Case)
  if (curPerm.length === permSize) return [curPerm];
  // ๋ฐฐ์—ด์ด ๋น„์–ด์žˆ๊ฑฐ๋‚˜ ์š”๊ตฌํ•˜๋Š” ์ˆœ์—ด ํฌ๊ธฐ๊ฐ€ 0์ด๋ฉด ๋นˆ ๋ฐฐ์—ด ๋ฐ˜ํ™˜
  if (arr.length === 0 || permSize === 0) return [];

  return arr.reduce((allPerms, item, i) => {
    const restItems = arr.slice(0, i).concat(arr.slice(i + 1));
    const nextPerm = curPerm.concat(item);
    return allPerms.concat(getPermutations(restItems, permSize, nextPerm));
  }, []);
};

getPermutations(['A', 'B', 'C'], 2); // [['A', 'B'], ['A', 'C'], ...]
  1. ์ž…๋ ฅ๋ฐ›์€ ๋ฐฐ์—ด์˜ ์š”์†Œ๋ฅผ ํ•˜๋‚˜์”ฉ ์„ ํƒํ•˜์—ฌ curPerm ์ˆœ์—ด ๋ฐฐ์—ด์— ์ถ”๊ฐ€ํ•œ๋‹ค
  2. ์„ ํƒํ•œ ์š”์†Œ๋ฅผ ์ œ์™ธํ•œ ๋‚˜๋จธ์ง€ ์š”์†Œ๋ฅผ restItems ๋ฐฐ์—ด(๋‹ค์Œ ์ˆœ์—ด ์ƒ์„ฑ ๋‹จ๊ณ„์—์„œ ์‚ฌ์šฉ)์— ์ €์žฅํ•œ๋‹ค
  3. ๋‚˜๋จธ์ง€ ์š”์†Œ์™€ ์ˆœ์—ด ๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•˜์—ฌ ์žฌ๊ท€์ ์œผ๋กœ(1~2 ๊ณผ์ • ๋ฐ˜๋ณต) ์ˆœ์—ด์„ ์ƒ์„ฑํ•œ๋‹ค
  4. ์žฌ๊ท€ ๊ณผ์ •์„ ํ†ตํ•ด ์ƒ์„ฑ๋œ ๋ชจ๋“  ์ˆœ์—ด์„ ํ•˜๋‚˜์˜ ๋ฐฐ์—ด๋กœ ๋งŒ๋“  ํ›„ ๋ฐ˜ํ™˜ํ•œ๋‹ค

 

 

์กฐํ•ฉ Combination


๊ฐœ๋…

์กฐํ•ฉ์€ ์„œ๋กœ ๋‹ค๋ฅธ n๊ฐœ ์š”์†Œ ์ค‘์—์„œ ์ˆœ์„œ์— ์ƒ๊ด€์—†์ด r๊ฐœ๋ฅผ ์„ ํƒํ•˜๋Š” ๋ฐฉ๋ฒ•์„ ์˜๋ฏธํ•œ๋‹ค. ์กฐํ•ฉ์—์„  ์„ ํƒํ•œ ์š”์†Œ๋“ค์˜ ์ˆœ์„œ๋ฅผ ๊ณ ๋ คํ•˜์ง€ ์•Š๋Š”๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด A, B, C์—์„œ A, B ๋‘ ์š”์†Œ๋ฅผ ์„ ํƒํ•˜๋Š” ๊ฒฝ์šฐ AB์™€ BA๋Š” ๋™์ผํ•œ ์กฐํ•ฉ์œผ๋กœ ๊ฐ„์ฃผํ•œ๋‹ค. ์กฐํ•ฉ์—์„  ์ค‘๋ณต์„ ํ”ผํ•˜๊ธฐ ์œ„ํ•ด ๊ฐ ๋‹จ๊ณ„์—์„œ ์„ ํƒํ•œ ์š”์†Œ ๋’ค์— ์žˆ๋Š” ์š”์†Œ๋“ค๋งŒ ์กฐํ•ฉ์˜ ๋Œ€์ƒ์œผ๋กœ ๊ณ ๋ คํ•œ๋‹ค.

 

  1. A ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž B, C
    • B ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž C (2์ž๋ฆฌ ์กฐํ•ฉ์ด๋ฏ€๋กœ ๋ฌด์‹œ) → AB
    • C ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž ็„ก → AC
  2. B ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž C
    • C ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž ็„ก → BC
  3. C ์„ ํƒ, ๋‚จ์€ ๊ธ€์ž ็„ก

 

์œ„์ฒ˜๋Ÿผ A, B, C๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” 2์ž๋ฆฌ ์กฐํ•ฉ์˜ ์ˆ˜๋Š” 3๊ฐ€์ง€๋‹ค. ์กฐํ•ฉ์€ ์ˆœ์—ด๊ณผ ๋‹ฌ๋ฆฌ ์š”์†Œ์˜ ์ˆœ์„œ๋ฅผ ๊ณ ๋ คํ•˜์ง€ ์•Š์œผ๋ฏ€๋กœ, ๋™์ผํ•œ ์š”์†Œ๋“ค์ด ์ˆœ์„œ๋งŒ ๋‹ค๋ฅธ ๊ฒฝ์šฐ๋ฅผ ํ•œ ๊ทธ๋ฃน์œผ๋กœ ๋ฌถ์–ด์„œ ๊ณ„์‚ฐํ•˜๋ฉด ์กฐํ•ฉ์˜ ์ˆ˜๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ๋‹ค.

 

์˜ˆ๋ฅผ๋“ค์–ด A, B, C๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” 2์ž๋ฆฌ(r=2) ์ˆœ์—ด์€ AB, BA, AC, CA, BC, CB ์ด 6๊ฐ€์ง€๋‹ค. ์ด ์ˆœ์—ด์—์„œ [AB, BA], [AC, CA], [BC, CB]์™€ ๊ฐ™์ด ์„œ๋กœ ์ˆœ์„œ๋งŒ ๋‹ค๋ฅธ ๊ฒฝ์šฐ๋“ค์„ ๊ทธ๋ฃน์œผ๋กœ ๋ฌถ์–ด์„œ ์ฒ˜๋ฆฌํ•˜๋ฉด ์กฐํ•ฉ์ด ๋œ๋‹ค.

 

๊ฐ ๊ทธ๋ฃน์€ $r!$ ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์œผ๋กœ ๋‚˜์—ด๋  ์ˆ˜ ์žˆ๋Š”๋ฐ, ํ•œ ์กฐํ•ฉ(e.g. AB)์˜ ์ˆœ์—ด์€ ๋‘ ๊ฐ€์ง€(e.g. AB, BA)๊ฐ€ ์žˆ๋‹ค๋Š” ๊ฒƒ์„ ์˜๋ฏธํ•œ๋‹ค. ๋”ฐ๋ผ์„œ ์ˆœ์—ด์˜ ์ด ์ˆ˜๋ฅผ ๊ฐ ๊ทธ๋ฃน์˜ ์ˆœ์—ด ์ˆ˜์ธ $r!$๋กœ ๋‚˜๋ˆ„๋ฉด ์ค‘๋ณต์„ ์ œ๊ฑฐํ•œ ์กฐํ•ฉ์˜ ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ๋‹ค.

 

 

์ •๋ฆฌํ•˜๋ฉด n๊ฐœ ์š”์†Œ์—์„œ r๊ฐœ๋ฅผ ์„ ํƒํ•˜๋Š” ์ˆœ์—ด์˜ ์ˆ˜($_nP_r$)๋ฅผ, $r!$๋กœ ๋‚˜๋ˆ ์„œ ์กฐํ•ฉ์˜ ์ˆ˜($_nC_r$)๋ฅผ ๊ตฌํ•  ์ˆ˜ ์žˆ๋‹ค. ์ด๋ฅผ ์ˆ˜ํ•™์  ๊ณต์‹์œผ๋กœ ํ‘œ๊ธฐํ•˜๋ฉด $C(n,r) = \frac{_nP_r}{r!} =\frac{n!}{r!(n-r)!}$์ด ๋œ๋‹ค. $\frac{n!}{(n-r)!}$์‹์€ ์ˆœ์—ด์„ ๋‚˜ํƒ€๋‚ด๊ณ , $(n-r)!$์— ํ•ด๋‹นํ•˜๋Š” ํ•ญ์ด ์•ฝ๋ถ„๋ผ์„œ $\frac{_nP_r}{r!}$ ํ˜•ํƒœ๋กœ ๋‹จ์ˆœํ™”๋œ๋‹ค.

 

$$C(3,2)=\frac{3!}{2!(3-2)!}=\frac{3 \cdot 2 \cdot \cancel{1}}{2 \cdot 1 \cdot \cancel {1}}=3$$

 

$$C(5,3)=\frac{5!}{3!(5-3)!}=\frac{5 \cdot 4 \cdot 3 \cdot \cancel{2} \cdot \cancel{1}}{3\cdot 2 \cdot 1 \cdot \cancel{2} \cdot \cancel{1}} =10$$

 

์‹ค์ƒํ™œ ์˜ˆ์‹œ

  • ๋กœ๋˜ ๋ฒˆํ˜ธ : 45๊ฐœ ์ˆซ์ž ์ค‘์—์„œ 6๊ฐœ๋ฅผ ๊ณ ๋ฅด๋Š” ๋กœ๋˜ ์ถ”์ฒจ์—์„œ ๊ฐ ์ˆซ์ž์˜ ์ˆœ์„œ๋Š” ์ค‘์š”ํ•˜์ง€ ์•Š๋‹ค. ์ˆซ์ž์กฐํ•ฉ [5, 12, 23, 34, 40, 42]์™€ [42, 34, 23, 12, 5, 40]์€ ๋™์ผํ•œ ๊ฒฐ๊ณผ๋กœ ์ทจ๊ธ‰ํ•œ๋‹ค.
  • ์กฐ ๋ฐฐ์ • : 30๋ช… ์ค‘์—์„œ 5๋ช…์œผ๋กœ ์ด๋ค„์ง„ ์กฐ๋ฅผ ๊ตฌ์„ฑํ•  ๋•Œ, ํ•œ ์กฐ์— ์†ํ•˜๋Š” ์‚ฌ๋žŒ์˜ ์ˆœ์„œ๋Š” ์ค‘์š”ํ•˜์ง€ ์•Š๋‹ค. ์˜ˆ๋ฅผ๋“ค์–ด [A, B, C, D, E] ๊ทธ๋ฃน๊ณผ [E, D, C, B, A] ๊ทธ๋ฃน์€ ๋™์ผํ•˜๋‹ค.

 

๊ตฌํ˜„

const getCombinations = (arr, combSize, start = 0, curComb = []) => {
  if (curComb.length === combSize) return [curComb]; // ๋ชฉํ‘œ ํฌ๊ธฐ์˜ ์กฐํ•ฉ์„ ์™„์„ฑํ–ˆ์„ ๋•Œ
  if (start === arr.length) return []; // ๋”์ด์ƒ ์กฐํ•ฉ์„ ์ƒ์„ฑํ•  ์ˆ˜ ์—†์„ ๋•Œ

  return arr.slice(start).reduce((allCombs, item, i) => {
    const nextComb = curComb.concat(item);
    const nextStart = start + i + 1;
    return allCombs.concat(getCombinations(arr, combSize, nextStart, nextComb));
  }, []);
};

getCombinations(['A', 'B', 'C'], 2); // [['A', 'B'], ['A', 'C'], ['B', 'C']]
๋”๋ณด๊ธฐ
/**
 * Iteratively generates combinations from an array. This method is typically
 * more performant than its recursive counterpart. For example, generating combinations of 2 elements
 * from a 1000-element array takes about 100ms iteratively, compared to 600ms functionally.
 */
const getCombinationsIterative = (arr, combSize, start = 0, curComb = []) => {
  if (curComb.length === combSize) return [curComb];

  const results = [];
  const maxIndex = arr.length - combSize + curComb.length;

  for (let i = start; i <= maxIndex; i++) {
    const nextComb = curComb.concat(arr[i]);
    const nextStart = i + 1;
    results.push(...getCombinationsIterative(arr, combSize, nextStart, nextComb));
  }

  return results;
};
  1. ์ž…๋ ฅ๋ฐ›์€ ๋ฐฐ์—ด์˜ start ์ธ๋ฑ์Šค๋ถ€ํ„ฐ ์š”์†Œ๋ฅผ ํ•˜๋‚˜์”ฉ ์„ ํƒํ•˜์—ฌ ํ˜„์žฌ ์กฐํ•ฉ curComb์— ์ถ”๊ฐ€ํ•œ๋‹ค
  2. ์„ ํƒํ•œ ์š”์†Œ ๋’ค์— ์žˆ๋Š” ์š”์†Œ๋“ค๋กœ ์กฐํ•ฉ์„ ์ƒ์„ฑํ•˜๊ธฐ ์œ„ํ•ด nextStart ์ธ๋ฑ์Šค๋ฅผ ์—…๋ฐ์ดํŠธํ•œ๋‹ค
  3. e.g. ['A', 'B', 'C'] ๋ฐฐ์—ด์—์„œ ์„ ํƒํ•œ ์š”์†Œ๊ฐ€ B(i=1)๋ผ๋ฉด nextStart๋Š” 2๊ฐ€ ๋œ๋‹ค
  4. ํ˜„์žฌ ์กฐํ•ฉ๊ณผ ์—…๋ฐ์ดํŠธํ•œ ์ธ๋ฑ์Šค๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ์žฌ๊ท€์ ์œผ๋กœ(1~2๊ณผ์ • ๋ฐ˜๋ณต) ์กฐํ•ฉ์„ ์ƒ์„ฑํ•œ๋‹ค
  5. ์žฌ๊ท€ ๊ณผ์ •์„ ํ†ตํ•ด ์ƒ์„ฑ๋œ ๋ชจ๋“  ์กฐํ•ฉ์„ ํ•˜๋‚˜์˜ ๋ฐฐ์—ด๋กœ ๋งŒ๋“  ํ›„ ๋ฐ˜ํ™˜ํ•œ๋‹ค

 

 

๋ ˆํผ๋Ÿฐ์Šค


์ˆœ์—ด๊ณผ ์กฐํ•ฉ - ์ˆœ์—ด์ด๋ž€ | ์ˆ˜ํ•™๋ฐฉ

์ˆœ์—ด๊ณผ ์กฐํ•ฉ - ์กฐํ•ฉ์ด๋ž€ | ์ˆ˜ํ•™๋ฐฉ

 


๊ธ€ ์ˆ˜์ •์‚ฌํ•ญ์€ ๋…ธ์…˜ ํŽ˜์ด์ง€์— ๊ฐ€์žฅ ๋น ๋ฅด๊ฒŒ ๋ฐ˜์˜๋ฉ๋‹ˆ๋‹ค. ๋งํฌ๋ฅผ ์ฐธ๊ณ ํ•ด ์ฃผ์„ธ์š”
๋ฐ˜์‘ํ˜•