[JavaScript] ์žฌ๊ท€

Hannahhhยท2022๋…„ 8์›” 19์ผ
0

JavaScript

๋ชฉ๋ก ๋ณด๊ธฐ
36/47

๐Ÿ” ์žฌ๊ท€


์ž๊ธฐ ์ž์‹ ์„ ํ˜ธ์ถœํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ์žฌ๊ท€ํ•จ์ˆ˜๋ผ๊ณ  ํ•˜๋ฉฐ, ์žฌ๊ท€ํ•จ์ˆ˜๋ฅผ ํ™œ์šฉํ•ด ๋ฐ˜๋ณต์ ์ธ ์ž‘์—…์„ ํ•ด์•ผํ•˜๋Š” ๋ฌธ์ œ๋ฅผ ๋”์šฑ ๊ฐ„๊ฒฐํ•œ ์ฝ”๋“œ๋กœ ํ’€์–ด๋‚ผ ์ˆ˜ ์žˆ๋‹ค.

์ฃผ์–ด์ง„ ๋ฌธ์ œ๋ฅผ ๋น„์Šทํ•œ ๊ตฌ์กฐ์˜ ๋” ์ž‘์€ ๋ฌธ์ œ๋กœ ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ, ํ˜น์€ ์ค‘์ฒฉ๋œ ๋ฐ˜๋ณต๋ฌธ์ด ๋งŽ๊ฑฐ๋‚˜ ๋ฐ˜๋ณต๋ฌธ์˜ ์ค‘์ฒฉ ํšŸ์ˆ˜๋ฅผ ์˜ˆ์ธกํ•˜๊ธฐ ์–ด๋ ค์šด ๊ฒฝ์šฐ์— ์‚ฌ์šฉํ•œ๋‹ค. ๋”ฐ๋ผ์„œ, ๋ชจ๋“  ์žฌ๊ท€ํ•จ์ˆ˜๋Š” ๋ฐ˜๋ณต๋ฌธ์œผ๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค.



์žฌ๊ท€๋กœ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ์•„๋ž˜์™€ ๊ฐ™๋‹ค.

  1. ๋ฌธ์ œ๋ฅผ ์ž‘๊ฒŒ ์ชผ๊ฐ ๋‹ค.
  2. 1๋ฒˆ๊ณผ ๊ฐ™์€ ๋ฐฉ์‹์œผ๋กœ, ๊ฐ€์žฅ ์ž‘์€ ๋‹จ์œ„๋กœ ๋ฌธ์ œ๋ฅผ ์ชผ๊ฐ ๋‹ค.
  3. ๊ฐ€์žฅ ์ž‘์€ ๋‹จ์œ„์˜ ๋ฌธ์ œ๋ฅผ ํ’‚์œผ๋กœ์จ ์ „์ฒด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•œ๋‹ค.

์œ„์˜ ๋ฐฉ๋ฒ•์„ ์ด์šฉํ•ด arrSum ํ•จ์ˆ˜๋กœ [1, 2, 3, 4, 5] ์˜ ํ•ฉ์„ ๊ตฌํ•˜๋Š” ๊ณผ์ •์„ ์˜ˆ์‹œ๋กœ ๋“ค๋ฉด, ์•„๋ž˜์™€ ๊ฐ™๋‹ค.

// ๋ฌธ์ œ๋ฅผ ๊ฐ€์žฅ ์ž‘์€ ๋‹จ์œ„๋กœ ์ชผ๊ฐ ๋‹ค.
arrSum([1, 2, 3, 4, 5]) === 1 + arrSum([2, 3, 4, 5])
arrSum([2, 3, 4, 5]) === 2 + arrSum([3, 4, 5])
arrSum([3, 4, 5]) === 3 + arrSum([4, 5])
arrSum([4, 5]) === 4 + arrSum([5])
arrSum([5]) === 5 + arrSum([]) // ๊ฐ€์žฅ ์ž‘์€ ๋ฌธ์ œ = arrSum([])


์œ„ ๋‹จ๊ณ„๋ฅผ ๋ฐ˜์˜ํ•ด, ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด๋ณด๋ฉด ์•„๋ž˜์™€ ๊ฐ™๋‹ค.

