This document discusses linear recursion and iteration processes for computing factorials. It presents two approaches - a linear recursive procedure that computes each factorial by multiplying the previous factorial by the current number, and a linear iterative procedure that maintains a running product and counter. Both approaches are expressed as procedures and their step-by-step workings are visualized through substitution models for computing 6!. The two approaches are compared, with the key difference being that the iterative procedure uses changing state variables during repeated calculations.

1. SICP

2.
1.2

3. 프로시저와

4. 프로세스
cecil

5. 프로그래머라면,

6. 여러가지

7. 프로시저가

8. 만들어

9. 내는

11. 프로세스를

12. 미리

13. 그릴줄

14. 알아야

15. 함.

16.
이

17. 장에서는

18. 프로시저가

19. 만들어

20. 내는

21. 프로세스

22. 가운데

23.
자주

24. 나타나는

25. 몇가지

26. 패턴을

27. 탐구

28. More formally, we maintain a running product, together with a counter
that counts from 1 up to n. We can describe the computation by saying
that the counter and the product simultaneously change from one step the next according to the rule
1.2.1 Linear Recursion and Iteration
We begin by considering the factorial function, defined by
Liner

29. recursion

30.
(Factorial

31. 함수)
n! = n · (n ° 1) · (n ° 2) · · · 3 · 2 · 1
product √ counter * product
counter √ counter + 1
There are many ways to compute factorials. One way is to make use of the
observation that n! is equal to n times (n ° 1)! for any positive integer n:
and stipulating that n! is the value of the product when the counter exceeds
n.
n! = n · [(n ° 1) · (n ° 2) · · · 3 · 2 · 1] = n · (n ° 1)!
n!

32. =

33. n

34. ·・

35. (n-1)

36. ·・

37. (n-2)

38. ·・

39. ·・

40. ·・

41. 3

42. ·・

43. 2

44. ·・

45. 1

46.
Thus, we can compute n! by computing (n ° 1)! and multiplying the result
by n. 즉,If

47. n!we

48. =

49. nadd

50. ·・

51. [(n-the 1)

52. ·・

53. stipulation (n-2)

55. ·・

56. 3

57. ·・

58. 2

59. ·・that

60. 1]

61. =

62. n1!

63. ·・

64. is (n-equal 1)!
to 1, this observation trans-lates
directly into a procedure:
(define (factorial n)
(if (= n 1)
1
(* n (factorial (- n 1)))))
We can use the substitution model of Section 1.1.5 to watch this proce-dure
F곧i

65. g바ure로1

66. .연3:산A l하ine지ar

67. 않rec고ur

68. s미iv루e어pr

69. o놓c은es

70. s탓fo에r c

71. o식m이pu

72. 늘tin어g남6!..
in action computing 6!, as shown in Figure 1.3.

73. Liner

74. iteration

75.
(Factorial

76. 함수)
product

77. ←

78. counter

79. *

80. product

82.
counter

83. ←

84. counter

85. +

86. 1
74
Once again, we can recast our description as a procedure for computing
factorials:29
(define (factorial n)
(fact-iter 1 1 n))
(define (fact-iter product counter max-count)
(if ( counter max-count)
product
(fact-iter (* counter product)
(+ counter 1)
max-count)))
Figure 1.4: A linear iterative process for computing Compare the two processes. From one point of view, they 상태As before, we can use the substitution model to visualize the process of
computing 6!, as shown in Figure 1.4.

87. 변수가

88. 있어서

89. 반복할

90. 때마다

92.
바뀌는

93. 계산

94. 상태를

95. 기록

96. (define (g n) (A 1 n))
(define (h n) (A 2 n))
(define (k n) (* 5 n n))
Give concise mathematical definitions for the functions computed
by the procedures f, g, and h for positive integer values of n. For
example, (k n) computes 5n2.
Tree

97. recursion

98.
(Fibonacci

99. sequence)
1.2.2 Tree Recursion
Another common pattern of computation is called tree recursion. As an ex-ample,
consider computing the sequence of Fibonacci numbers, in which
each number is the sum of the preceding two:
0, 1, 1, 2, 3, 5, 8, 13, 21, . . .
In general, the Fibonacci numbers can be defined by the rule
Fib(n) =
8
:
0 if n = 0
1 if n = 1
Fib(n ° 1) + Fib(n ° 2) otherwise
프로시저가

100. 1번

101. 실행될때

102. 자신을

103. 2번

104. 호출
We can immediately translate this definition into a recursive computing Fibonacci numbers:
(define (fib n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (fib (- n 1))
80
We can immediately translate this definition into a recursive procedure for
computing Fibonacci numbers:
(define (fib n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (fib (- n 1))
(fib (- n 2))))))
계산

105. 복잡도:

106. Fib(n)이

107. 지수비례로

108. 증가

109.
Consider the pattern of this computation. To compute (fib 5), we com-pute
(fib 4) and (fib 3). To compute (fib 4), we compute (fib 3)
and (fib 2). In general, the evolved process looks like a tree, as shown in
Figure 1.5. Notice that the branches split into two at each level (except at
81
Figure 1.5: The tree-recursive process generated in computing
(fib 5).
에

110. 가까운

111. 정수,

113.
Thus, the process 공간uses

114. 복잡도:a number

115. 입력

116. 크기에of steps

117. 선형으로that grows

118. 비례
exponentially with
the input. On the other hand, the space required grows only linearly with
the input, because we need keep track only of which nodes are above us in
the tree at any point in the computation. In general, the number of steps
80
We can immediately translate this definition into a recursive procedure for
computing Fibonacci numbers:
(define (fib n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (fib (- n 1))
(fib (- n 2))))))
Consider the pattern of this computation. To compute (fib 5), we com-pute
(fib 4) and (fib 3). To compute (fib 4), we compute (fib 3)
and (fib 2). In general, the evolved process looks like a tree, as shown in
Figure 1.5. Notice that the branches split into two at each level (except at
the bottom); this reflects the fact that the fib procedure calls itself twice
each time it is invoked.
This procedure is instructive as a prototypical tree recursion, but it is a
terrible way to compute Fibonacci numbers because it does so much re-dundant
computation. Notice in Figure 1.5 that the entire computation
of (fib 3)—almost half the work—is duplicated. In fact, it is not hard
to show that the number of times the procedure will compute (fib 1) or
(fib 0) (the number of leaves in the above tree, in general) is precisely
Fib(n + 1). To get an idea of how bad this is, one can show that the value
of Fib(n) grows exponentially with n. More precisely (see Exercise 1.13),
Fib(n) is the closest integer to 'n/p5, where
' =
1 + p5
2 º 1.6180
is the golden ratio, which satisfies the equation
(fib (- n 2))))))
Consider the pattern of this computation. To compute (fib 4) and (fib 3). To compute (fib 4), we compute and (fib 2). In general, the evolved process looks like a Figure 1.5. Notice that the branches split into two at each the bottom); this reflects the fact that the fib procedure each time it is invoked.
This procedure is instructive as a prototypical tree recursion, terrible way to compute Fibonacci numbers because it computation. Notice in Figure 1.5 that the entire of (fib 3)—almost half the work—is duplicated. In fact, to show that the number of times the procedure will compute (fib 0) (the number of leaves in the above tree, in general) Fib(n + 1). To get an idea of how bad this is, one can show of Fib(n) grows exponentially with n. More precisely (see Fib(n) is the closest integer to 'n/p5, where
' =
1 + p5
2 º 1.6180
is the golden ratio, which satisfies the equation
'2 = ' + 1

119. the tree at any point in the computation. In general, the number of steps
required by a tree-recursive process will be proportional to the number of
nodes in the tree, while the space required will be proportional to the max-imum
Liner

120. iteration

122.
(Fibonacci

123. sequence)
depth of the tree.
We can also formulate an iterative process for computing the Fibonacci
numbers. The idea is to use a pair of integers a and b, initialized to Fib(1) =
1 and Fib(0) = 0, and to repeatedly apply the simultaneous transformations
a √ a + b
b √ a
82
It is not hard to showthat, after applying this transformation n times, a and
b will be equal, respectively, to Fib(n+1) and Fib(n). Thus, we can compute
Fibonacci numbers iteratively using the procedure
(define (fib n)
(fib-iter 1 0 n))
(define (fib-iter a b count)
(if (= count 0)
b
(fib-iter (+ a b) a (- count 1))))
This second method for computing Fib(n) is a linear iteration. The dif-ference
in number of steps required by the two methods—one linear in n,

124. 연습:

125. 돈

126. 바꾸는

127. 방법
N

128. 달러를

129. 50센트,

130. 25센트,

131. 10센트,

132. 5센트,

133. 1센트

134. 동전으로

135. 바꾸는

136. 방법

137.
•맨

138. 처음

139. 나오는

140. 한가지

141. 동전을

142. 빼고,

143. 남은

144. 가지

145. 동전으로

146. 바꾸는

147. 가짓수

150. (처음

151. 나온

152. 동전을

153. 쓰지

154. 않는

155. 가짓수)

156.
•처음

157. 나오는

158. 동전이

159. d짜리

160. 일때

161. a-d한

162. 돈을

163. n가지

164. 동전으로

165. 바꾸는

166. 가짓수

169. (처음

170. 나온

171. 동전을

172. 쓰는

173. 가짓수)
종료

174. 조건

175. 정의

176.
•a가

177. 0으로

178. 딱

179. 떨어지면,

180. 동전으로

181. 바꾸는

182. 방법은

183. 1가지

184.
•a가

185. 0보다

186. 적거나

187. n이

188. 0이면

189. 동전으로

190. 바꾸는

191. 방법은

192. 0가지

193. 연습:

194. 돈

195. 바꾸는

196. 방법
84
can use it to describe an algorithm if we specify the following degenerate
cases:33
• If a is exactly 0, we should count that as 1 way to make change.
• If a is less than 0, we should count that as 0 ways to make change.
• If n is 0, we should count that as 0 ways to make change.
We can easily translate this description into a recursive procedure:
(define (count-change amount)
(cc amount 5))
(define (cc amount kinds-of-coins)
(cond ((= amount 0) 1)
종료((or ( amount 0) (= kinds-of-coins 0)) 0)
(else (+ (cc amount
(- kinds-of-coins 1))
(cc (- amount
(The first-denomination procedure takes as input the number of kinds
of coins available and returns the denomination of the first kind. Here we
33 (first-denomination kinds-of-coins))
kinds-of-coins)))))
(define (first-denomination kinds-of-coins)
(cond ((= kinds-of-coins 1) 1)
((= kinds-of-coins 2) 5)
((= kinds-of-coins 3) 10)
((= kinds-of-coins 4) 25)
((= kinds-of-coins 5) 50)))

197. 조건
동전

198. 사용

200. X
동전

201. 사용
Iteration으로

203.
만들기가

204. 쉽지

205. 않음.

206. Order

207. of

208. Growth

209.
(프로세스가

210. 자라나는

211. 정도)
입력

212. 크기에

213. 따라

214. 프로세스가

215. 쓰는

216. 자원

217. 양이

218. 자라나는

219. 정도

220.
-

221. 프로세스가

222. 쓰는

223. 자원

224. 양을

225. 어림잡아

226. 측정할때

227. 사용
n이

228. 알맞게

229. 큰

230. 값을

231. 가리키는

232. 변수이고,

233. n에

234. 매이지

235. 않은

236. 상수

237. k1

238. 과

239. k2

240. 가

242.
다음

243. 조건을

244. 만족한다면,

245. R(n)

246. 은

247. Θ(f

248. (n))

249. 차수로

250. 자라난다고

251. 하고

252.
,

253. R(n)

254. =

255. Θ(f

256. (n))

257. 이라고

258. 쓰며

259. “theta

260. of

261. f

262. (n)”라

263. 읽는다

265.
!
k1

266. f

267. (n)

268. ≤

269. R(n)

270. ≤

271. k2

272. f

273. (n)

274. 거듭제곱(1)
밑수

275. b,

276. 0보다

277. 큰

278. 정수

279. n에

280. 대하여
12.15) is evaluated?
b. What is the order of growth in space and number of steps (as a
function of a) used by the process generated by the sine proce-dure
when (sine a) is evaluated?
1.2.4 Exponentiation
Consider the problem of computing the exponential of a given number.
We would like a procedure that takes as arguments a base b and a positive
integer exponent n and computes bn. One way to do this is via the recursive
definition
bn = b · bn°1
b0 = 1
90
which translates readily into the procedure
(define (expt b n)
(if (= n 0)
1
(* b (expt b (- n 1)))))
This is a linear recursive process, which requires ⇥(n) steps and ⇥(n)
space. Just as with factorial, we can readily formulate an equivalent linear
iteration:
(define (expt b n)
(expt-iter b n 1))
which translates readily into the procedure
(define (expt b n)
(if (= n 0)
1
(* b (expt b (- n 1)))))
This is a linear recursive process, which requires ⇥(n) steps space. Just as with factorial, we can readily formulate an equivalent iteration:
(define (expt b n)
(expt-iter b n 1))
(define (expt-iter b counter product)
(if (= counter 0)
product
(expt-iter b
(- counter 1)
(* b product))))
This version requires ⇥(n) steps and ⇥(1) space.
We can compute exponentials in fewer steps by using successive For instance, rather than computing b8 as
계산

281. 복잡도:

282. Θ(n)

283.
공간

284. 복잡도:

285. Θ(n)
계산

286. 복잡도:

287. Θ(n)

288.
공간

289. 복잡도:

290. Θ(1)

291. (- counter 1)
(* b product))))
This method works fine for exponents that are powers of 2. We can also take
advantage of successive squaring in computing exponentials in general if
we use the rule
거듭제곱(2)
product
(expt-iter b
This version requires ⇥(n) steps and ⇥(1) space.
We can compute exponentials in fewer steps by using successive squar-ing.
For instance, rather than computing b8 as
bn = (bn/2)2 if n is even
bn = b · bn°1 if n is odd
We can express this method as a procedure:
b · (b · (b · (b · (b · (b · (b · b))))))
91
계산

292. 단계를

293. 줄이기

294. 위해

295. 계속

296. 제곱하는

297. 방법을

298. 사용
(define (fast-expt b n)
(cond ((= n 0) 1)
we can compute it using three multiplications:
b2 = b · b
b4 = b2 · b2
b8 = b4 · b4
91
This method works fine for exponents that are powers of 2. We can also take
advantage of successive squaring in computing exponentials in general if
we use the rule
This method works fine for exponents that are powers of 2. We can also take
advantage of successive squaring in computing exponentials in general we use the rule
((even? n) (square (fast-expt b (/ n 2))))
(else (* b (fast-expt b (- n 1))))))
bn = (bn/2)2 if n is even
bn = b · bn°1 if n is odd
bn = (bn/2)2 if n is even
bn = b · bn°1 if n is odd
where the predicate to test whether an integer is even is defined in terms of
the primitive procedure We can remainder express this by
method as a procedure:
We can express this method as a procedure:
(define (fast-expt b n)
(cond ((= n 0) 1)
(define (even? n)
(define (fast-expt b n)
(= (remainder n 2) 0))
(cond ((= n 0) 1)
The process evolved by fast-expt grows logarithmically with n in both
space and number of steps. To see this, observe that computing b2n using
fast-expt requires only one more multiplication than computing bn. The
size of the exponent we can compute therefore doubles (approximately)
with every new multiplication we are allowed. Thus, the number of mul-tiplications
((even? n) (square (fast-expt b (/ n 2))))
(else (* b fast-expt b (- n 1))))))
((even? n) (square (fast-expt b (/ n 2))))
(else (* b (fast-expt b (- n 1))))))
where the predicate to test whether an integer is even is defined in terms the primitive procedure remainder by
where the predicate to test whether an integer is even is defined in terms of
the primitive procedure remainder by
b2n