function arrSum (arr) {
  // ๋นˆ ๋ฐฐ์—ด์„ ๋ฐ›์•˜์„ ๋•Œ 0์„ ๋ฆฌํ„ดํ•˜๋Š” ์กฐ๊ฑด๋ฌธ
  //   --> ๊ฐ€์žฅ ์ž‘์€ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ์ฝ”๋“œ & ์žฌ๊ท€๋ฅผ ๋ฉˆ์ถ”๋Š” ์ฝ”๋“œ
  
  // ์กฐ๊ฑด๋ฌธ์— ์˜ํ•ด ๋” ์ด์ƒ ์ž๊ธฐ์ž์‹ ์„ ํ˜ธ์ถœํ•˜์ง€ ์•Š๊ณ , ์ˆซ์ž 0๋ฅผ returnํ•˜๋ฉด์„œ ์ข…๋ฃŒ. 
  if (arr.length === 0) {
    return 0
  }

  // ๋ฐฐ์—ด์˜ ์ฒซ ์š”์†Œ + ๋‚˜๋จธ์ง€ ์š”์†Œ๊ฐ€ ๋‹ด๊ธด ๋ฐฐ์—ด์„ ๋ฐ›๋Š” arrSum ํ•จ์ˆ˜
  //   --> ์žฌ๊ท€(์ž๊ธฐ ์ž์‹ ์„ ํ˜ธ์ถœ)๋ฅผ ํ†ตํ•ด ๋ฌธ์ œ๋ฅผ ์ž‘๊ฒŒ ์ชผ๊ฐœ๋‚˜๊ฐ€๋Š” ์ฝ”๋“œ
	return arr.shift() + arrSum(arr) // 0๋ฒˆ์งธ ์ธ๋ฑ์Šค๋ฅผ ์‚ญ์ œํ•ด๊ฐ€๋ฉด์„œ ++
}




๐Ÿ‘€ ์žฌ๊ท€์ ์œผ๋กœ ์‚ฌ๊ณ ํ•˜๊ธฐ


1) ์žฌ๊ท€ ํ•จ์ˆ˜์˜ ์ž…๋ ฅ๊ฐ’๊ณผ ์ถœ๋ ฅ๊ฐ’์„ ์ •์˜ํ•œ๋‹ค.

์ด๋•Œ, ์ถ”์ƒ์ ์œผ๋กœ ๋˜๋Š” ๋‹จ์ˆœํ•˜๊ฒŒ ์ •์˜ํ•ด์•ผ ํ•œ๋‹ค.

  • arrSum: [number] => number โ† ์ž…์ถœ๋ ฅ๊ฐ’ ์ •์˜

2) ๋ฌธ์ œ๋ฅผ ์ชผ๊ฐœ๊ณ  ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๋‚˜๋ˆ„๊ธฐ

๋ฌธ์ œ๋ฅผ ์ชผ๊ฐค ๊ธฐ์ค€์„ ์ •ํ•˜๊ณ , ๊ธฐ์ค€์— ๋”ฐ๋ผ ๋” ํฐ ๊ฒฝ์šฐ์™€ ์ž‘์€ ๊ฒฝ์šฐ๋กœ ๊ตฌ๋ถ„ํ•  ์ˆ˜ ์žˆ๋Š” ์ง€ ํ™•์ธํ•œ๋‹ค. ์ผ๋ฐ˜์ ์œผ๋กœ, ์ž…๋ ฅ๊ฐ’์„ ๊ธฐ์ค€์œผ๋กœ ์ •ํ•œ๋‹ค.

์ด๋•Œ, ์ค‘์š”ํ•œ ๊ด€์ ์€ ์ž…๋ ฅ๊ฐ’, ๋ฌธ์ œ์˜ ์ˆœ์„œ, ํฌ๊ธฐ๋กœ, ๋ฌธ์ œ๋ฅผ ๊ตฌ๋ถ„ํ•˜๋Š” ๋ฐ ์ˆ˜์›”ํ•˜๋‹ค.

  • ํ•จ์ˆ˜ arrSum ์˜ ๊ฒฝ์šฐ ์ž…๋ ฅ๊ฐ’์ธ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ์— ๋”ฐ๋ผ, ๋” ์ž‘์€ ๋ฌธ์ œ๋กœ ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ๋‹ค.

  • arrSum([1, 2, 3, 4]) ๋ฅผ ๊ตฌํ•˜๋Š” ๋ฐฉ๋ฒ•๊ณผ arrSum([2, 3, 4]) ์„ ๊ตฌํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ๋™์ผํ•˜๋‹ค.

  • ํ•จ์ˆ˜ arrSum์€ ์ž…๋ ฅ๊ฐ’์ด ๋นˆ ๋ฐฐ์—ด์ธ ๊ฒฝ์šฐ์™€ ๊ทธ๋ ‡์ง€ ์•Š์€ ๊ฒฝ์šฐ๋กœ ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ์œผ๋ฉฐ, ๊ฐ๊ฐ ๋‹ค๋ฅธ ๋ฐฉ์‹์œผ๋กœ ์ฒ˜๋ฆฌํ•ด์•ผ ํ•œ๋‹ค.
    arrSum: [number] => number
    arrSum([ ]) โ† ์ž…๋ ฅ๊ฐ’์ด ๋นˆ ๋ฐฐ์—ด์ธ ๊ฒฝ์šฐ
    arrSum([์š”์†Œ1, ์š”์†Œ2, ... , ์š”์†Œn]) โ† ๊ทธ๋ ‡์ง€ ์•Š์€ ๊ฒฝ์šฐ


3) ๋‹จ์ˆœํ•œ ๋ฌธ์ œ ํ•ด๊ฒฐํ•˜๊ธฐ