299. 값을

300. 얻는데

301. 쓴

302. 곱셈의

303. 수는

304. bn에서

305. 쓴

306. 곱셈의

307. 수

308. +

309. 1

310.
계산/공간

311. 복잡도:

312. Θ(log2n)
(define (even? n)
(= (remainder n 2) 0))
The process evolved by fast-expt grows logarithmically with n in both
space and number of steps. To see this, observe that computing b2n using
(define (even? n)
(= (remainder n 2) 0))
The process evolved by fast-expt grows logarithmically with n in both
space and number of steps. To see this, observe that computing b2n using
required for an exponent of n grows about as fast as the loga-rithm
of n to the base 2. The process has ⇥(log n) growth.37

313. 최대

314. 공약수
유클리드

315. 알고리즘

316.
a를

317. b로

318. 나눈

319. 나머지가

320. r일때

321. a와

322. b의

323. 최대

324. 공약수가

325. b와

326. r의

327. 최대

328. 공약수와

329. 같다.

331.
!
GCD(a,

332. b)

333. =

334. GCD(b,

335. r)
GCD(206,40)

336. =

337. GCD(40,6)

353. =

354. GCD(6,4)

370. =

371. GCD(4,2)

387. =

388. GCD(2,0)

404. =2
will always eventually produce a pair where the second the GCD is the other number in the pair. This method GCD is known as Euclid’s Algorithm.42
It is easy to express Euclid’s Algorithm as a procedure:
(define (gcd a b)
(if (= b 0)
a
(gcd b (remainder a b))))
This generates an iterative process, whose number of logarithm of the numbers involved.
The fact that the number of steps required by Euclid’s growth bears an interesting relation to the Fibonacci Lam로그

405. 자람

406. 차수를

407. 가짐
e’s ´Theorem: If Euclid’s Algorithm requires k steps ※

408. 라메의

409. 정리:

410. 유클리드

411. 알고리즘으로

412. GCD를

413. 구하는데

414. K단계를

415. 거치는

416. 경우,

417. 두

418. 수

419. 가운데

420. 작은

421.
수는

422. k번째

423. 피보나치

424. 수보다

425. 크거나

426. 같아야

427. 한다.

428. n

429. ≥

430. Fib(k)

431. ≈

432. φk/sqrt(5)

433. 소수

434. 찾기

435.
(약수

436. 찾기)
(define (prime? n)!
(= n (smallest-divisor n)))!
!
(define (smallest-divisor n)!
(find-divisor n 2))!
!
(define (find-divisor n test-divisor)!
(cond (( (square test-divisor) n) n)!
((divides? test-divisor n) test-divisor)!
(else (find-divisor n (+ test-divisor 1)))))!
!
(define (divides? a b)!
(= (remainder b a) 0))
계산

437. 복잡도

438.
sqrt(n)

439. 소수

440. 찾기

441.
(페르마

442. 검사-1)
페르마의

443. 작은

444. 정리:

445. n이

446. 소수고,

447. a가

448. n보다는