๋ฌธ์ œ๋ฅผ ์—ฌ๋Ÿฌ ๊ฒฝ์šฐ๋กœ ๊ตฌ๋ถ„ํ•œ ๋‹ค์Œ, ๊ฐ€์žฅ ํ•ด๊ฒฐํ•˜๊ธฐ ์‰ฌ์šด ๋ฌธ์ œ๋ถ€ํ„ฐ ํ•ด๊ฒฐํ•˜๋ฉฐ ์ด๋ฅผ ์žฌ๊ท€์˜ ๊ธฐ์ดˆ(base case)๋ผ๊ณ  ํ•œ๋‹ค.
์žฌ๊ท€์˜ ๊ธฐ์ดˆ๋Š” ์žฌ๊ท€ ํ•จ์ˆ˜๋ฅผ ๊ตฌํ˜„ํ•  ๋•Œ, ์žฌ๊ท€์˜ ํƒˆ์ถœ ์กฐ๊ฑด(์žฌ๊ท€ ํ˜ธ์ถœ์ด ๋ฉˆ์ถ”๋Š” ์กฐ๊ฑด)์„ ๊ตฌ์„ฑํ•œ๋‹ค.
๋”ฐ๋ผ์„œ, ๋ฌธ์ œ๋ฅผ ์ตœ๋Œ€ํ•œ ์ž‘๊ฒŒ ์ชผ๊ฐ  ํ›„์— ํ•ด๊ฒฐํ•˜๋Š” ๊ฒƒ์ด ์ค‘์š”ํ•˜๋‹ค.

  • arrSum: [number] => number
    arrSum([ ]) โ† ์ž…๋ ฅ๊ฐ’์ด ๋นˆ ๋ฐฐ์—ด์ธ ๊ฒฝ์šฐ : ํ•ด๊ฒฐ!
    arrSum([์š”์†Œ1, ์š”์†Œ2, ... , ์š”์†Œn]) โ† ๊ทธ๋ ‡์ง€ ์•Š์€ ๊ฒฝ์šฐ

4) ๋ณต์žกํ•œ ๋ฌธ์ œ ํ•ด๊ฒฐํ•˜๊ธฐ

  • ๊ธธ์ด๊ฐ€ 1 ์ด์ƒ์ธ ๋ฐฐ์—ด์ด ํ•จ์ˆ˜ arrSum ์— ์ž…๋ ฅ๋œ ๊ฒฝ์šฐ, ์ž…๋ ฅ๋œ ๋ฐฐ์—ด์„ ๋ฐฐ์—ด์˜ ์ฒซ ์š”์†Œ์™€ ๋‚˜๋จธ์ง€ ์š”์†Œ๋ฅผ ์ž…๋ ฅ๊ฐ’์œผ๋กœ ๊ฐ–๋Š” ๋ฌธ์ œ๋กœ ์ชผ๊ฐœ๊ณ , ๋‘˜์„ ๋”ํ•œ๋‹ค.
    arrSum: [number] => number
    arrSum([ ]) === 0
    arrSum([์š”์†Œ1, ์š”์†Œ2, ... , ์š”์†Œn]) === ์š”์†Œ1 + arrSum([์š”์†Œ2, ..., ์š”์†Œn]) โ† ๊ทธ๋ ‡์ง€ ์•Š์€ ๊ฒฝ์šฐ : ํ•ด๊ฒฐ!



์•„๋ž˜๋Š” ์ผ๋ฐ˜์ ์ธ ์žฌ๊ท€ ํ•จ์ˆ˜์˜ ํ…œํ”Œ๋ฆฟ์ด๋‹ค.

function recursive(input1, input2, ...) {
  // base case : ๋ฌธ์ œ๋ฅผ ๋” ์ด์ƒ ์ชผ๊ฐค ์ˆ˜ ์—†๋Š” ๊ฒฝ์šฐ
  if (๋ฌธ์ œ๋ฅผ ๋” ์ด์ƒ ์ชผ๊ฐค ์ˆ˜ ์—†์„ ๊ฒฝ์šฐ) {
    return ๋‹จ์ˆœํ•œ ๋ฌธ์ œ์˜ ํ•ด๋‹ต;
  }

  // recursive case : ๊ทธ๋ ‡์ง€ ์•Š์€ ๊ฒฝ์šฐ
  return ๋” ์ž‘์€ ๋ฌธ์ œ๋กœ ์ƒˆ๋กญ๊ฒŒ ์ •์˜๋œ ๋ฌธ์ œ
}

์•„๋ž˜๋Š” ์œ„์˜ ํ…œํ”Œ๋ฆฟ์„ ์ ์šฉํ•ด ํŒฉํ† ๋ฆฌ์–ผ์„ ๊ตฌํ˜„ํ•œ ์˜ˆ์ œ์ด๋‹ค.

function factorial(n){

  if(n === 1){
    return 1;
  }
  return n * factorical(n-1);
}




Reference: ์ฝ”๋“œ์Šคํ…Œ์ด์ธ 

0๊ฐœ์˜ ๋Œ“๊ธ€