449. 작고

450. 0보다는

451. 큰

452. 정수라면

453.
an은

454. a

455. modulo

456. n으로

457. 맞아

458. 떨어진다

459.
(두

460. 수를

461. n으로

462. 나눈

463. 나머지가

464. 같을

465. 때,

466. 그

467. 두

468. 숫자는

469. module

470. n으로

471. 맞아

472. 떨어진다라고

473. 함)

474.
!
페르마

475. 검사

476.
n이

477. 소수가

478. 아닐때

479. n보다

480. 작은

481. 수

482. a는

483. 거의

484. 위의

485. 조건을

486. 만족하지

487. 않는데,

488.
수

489. n이

490. a

492. n인

493. 수

495. a를

496. 임으로

497. 골라,

498. an

499. modulo

500. n의

501. 나머지가

502. a가

503. 아니라면,

504.
소수가

505. 아님.

506. a가

507. 맞으면

508. 소수일

509. 확률이

510. 높음.

511. 이를

512. 반복하는

513. 방법

514. 소수

515. 찾기

516.
(페르마

517. 검사-2)
거듭

518. 제곱하여

519. 구한

520. 값을

521. 다시

522. 다른

523. 수로

524. modulo하는

525. 프로시저
an

526. modulo

527. n을

529.
구하는

530. 프로시저
(define

531. (expmod

532. base

533. exp

534. m)

537. (cond

538. ((=

539. exp

540. 0)

541. 1)

546. ((even?

547. exp)

554. (remainder

555. (square

556. (expmod

557. base

558. (/

559. exp

560. 2)

561. m))

562. m))

567. (else

574. (remainder

575. (*

576. base

577. (expmod

578. base

579. (-

580. exp

581. 1)

582. m))

583. m))))
각주46)

584.
(x

585. *

586. y)

587. %

588. m

589. =

591.
((x%m)

592. *

593. (y%m))

594. %m
(define

595. (fermat-test

596. n)

599. (define

600. (try-it

601. a)

606. (=

607. (expmod

608. a

609. n

610. n)

611. a))

614. (try-it

615. (+

616. 1

617. (random

618. (-

619. n

620. 1)))))
계산

621. 복잡도:

622. Θ(log2n)
(define

623. (fast-prime?

624. n

625. times)

628. (cond

629. ((=

630. times

631. 0)

632. true)

637. ((fermat-test

638. n)

639. (fast-prime?

640. n

641. (-

642. times

643. 1)))

648. (else

649. false)))

650. 확률을

651. 바탕으로한

652. 알고리즘
페르마의

653. 검사:

654. 어떤

655. 수

656. n이

657. 페르마

658. 검사를

659. 모두

660. 거쳤다고

661. 해도

663.
n이

664. 소수가

665. 아닐

666. 수

667. 있다,

668. 아닐

669. 확률이

670. 높을

671. 뿐!!

672.
!
소수가

673. 아니지만,

674. an인

675. 정수

676. a에서

678.
an이

679. a와

680. modulo

681. n으로

682. 맞아

683. 떨어

684. 지는

685. n이

686. 존재

687.
운좋게

688. 이런

689. 정수는

690. 거의

691. 없음.

692. 페르마의

693. 검사는

694. 쓸만함.

695.
!
페르마의

696. 검사와

697. 같이

698. 틀릴

699. 확률이

700. 줄어

701. 든다고

702. 증명할

703. 수

704. 있으며,

705.
이러한

706. 확률

707. 알고리즘은

708. 여러

709. 분야에서

710. 사용되고

711. 있음.

712. QA

713. Reference
• Harold

714. Abelson,

715. Gerald

716. Jay

717. Sussman,

718. Julie

719. Sussman,

720. 컴퓨
터

721. 프로그램의

722. 구조와

723. 해석(김재우,

724. 안윤호,

725. 김수정,

726. 김정민

727. 옮김).

728. 서울시

729.
마포구:

730. 인사이트,

731. 2008