xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-08-26 10:07:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

build

Browse Source
This commit is contained in:
krahets
2026-08-18 04:58:51 +08:00
parent ba5285949b
commit 70c2fec77a
10 changed files with 4415 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/chapter_computational_complexity/exercises.md
+678 -32
View File
@@ -11,33 +11,287 @@ comments: true
下面两段代码都计算 $1 + 2 + \dots + n$（设 $n \ge 1$）。请把 `n` 设为 4，
按照程序实际执行的顺序回答问题，然后比较两种写法的效率。
```python
def sum_iter(n):
s = 0
for i in range(1, n + 1):
s += i
return s
=== "Python"
def sum_recur(n):
if n == 1:
return 1
return n + sum_recur(n - 1)
```
```python title="complexity_exercises.py"
def sum_iter(n: int) -> int:
"""迭代求和"""
res = 0
for i in range(1, n + 1):
res += i
return res
def sum_recur(n: int) -> int:
"""递归求和"""
if n == 1:
return 1
return n + sum_recur(n - 1)
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* 迭代求和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; ++i) {
res += i;
}
return res;
}
/* 递归求和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Java"
```java title="complexity_exercises.java"
/* 迭代求和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 递归求和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* 迭代求和 */
int SumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 递归求和 */
int SumRecur(int n) {
if (n == 1) {
return 1;
}
return n + SumRecur(n - 1);
}
```
=== "Go"
```go title="complexity_exercises.go"
/* 迭代求和 */
func sumIter(n int) int {
res := 0
for i := 1; i <= n; i++ {
res += i
}
return res
}
/* 递归求和 */
func sumRecur(n int) int {
if n == 1 {
return 1
}
return n + sumRecur(n-1)
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* 迭代求和 */
func sumIter(n: Int) -> Int {
var res = 0
for i in 1 ... n {
res += i
}
return res
}
/* 递归求和 */
func sumRecur(n: Int) -> Int {
if n == 1 {
return 1
}
return n + sumRecur(n: n - 1)
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* 迭代求和 */
function sumIter(n) {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 递归求和 */
function sumRecur(n) {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* 迭代求和 */
function sumIter(n: number): number {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 递归求和 */
function sumRecur(n: number): number {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* 迭代求和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 递归求和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* 迭代求和 */
fn sum_iter(n: i32) -> i32 {
let mut res = 0;
for i in 1..=n {
res += i;
}
res
}
/* 递归求和 */
fn sum_recur(n: i32) -> i32 {
if n == 1 {
return 1;
}
n + sum_recur(n - 1)
}
```
=== "C"
```c title="complexity_exercises.c"
/* 迭代求和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 递归求和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* 迭代求和 */
fun sumIter(n: Int): Int {
var res = 0
for (i in 1..n) {
res += i
}
return res
}
/* 递归求和 */
fun sumRecur(n: Int): Int {
if (n == 1) {
return 1
}
return n + sumRecur(n - 1)
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### 迭代求和 ###
def sum_iter(n)
res = 0
for i in 1..n
res += i
end
res
end
### 递归求和 ###
def sum_recur(n)
return 1 if n == 1
n + sum_recur(n - 1)
end
```
<!-- numbered-subquestions -->
1. 执行 `sum_iter(4)` 时，每轮循环结束后，变量 `s` 的值分别是多少？
2. 执行 `sum_recur(4)` 时，会依次调用哪些函数？从最深的一层开始返回时，结果怎样得到？
1. 输入 `n = 4` 执行迭代函数时，每轮循环结束后，累加变量 `res` 的值分别是多少？
2. 输入 `n = 4` 执行递归函数时，参数 `n` 会依次取哪些值？从最深的一层开始返回时，结果怎样得到？
3. 两种写法的时间复杂度和空间复杂度分别是多少？结合第 1、2 问的执行过程说明理由。
??? success "参考答案"
1. 循环变量 `i` 依次为 `1、2、3、4`，每轮结束后，`s` 依次变为
`1、3、6、10`，所以 `sum_iter(4)` 返回 10。
1. 循环变量 `i` 依次为 `1、2、3、4`，每轮结束后，`res` 依次变为
`1、3、6、10`，所以迭代函数返回 10。
2. 函数依次调用
`sum_recur(4) → sum_recur(3) → sum_recur(2) → sum_recur(1)`。
`sum_recur(1)` 返回 1，随后各层依次得到 `2 + 1 = 3`、`3 + 3 = 6`、`4 + 6 = 10`。
2. 参数 `n` 依次为 `4 → 3 → 2 → 1`。
最深一层返回 1，随后各层依次得到 `2 + 1 = 3`、`3 + 3 = 6`、`4 + 6 = 10`。
在最深处，4 次函数调用都尚未结束。
3. 两段代码都进行与 $n$ 成正比的循环或调用，因此时间复杂度均为 $O(n)$ 。
@@ -51,22 +305,414 @@ def sum_recur(n):
以下三个代码片段的输入均为正整数 $n$ 。请按时间复杂度从低到高排序，并写出各自的复杂度。
```python
# 片段一
s = 0
for i in range(n):
s += i
=== "Python"
# 片段二
s = 0
for i in range(n):
for j in range(i, n):
s += j
```python title="complexity_exercises.py"
def linear_loop(n: int) -> int:
"""线性阶循环"""
res = 0
for i in range(n):
res += i
return res
# 片段三
while n > 1:
n = n // 2
```
def quadratic_loop(n: int) -> int:
"""平方阶循环"""
res = 0
for i in range(n):
for j in range(i, n):
res += j
return res
def logarithmic_loop(n: int) -> int:
"""对数阶循环"""
while n > 1:
n //= 2
return n
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* 线性阶循环 */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
res += i;
}
return res;
}
/* 平方阶循环 */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
res += j;
}
}
return res;
}
/* 对数阶循环 */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Java"
```java title="complexity_exercises.java"
/* 线性阶循环 */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方阶循环 */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 对数阶循环 */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* 线性阶循环 */
int LinearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方阶循环 */
int QuadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 对数阶循环 */
int LogarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Go"
```go title="complexity_exercises.go"
/* 线性阶循环 */
func linearLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
res += i
}
return res
}
/* 平方阶循环 */
func quadraticLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
for j := i; j < n; j++ {
res += j
}
}
return res
}
/* 对数阶循环 */
func logarithmicLoop(n int) int {
for n > 1 {
n /= 2
}
return n
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* 线性阶循环 */
func linearLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
res += i
}
return res
}
/* 平方阶循环 */
func quadraticLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
for j in i ..< n {
res += j
}
}
return res
}
/* 对数阶循环 */
func logarithmicLoop(n: Int) -> Int {
var n = n
while n > 1 {
n /= 2
}
return n
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* 线性阶循环 */
function linearLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方阶循环 */
function quadraticLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 对数阶循环 */
function logarithmicLoop(n) {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* 线性阶循环 */
function linearLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方阶循环 */
function quadraticLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 对数阶循环 */
function logarithmicLoop(n: number): number {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* 线性阶循环 */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方阶循环 */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 对数阶循环 */
int logarithmicLoop(int n) {
while (n > 1) {
n ~/= 2;
}
return n;
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* 线性阶循环 */
fn linear_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
res += i;
}
res
}
/* 平方阶循环 */
fn quadratic_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
for j in i..n {
res += j;
}
}
res
}
/* 对数阶循环 */
fn logarithmic_loop(mut n: i32) -> i32 {
while n > 1 {
n /= 2;
}
n
}
```
=== "C"
```c title="complexity_exercises.c"
/* 线性阶循环 */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方阶循环 */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 对数阶循环 */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* 线性阶循环 */
fun linearLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
res += i
}
return res
}
/* 平方阶循环 */
fun quadraticLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
for (j in i until n) {
res += j
}
}
return res
}
/* 对数阶循环 */
fun logarithmicLoop(n: Int): Int {
var value = n
while (value > 1) {
value /= 2
}
return value
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### 线性阶循环 ###
def linear_loop(n)
res = 0
for i in 0...n
res += i
end
res
end
### 平方阶循环 ###
def quadratic_loop(n)
res = 0
for i in 0...n
for j in i...n
res += j
end
end
res
end
### 对数阶循环 ###
def logarithmic_loop(n)
n /= 2 while n > 1
n
end
```
??? success "参考答案"
docs/chapter_divide_and_conquer/exercises.md
+205 -12
View File
@@ -29,23 +29,216 @@ comments: true
下面的递归函数用分治计算 $x^n$：
```python
def fast_pow(x, n):
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "Python"
用它计算 `fast_pow(3, 5)`：
```python title="fast_power.py"
def fast_pow(x: int, n: int) -> int:
"""快速幂"""
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "C++"
```cpp title="fast_power.cpp"
/* 快速幂 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Java"
```java title="fast_power.java"
/* 快速幂 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "C#"
```csharp title="fast_power.cs"
/* 快速幂 */
int FastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = FastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Go"
```go title="fast_power.go"
/* 快速幂 */
func fastPow(x, n int) int {
if n == 0 {
return 1
}
half := fastPow(x, n/2)
if n%2 == 0 {
return half * half
}
return half * half * x
}
```
=== "Swift"
```swift title="fast_power.swift"
/* 快速幂 */
func fastPow(x: Int, n: Int) -> Int {
if n == 0 {
return 1
}
let half = fastPow(x: x, n: n / 2)
if n % 2 == 0 {
return half * half
}
return half * half * x
}
```
=== "JS"
```javascript title="fast_power.js"
/* 快速幂 */
function fastPow(x, n) {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "TS"
```typescript title="fast_power.ts"
/* 快速幂 */
function fastPow(x: number, n: number): number {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "Dart"
```dart title="fast_power.dart"
/* 快速幂 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n ~/ 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Rust"
```rust title="fast_power.rs"
/* 快速幂 */
fn fast_pow(x: i32, n: i32) -> i32 {
if n == 0 {
return 1;
}
let half = fast_pow(x, n / 2);
if n % 2 == 0 {
return half * half;
}
half * half * x
}
```
=== "C"
```c title="fast_power.c"
/* 快速幂 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Kotlin"
```kotlin title="fast_power.kt"
/* 快速幂 */
fun fastPow(x: Int, n: Int): Int {
if (n == 0) {
return 1
}
val half = fastPow(x, n / 2)
if (n % 2 == 0) {
return half * half
}
return half * half * x
}
```
=== "Ruby"
```ruby title="fast_power.rb"
### 快速幂 ###
def fast_pow(x, n)
return 1 if n == 0
half = fast_pow(x, n / 2)
return half * half if n.even?
half * half * x
end
```
令 `x = 3`、`n = 5`，用这个函数计算：
<!-- numbered-subquestions -->
1. 递归调用时，参数 `n` 依次变成哪些值？
2. 从最深层开始返回时，各层依次返回什么值？
3. 为什么要先保存 `half`，而不是把 `fast_pow(x, n // 2)` 写两遍？
3. 为什么要先把递归结果保存为 `half`，而不是在乘法两边各调用一次相同的子问题？
??? success "参考答案"
@@ -54,7 +247,7 @@ def fast_pow(x, n):
2. `n = 0` 时返回 1；`n = 1` 时返回 $1×1×3=3$；
`n = 2` 时返回 $3×3=9$；`n = 5` 时返回 $9×9×3=243$。
3. 如果把 `fast_pow(x, n // 2)` 在乘法两边各写一次，两次递归会计算完全相同的子问题。
3. 如果在乘法两边各调用一次相同的子问题，两次递归会进行完全相同的计算。
先把结果保存为 `half`，每层就只递归一次，递归深度约为 $\log n$；
调用两次会造成大量重复计算。
en/docs/chapter_computational_complexity/exercises.md
+678 -32
View File
@@ -11,33 +11,287 @@ comments: true
The two functions below both calculate $1 + 2 + \dots + n$ (assume $n \ge 1$). Set `n` to 4,
answer the questions by following the program's actual execution order, and then compare the efficiency of the two approaches.
```python
def sum_iter(n):
s = 0
for i in range(1, n + 1):
s += i
return s
=== "Python"
def sum_recur(n):
if n == 1:
return 1
return n + sum_recur(n - 1)
```
```python title="complexity_exercises.py"
def sum_iter(n: int) -> int:
"""Iterative summation"""
res = 0
for i in range(1, n + 1):
res += i
return res
def sum_recur(n: int) -> int:
"""Recursive summation"""
if n == 1:
return 1
return n + sum_recur(n - 1)
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* Iterative summation */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; ++i) {
res += i;
}
return res;
}
/* Recursive summation */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Java"
```java title="complexity_exercises.java"
/* Iterative summation */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Recursive summation */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* Iterative summation */
int SumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Recursive summation */
int SumRecur(int n) {
if (n == 1) {
return 1;
}
return n + SumRecur(n - 1);
}
```
=== "Go"
```go title="complexity_exercises.go"
/* Iterative summation */
func sumIter(n int) int {
res := 0
for i := 1; i <= n; i++ {
res += i
}
return res
}
/* Recursive summation */
func sumRecur(n int) int {
if n == 1 {
return 1
}
return n + sumRecur(n-1)
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* Iterative summation */
func sumIter(n: Int) -> Int {
var res = 0
for i in 1 ... n {
res += i
}
return res
}
/* Recursive summation */
func sumRecur(n: Int) -> Int {
if n == 1 {
return 1
}
return n + sumRecur(n: n - 1)
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* Iterative summation */
function sumIter(n) {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Recursive summation */
function sumRecur(n) {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* Iterative summation */
function sumIter(n: number): number {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Recursive summation */
function sumRecur(n: number): number {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* Iterative summation */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Recursive summation */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* Iterative summation */
fn sum_iter(n: i32) -> i32 {
let mut res = 0;
for i in 1..=n {
res += i;
}
res
}
/* Recursive summation */
fn sum_recur(n: i32) -> i32 {
if n == 1 {
return 1;
}
n + sum_recur(n - 1)
}
```
=== "C"
```c title="complexity_exercises.c"
/* Iterative summation */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Recursive summation */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* Iterative summation */
fun sumIter(n: Int): Int {
var res = 0
for (i in 1..n) {
res += i
}
return res
}
/* Recursive summation */
fun sumRecur(n: Int): Int {
if (n == 1) {
return 1
}
return n + sumRecur(n - 1)
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### Iterative summation ###
def sum_iter(n)
res = 0
for i in 1..n
res += i
end
res
end
### Recursive summation ###
def sum_recur(n)
return 1 if n == 1
n + sum_recur(n - 1)
end
```
<!-- numbered-subquestions -->
1. When `sum_iter(4)` runs, what is the value of `s` after each loop iteration?
2. When `sum_recur(4)` runs, which function calls occur in order? As the calls return from the deepest level, how is the result obtained?
1. When the iterative function runs with `n = 4`, what is the value of the accumulator `res` after each loop iteration?
2. When the recursive function runs with `n = 4`, which values does the argument `n` take in order? As the calls return from the deepest level, how is the result obtained?
3. What are the time and space complexities of the two approaches? Explain your reasoning using the execution processes from Questions 1 and 2.
??? success "Answer"
1. The loop variable `i` takes the values `1, 2, 3, 4`. After each iteration, `s` becomes
`1, 3, 6, 10`, respectively, so `sum_iter(4)` returns 10.
1. The loop variable `i` takes the values `1, 2, 3, 4`. After each iteration, `res` becomes
`1, 3, 6, 10`, respectively, so the iterative function returns 10.
2. The function calls occur in this order:
`sum_recur(4) → sum_recur(3) → sum_recur(2) → sum_recur(1)`.
`sum_recur(1)` returns 1. The remaining calls then obtain `2 + 1 = 3`, `3 + 3 = 6`, and `4 + 6 = 10`, in that order.
2. The argument `n` takes the values `4 → 3 → 2 → 1`.
The deepest call returns 1. The remaining calls then obtain `2 + 1 = 3`, `3 + 3 = 6`, and `4 + 6 = 10`, in that order.
At the deepest point, all four function calls are still unfinished.
3. Both functions perform a number of loop iterations or calls proportional to $n$, so both have a time complexity of $O(n)$.
@@ -51,22 +305,414 @@ def sum_recur(n):
Each of the following code fragments takes a positive integer $n$ as input. Order them from lowest to highest time complexity, and give the complexity of each one.
```python
# Fragment 1
s = 0
for i in range(n):
s += i
=== "Python"
# Fragment 2
s = 0
for i in range(n):
for j in range(i, n):
s += j
```python title="complexity_exercises.py"
def linear_loop(n: int) -> int:
"""Linear loop"""
res = 0
for i in range(n):
res += i
return res
# Fragment 3
while n > 1:
n = n // 2
```
def quadratic_loop(n: int) -> int:
"""Quadratic loop"""
res = 0
for i in range(n):
for j in range(i, n):
res += j
return res
def logarithmic_loop(n: int) -> int:
"""Logarithmic loop"""
while n > 1:
n //= 2
return n
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* Linear loop */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
res += i;
}
return res;
}
/* Quadratic loop */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
res += j;
}
}
return res;
}
/* Logarithmic loop */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Java"
```java title="complexity_exercises.java"
/* Linear loop */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Quadratic loop */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Logarithmic loop */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* Linear loop */
int LinearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Quadratic loop */
int QuadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Logarithmic loop */
int LogarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Go"
```go title="complexity_exercises.go"
/* Linear loop */
func linearLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
res += i
}
return res
}
/* Quadratic loop */
func quadraticLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
for j := i; j < n; j++ {
res += j
}
}
return res
}
/* Logarithmic loop */
func logarithmicLoop(n int) int {
for n > 1 {
n /= 2
}
return n
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* Linear loop */
func linearLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
res += i
}
return res
}
/* Quadratic loop */
func quadraticLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
for j in i ..< n {
res += j
}
}
return res
}
/* Logarithmic loop */
func logarithmicLoop(n: Int) -> Int {
var n = n
while n > 1 {
n /= 2
}
return n
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* Linear loop */
function linearLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Quadratic loop */
function quadraticLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Logarithmic loop */
function logarithmicLoop(n) {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* Linear loop */
function linearLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Quadratic loop */
function quadraticLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Logarithmic loop */
function logarithmicLoop(n: number): number {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* Linear loop */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Quadratic loop */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Logarithmic loop */
int logarithmicLoop(int n) {
while (n > 1) {
n ~/= 2;
}
return n;
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* Linear loop */
fn linear_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
res += i;
}
res
}
/* Quadratic loop */
fn quadratic_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
for j in i..n {
res += j;
}
}
res
}
/* Logarithmic loop */
fn logarithmic_loop(mut n: i32) -> i32 {
while n > 1 {
n /= 2;
}
n
}
```
=== "C"
```c title="complexity_exercises.c"
/* Linear loop */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Quadratic loop */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Logarithmic loop */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* Linear loop */
fun linearLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
res += i
}
return res
}
/* Quadratic loop */
fun quadraticLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
for (j in i until n) {
res += j
}
}
return res
}
/* Logarithmic loop */
fun logarithmicLoop(n: Int): Int {
var value = n
while (value > 1) {
value /= 2
}
return value
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### Linear loop ###
def linear_loop(n)
res = 0
for i in 0...n
res += i
end
res
end
### Quadratic loop ###
def quadratic_loop(n)
res = 0
for i in 0...n
for j in i...n
res += j
end
end
res
end
### Logarithmic loop ###
def logarithmic_loop(n)
n /= 2 while n > 1
n
end
```
??? success "Answer"
en/docs/chapter_divide_and_conquer/exercises.md
+205 -12
View File
@@ -29,23 +29,216 @@ Classify each task as "suitable for divide and conquer," "can use divide and con
The recursive function below uses divide and conquer to calculate $x^n$:
```python
def fast_pow(x, n):
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "Python"
Use it to calculate `fast_pow(3, 5)`:
```python title="fast_power.py"
def fast_pow(x: int, n: int) -> int:
"""Exponentiation by squaring"""
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "C++"
```cpp title="fast_power.cpp"
/* Exponentiation by squaring */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Java"
```java title="fast_power.java"
/* Exponentiation by squaring */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "C#"
```csharp title="fast_power.cs"
/* Exponentiation by squaring */
int FastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = FastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Go"
```go title="fast_power.go"
/* Exponentiation by squaring */
func fastPow(x, n int) int {
if n == 0 {
return 1
}
half := fastPow(x, n/2)
if n%2 == 0 {
return half * half
}
return half * half * x
}
```
=== "Swift"
```swift title="fast_power.swift"
/* Exponentiation by squaring */
func fastPow(x: Int, n: Int) -> Int {
if n == 0 {
return 1
}
let half = fastPow(x: x, n: n / 2)
if n % 2 == 0 {
return half * half
}
return half * half * x
}
```
=== "JS"
```javascript title="fast_power.js"
/* Exponentiation by squaring */
function fastPow(x, n) {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "TS"
```typescript title="fast_power.ts"
/* Exponentiation by squaring */
function fastPow(x: number, n: number): number {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "Dart"
```dart title="fast_power.dart"
/* Exponentiation by squaring */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n ~/ 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Rust"
```rust title="fast_power.rs"
/* Exponentiation by squaring */
fn fast_pow(x: i32, n: i32) -> i32 {
if n == 0 {
return 1;
}
let half = fast_pow(x, n / 2);
if n % 2 == 0 {
return half * half;
}
half * half * x
}
```
=== "C"
```c title="fast_power.c"
/* Exponentiation by squaring */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Kotlin"
```kotlin title="fast_power.kt"
/* Exponentiation by squaring */
fun fastPow(x: Int, n: Int): Int {
if (n == 0) {
return 1
}
val half = fastPow(x, n / 2)
if (n % 2 == 0) {
return half * half
}
return half * half * x
}
```
=== "Ruby"
```ruby title="fast_power.rb"
### Exponentiation by squaring ###
def fast_pow(x, n)
return 1 if n == 0
half = fast_pow(x, n / 2)
return half * half if n.even?
half * half * x
end
```
Set `x = 3` and `n = 5`, and use this function to calculate the result:
<!-- numbered-subquestions -->
1. As the recursive calls proceed, which values does the argument `n` take in order?
2. Starting from the deepest call, what value does each level return?
3. Why should the result be stored in `half` instead of writing `fast_pow(x, n // 2)` twice?
3. Why should the recursive result be stored in `half` instead of calling the same subproblem once on each side of the multiplication?
??? success "Answer"
@@ -54,7 +247,7 @@ Use it to calculate `fast_pow(3, 5)`:
2. When `n = 0`, the function returns 1. When `n = 1`, it returns $1×1×3=3$.
When `n = 2`, it returns $3×3=9$. When `n = 5`, it returns $9×9×3=243$.
3. If `fast_pow(x, n // 2)` were written once on each side of the multiplication, the two recursive calls would calculate exactly the same subproblem.
3. If the same subproblem were called once on each side of the multiplication, the two recursive calls would perform exactly the same calculation.
Storing the result in `half` means that each level makes only one recursive call, so the recursion depth is about $\log n$.
Making two calls would cause a great deal of repeated computation.
ja/docs/chapter_computational_complexity/exercises.md
+678 -32
View File
@@ -11,33 +11,287 @@ comments: true
次の 2 つのコードは、どちらも $1 + 2 + \dots + n$ を計算します（$n \ge 1$ とします）。`n` を 4 として、
プログラムが実際に実行される順序に沿って次の問いに答え、2 つの書き方の効率を比較してください。
```python
def sum_iter(n):
s = 0
for i in range(1, n + 1):
s += i
return s
=== "Python"
def sum_recur(n):
if n == 1:
return 1
return n + sum_recur(n - 1)
```
```python title="complexity_exercises.py"
def sum_iter(n: int) -> int:
"""反復による総和"""
res = 0
for i in range(1, n + 1):
res += i
return res
def sum_recur(n: int) -> int:
"""再帰による総和"""
if n == 1:
return 1
return n + sum_recur(n - 1)
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* 反復による総和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; ++i) {
res += i;
}
return res;
}
/* 再帰による総和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Java"
```java title="complexity_exercises.java"
/* 反復による総和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 再帰による総和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* 反復による総和 */
int SumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 再帰による総和 */
int SumRecur(int n) {
if (n == 1) {
return 1;
}
return n + SumRecur(n - 1);
}
```
=== "Go"
```go title="complexity_exercises.go"
/* 反復による総和 */
func sumIter(n int) int {
res := 0
for i := 1; i <= n; i++ {
res += i
}
return res
}
/* 再帰による総和 */
func sumRecur(n int) int {
if n == 1 {
return 1
}
return n + sumRecur(n-1)
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* 反復による総和 */
func sumIter(n: Int) -> Int {
var res = 0
for i in 1 ... n {
res += i
}
return res
}
/* 再帰による総和 */
func sumRecur(n: Int) -> Int {
if n == 1 {
return 1
}
return n + sumRecur(n: n - 1)
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* 反復による総和 */
function sumIter(n) {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 再帰による総和 */
function sumRecur(n) {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* 反復による総和 */
function sumIter(n: number): number {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 再帰による総和 */
function sumRecur(n: number): number {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* 反復による総和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 再帰による総和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* 反復による総和 */
fn sum_iter(n: i32) -> i32 {
let mut res = 0;
for i in 1..=n {
res += i;
}
res
}
/* 再帰による総和 */
fn sum_recur(n: i32) -> i32 {
if n == 1 {
return 1;
}
n + sum_recur(n - 1)
}
```
=== "C"
```c title="complexity_exercises.c"
/* 反復による総和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 再帰による総和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* 反復による総和 */
fun sumIter(n: Int): Int {
var res = 0
for (i in 1..n) {
res += i
}
return res
}
/* 再帰による総和 */
fun sumRecur(n: Int): Int {
if (n == 1) {
return 1
}
return n + sumRecur(n - 1)
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### 反復による総和 ###
def sum_iter(n)
res = 0
for i in 1..n
res += i
end
res
end
### 再帰による総和 ###
def sum_recur(n)
return 1 if n == 1
n + sum_recur(n - 1)
end
```
<!-- numbered-subquestions -->
1. `sum_iter(4)` を実行すると、各ループの終了時に変数 `s` はそれぞれいくつになりますか？
2. `sum_recur(4)` を実行すると、どの関数が順に呼び出されますか？最も深い呼び出しから戻るとき、結果はどのように求められますか？
1. `n = 4` を入力して反復関数を実行すると、各ループの終了時に累積変数 `res` はそれぞれいくつになりますか？
2. `n = 4` を入力して再帰関数を実行すると、引数 `n` はどの値を順に取りますか？最も深い呼び出しから戻るとき、結果はどのように求められますか？
3. 2 つの書き方の時間計算量と空間計算量は、それぞれいくつですか？問い 1、2 の実行過程と結び付けて理由を説明してください。
??? success "解答"
1. ループ変数 `i` は `1、2、3、4` の順に変化し、各ループの終了時に `s` は
`1、3、6、10` となります。したがって、`sum_iter(4)` は 10 を返します。
1. ループ変数 `i` は `1、2、3、4` の順に変化し、各ループの終了時に `res` は
`1、3、6、10` となります。したがって、反復関数は 10 を返します。
2. 関数は
`sum_recur(4) → sum_recur(3) → sum_recur(2) → sum_recur(1)` の順に呼び出されます。
`sum_recur(1)` が 1 を返した後、各呼び出しは順に `2 + 1 = 3`、`3 + 3 = 6`、`4 + 6 = 10` を得ます。
2. 引数 `n` は `4 → 3 → 2 → 1` の順に変化します。
最も深い呼び出しが 1 を返した後、各呼び出しは順に `2 + 1 = 3`、`3 + 3 = 6`、`4 + 6 = 10` を得ます。
最も深い呼び出しに到達した時点では、4 回の関数呼び出しはどれもまだ終了していません。
3. どちらのコードも、$n$ に比例する回数のループまたは呼び出しを行うため、時間計算量はともに $O(n)$ です。
@@ -51,22 +305,414 @@ def sum_recur(n):
次の 3 つのコード片はいずれも、正の整数 $n$ を入力とします。時間計算量が小さい順に並べ、それぞれの計算量を書いてください。
```python
# コード片 1
s = 0
for i in range(n):
s += i
=== "Python"
# コード片 2
s = 0
for i in range(n):
for j in range(i, n):
s += j
```python title="complexity_exercises.py"
def linear_loop(n: int) -> int:
"""線形時間のループ"""
res = 0
for i in range(n):
res += i
return res
# コード片 3
while n > 1:
n = n // 2
```
def quadratic_loop(n: int) -> int:
"""二次時間のループ"""
res = 0
for i in range(n):
for j in range(i, n):
res += j
return res
def logarithmic_loop(n: int) -> int:
"""対数時間のループ"""
while n > 1:
n //= 2
return n
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* 線形時間のループ */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
res += i;
}
return res;
}
/* 二次時間のループ */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
res += j;
}
}
return res;
}
/* 対数時間のループ */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Java"
```java title="complexity_exercises.java"
/* 線形時間のループ */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 二次時間のループ */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 対数時間のループ */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* 線形時間のループ */
int LinearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 二次時間のループ */
int QuadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 対数時間のループ */
int LogarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Go"
```go title="complexity_exercises.go"
/* 線形時間のループ */
func linearLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
res += i
}
return res
}
/* 二次時間のループ */
func quadraticLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
for j := i; j < n; j++ {
res += j
}
}
return res
}
/* 対数時間のループ */
func logarithmicLoop(n int) int {
for n > 1 {
n /= 2
}
return n
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* 線形時間のループ */
func linearLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
res += i
}
return res
}
/* 二次時間のループ */
func quadraticLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
for j in i ..< n {
res += j
}
}
return res
}
/* 対数時間のループ */
func logarithmicLoop(n: Int) -> Int {
var n = n
while n > 1 {
n /= 2
}
return n
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* 線形時間のループ */
function linearLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 二次時間のループ */
function quadraticLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 対数時間のループ */
function logarithmicLoop(n) {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* 線形時間のループ */
function linearLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 二次時間のループ */
function quadraticLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 対数時間のループ */
function logarithmicLoop(n: number): number {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* 線形時間のループ */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 二次時間のループ */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 対数時間のループ */
int logarithmicLoop(int n) {
while (n > 1) {
n ~/= 2;
}
return n;
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* 線形時間のループ */
fn linear_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
res += i;
}
res
}
/* 二次時間のループ */
fn quadratic_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
for j in i..n {
res += j;
}
}
res
}
/* 対数時間のループ */
fn logarithmic_loop(mut n: i32) -> i32 {
while n > 1 {
n /= 2;
}
n
}
```
=== "C"
```c title="complexity_exercises.c"
/* 線形時間のループ */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 二次時間のループ */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 対数時間のループ */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* 線形時間のループ */
fun linearLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
res += i
}
return res
}
/* 二次時間のループ */
fun quadraticLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
for (j in i until n) {
res += j
}
}
return res
}
/* 対数時間のループ */
fun logarithmicLoop(n: Int): Int {
var value = n
while (value > 1) {
value /= 2
}
return value
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### 線形時間のループ ###
def linear_loop(n)
res = 0
for i in 0...n
res += i
end
res
end
### 二次時間のループ ###
def quadratic_loop(n)
res = 0
for i in 0...n
for j in i...n
res += j
end
end
res
end
### 対数時間のループ ###
def logarithmic_loop(n)
n /= 2 while n > 1
n
end
```
??? success "解答"
ja/docs/chapter_divide_and_conquer/exercises.md
+205 -12
View File
@@ -29,23 +29,216 @@ comments: true
次の再帰関数は、分割統治を使って $x^n$ を計算します。
```python
def fast_pow(x, n):
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "Python"
この関数で `fast_pow(3, 5)` を計算します。
```python title="fast_power.py"
def fast_pow(x: int, n: int) -> int:
"""高速べき乗"""
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "C++"
```cpp title="fast_power.cpp"
/* 高速べき乗 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Java"
```java title="fast_power.java"
/* 高速べき乗 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "C#"
```csharp title="fast_power.cs"
/* 高速べき乗 */
int FastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = FastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Go"
```go title="fast_power.go"
/* 高速べき乗 */
func fastPow(x, n int) int {
if n == 0 {
return 1
}
half := fastPow(x, n/2)
if n%2 == 0 {
return half * half
}
return half * half * x
}
```
=== "Swift"
```swift title="fast_power.swift"
/* 高速べき乗 */
func fastPow(x: Int, n: Int) -> Int {
if n == 0 {
return 1
}
let half = fastPow(x: x, n: n / 2)
if n % 2 == 0 {
return half * half
}
return half * half * x
}
```
=== "JS"
```javascript title="fast_power.js"
/* 高速べき乗 */
function fastPow(x, n) {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "TS"
```typescript title="fast_power.ts"
/* 高速べき乗 */
function fastPow(x: number, n: number): number {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "Dart"
```dart title="fast_power.dart"
/* 高速べき乗 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n ~/ 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Rust"
```rust title="fast_power.rs"
/* 高速べき乗 */
fn fast_pow(x: i32, n: i32) -> i32 {
if n == 0 {
return 1;
}
let half = fast_pow(x, n / 2);
if n % 2 == 0 {
return half * half;
}
half * half * x
}
```
=== "C"
```c title="fast_power.c"
/* 高速べき乗 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Kotlin"
```kotlin title="fast_power.kt"
/* 高速べき乗 */
fun fastPow(x: Int, n: Int): Int {
if (n == 0) {
return 1
}
val half = fastPow(x, n / 2)
if (n % 2 == 0) {
return half * half
}
return half * half * x
}
```
=== "Ruby"
```ruby title="fast_power.rb"
### 高速べき乗 ###
def fast_pow(x, n)
return 1 if n == 0
half = fast_pow(x, n / 2)
return half * half if n.even?
half * half * x
end
```
`x = 3`、`n = 5` として、この関数で結果を計算します。
<!-- numbered-subquestions -->
1. 再帰呼び出しでは、引数 `n` はどのような値に順に変わりますか？
2. 最も深い呼び出しから戻るとき、各呼び出しはどの値を順に返しますか？
3. `fast_pow(x, n // 2)` を 2 回書くのではなく、先に `half` へ保存するのはなぜですか？
3. 同じ部分問題を乗算の両側で 1 回ずつ呼び出すのではなく、再帰結果を先に `half` へ保存するのはなぜですか？
??? success "解答"
@@ -54,7 +247,7 @@ def fast_pow(x, n):
2. `n = 0` のとき 1 を返します。`n = 1` のとき $1×1×3=3$、
`n = 2` のとき $3×3=9$、`n = 5` のとき $9×9×3=243$ を返します。
3. 乗算の両側に `fast_pow(x, n // 2)` を 1 回ずつ書くと、2 つの再帰呼び出しがまったく同じ部分問題を計算します。
3. 同じ部分問題を乗算の両側で 1 回ずつ呼び出すと、2 つの再帰呼び出しがまったく同じ計算を行います。
結果を先に `half` へ保存すれば、各層で再帰するのは 1 回だけとなり、再帰の深さは約 $\log n$ です。
2 回呼び出すと、大量の重複計算が発生します。
ru/docs/chapter_computational_complexity/exercises.md
+678 -32
View File
@@ -11,33 +11,287 @@ comments: true
Обе функции ниже вычисляют $1 + 2 + \dots + n$ (считайте, что $n \ge 1$). Присвойте `n` значение 4,
ответьте на вопросы в порядке фактического выполнения программы, а затем сравните эффективность двух вариантов.
```python
def sum_iter(n):
s = 0
for i in range(1, n + 1):
s += i
return s
=== "Python"
def sum_recur(n):
if n == 1:
return 1
return n + sum_recur(n - 1)
```
```python title="complexity_exercises.py"
def sum_iter(n: int) -> int:
"""Итеративное суммирование"""
res = 0
for i in range(1, n + 1):
res += i
return res
def sum_recur(n: int) -> int:
"""Рекурсивное суммирование"""
if n == 1:
return 1
return n + sum_recur(n - 1)
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* Итеративное суммирование */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; ++i) {
res += i;
}
return res;
}
/* Рекурсивное суммирование */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Java"
```java title="complexity_exercises.java"
/* Итеративное суммирование */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Рекурсивное суммирование */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* Итеративное суммирование */
int SumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Рекурсивное суммирование */
int SumRecur(int n) {
if (n == 1) {
return 1;
}
return n + SumRecur(n - 1);
}
```
=== "Go"
```go title="complexity_exercises.go"
/* Итеративное суммирование */
func sumIter(n int) int {
res := 0
for i := 1; i <= n; i++ {
res += i
}
return res
}
/* Рекурсивное суммирование */
func sumRecur(n int) int {
if n == 1 {
return 1
}
return n + sumRecur(n-1)
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* Итеративное суммирование */
func sumIter(n: Int) -> Int {
var res = 0
for i in 1 ... n {
res += i
}
return res
}
/* Рекурсивное суммирование */
func sumRecur(n: Int) -> Int {
if n == 1 {
return 1
}
return n + sumRecur(n: n - 1)
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* Итеративное суммирование */
function sumIter(n) {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Рекурсивное суммирование */
function sumRecur(n) {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* Итеративное суммирование */
function sumIter(n: number): number {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Рекурсивное суммирование */
function sumRecur(n: number): number {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* Итеративное суммирование */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Рекурсивное суммирование */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* Итеративное суммирование */
fn sum_iter(n: i32) -> i32 {
let mut res = 0;
for i in 1..=n {
res += i;
}
res
}
/* Рекурсивное суммирование */
fn sum_recur(n: i32) -> i32 {
if n == 1 {
return 1;
}
n + sum_recur(n - 1)
}
```
=== "C"
```c title="complexity_exercises.c"
/* Итеративное суммирование */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* Рекурсивное суммирование */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* Итеративное суммирование */
fun sumIter(n: Int): Int {
var res = 0
for (i in 1..n) {
res += i
}
return res
}
/* Рекурсивное суммирование */
fun sumRecur(n: Int): Int {
if (n == 1) {
return 1
}
return n + sumRecur(n - 1)
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### Итеративное суммирование ###
def sum_iter(n)
res = 0
for i in 1..n
res += i
end
res
end
### Рекурсивное суммирование ###
def sum_recur(n)
return 1 if n == 1
n + sum_recur(n - 1)
end
```
<!-- numbered-subquestions -->
1. Какие значения принимает переменная `s` после каждой итерации при выполнении `sum_iter(4)`?
2. Какие функции поочередно вызываются при выполнении `sum_recur(4)`? Как формируется результат при возврате, начиная с самого глубокого вызова?
1. Какие значения принимает переменная-аккумулятор `res` после каждой итерации при выполнении итеративной функции с `n = 4`?
2. Какие значения поочередно принимает параметр `n` при выполнении рекурсивной функции с `n = 4`? Как формируется результат при возврате, начиная с самого глубокого вызова?
3. Каковы временная и пространственная сложности каждого варианта? Обоснуйте ответ, опираясь на процессы выполнения из вопросов 1 и 2.
??? success "Ответ"
1. Переменная цикла `i` поочередно принимает значения `1, 2, 3, 4`, а `s` после каждой итерации становится равной
`1, 3, 6, 10`. Поэтому `sum_iter(4)` возвращает 10.
1. Переменная цикла `i` поочередно принимает значения `1, 2, 3, 4`, а `res` после каждой итерации становится равной
`1, 3, 6, 10`. Поэтому итеративная функция возвращает 10.
2. Функции вызываются в следующем порядке:
`sum_recur(4) → sum_recur(3) → sum_recur(2) → sum_recur(1)`.
`sum_recur(1)` возвращает 1, после чего следующие уровни поочередно получают `2 + 1 = 3`, `3 + 3 = 6` и `4 + 6 = 10`.
2. Параметр `n` принимает значения `4 → 3 → 2 → 1`.
Самый глубокий вызов возвращает 1, после чего следующие уровни поочередно получают `2 + 1 = 3`, `3 + 3 = 6` и `4 + 6 = 10`.
В самой глубокой точке все 4 вызова функции еще не завершены.
3. В обеих функциях число итераций или вызовов пропорционально $n$, поэтому их временная сложность равна $O(n)$.
@@ -51,22 +305,414 @@ def sum_recur(n):
Во всех трех фрагментах кода входные данные — положительное целое число $n$. Расположите фрагменты в порядке возрастания временной сложности и укажите сложность каждого из них.
```python
# Фрагмент 1
s = 0
for i in range(n):
s += i
=== "Python"
# Фрагмент 2
s = 0
for i in range(n):
for j in range(i, n):
s += j
```python title="complexity_exercises.py"
def linear_loop(n: int) -> int:
"""Цикл линейной сложности"""
res = 0
for i in range(n):
res += i
return res
# Фрагмент 3
while n > 1:
n = n // 2
```
def quadratic_loop(n: int) -> int:
"""Цикл квадратичной сложности"""
res = 0
for i in range(n):
for j in range(i, n):
res += j
return res
def logarithmic_loop(n: int) -> int:
"""Цикл логарифмической сложности"""
while n > 1:
n //= 2
return n
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* Цикл линейной сложности */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
res += i;
}
return res;
}
/* Цикл квадратичной сложности */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
res += j;
}
}
return res;
}
/* Цикл логарифмической сложности */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Java"
```java title="complexity_exercises.java"
/* Цикл линейной сложности */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Цикл квадратичной сложности */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Цикл логарифмической сложности */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* Цикл линейной сложности */
int LinearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Цикл квадратичной сложности */
int QuadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Цикл логарифмической сложности */
int LogarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Go"
```go title="complexity_exercises.go"
/* Цикл линейной сложности */
func linearLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
res += i
}
return res
}
/* Цикл квадратичной сложности */
func quadraticLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
for j := i; j < n; j++ {
res += j
}
}
return res
}
/* Цикл логарифмической сложности */
func logarithmicLoop(n int) int {
for n > 1 {
n /= 2
}
return n
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* Цикл линейной сложности */
func linearLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
res += i
}
return res
}
/* Цикл квадратичной сложности */
func quadraticLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
for j in i ..< n {
res += j
}
}
return res
}
/* Цикл логарифмической сложности */
func logarithmicLoop(n: Int) -> Int {
var n = n
while n > 1 {
n /= 2
}
return n
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* Цикл линейной сложности */
function linearLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Цикл квадратичной сложности */
function quadraticLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Цикл логарифмической сложности */
function logarithmicLoop(n) {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* Цикл линейной сложности */
function linearLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Цикл квадратичной сложности */
function quadraticLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Цикл логарифмической сложности */
function logarithmicLoop(n: number): number {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* Цикл линейной сложности */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Цикл квадратичной сложности */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Цикл логарифмической сложности */
int logarithmicLoop(int n) {
while (n > 1) {
n ~/= 2;
}
return n;
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* Цикл линейной сложности */
fn linear_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
res += i;
}
res
}
/* Цикл квадратичной сложности */
fn quadratic_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
for j in i..n {
res += j;
}
}
res
}
/* Цикл логарифмической сложности */
fn logarithmic_loop(mut n: i32) -> i32 {
while n > 1 {
n /= 2;
}
n
}
```
=== "C"
```c title="complexity_exercises.c"
/* Цикл линейной сложности */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* Цикл квадратичной сложности */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* Цикл логарифмической сложности */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* Цикл линейной сложности */
fun linearLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
res += i
}
return res
}
/* Цикл квадратичной сложности */
fun quadraticLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
for (j in i until n) {
res += j
}
}
return res
}
/* Цикл логарифмической сложности */
fun logarithmicLoop(n: Int): Int {
var value = n
while (value > 1) {
value /= 2
}
return value
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### Цикл линейной сложности ###
def linear_loop(n)
res = 0
for i in 0...n
res += i
end
res
end
### Цикл квадратичной сложности ###
def quadratic_loop(n)
res = 0
for i in 0...n
for j in i...n
res += j
end
end
res
end
### Цикл логарифмической сложности ###
def logarithmic_loop(n)
n /= 2 while n > 1
n
end
```
??? success "Ответ"
ru/docs/chapter_divide_and_conquer/exercises.md
+205 -12
View File
@@ -29,23 +29,216 @@ comments: true
Рекурсивная функция ниже вычисляет $x^n$ методом «разделяй и властвуй»:
```python
def fast_pow(x, n):
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "Python"
Функция вызывается как `fast_pow(3, 5)`.
```python title="fast_power.py"
def fast_pow(x: int, n: int) -> int:
"""Быстрое возведение в степень"""
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "C++"
```cpp title="fast_power.cpp"
/* Быстрое возведение в степень */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Java"
```java title="fast_power.java"
/* Быстрое возведение в степень */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "C#"
```csharp title="fast_power.cs"
/* Быстрое возведение в степень */
int FastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = FastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Go"
```go title="fast_power.go"
/* Быстрое возведение в степень */
func fastPow(x, n int) int {
if n == 0 {
return 1
}
half := fastPow(x, n/2)
if n%2 == 0 {
return half * half
}
return half * half * x
}
```
=== "Swift"
```swift title="fast_power.swift"
/* Быстрое возведение в степень */
func fastPow(x: Int, n: Int) -> Int {
if n == 0 {
return 1
}
let half = fastPow(x: x, n: n / 2)
if n % 2 == 0 {
return half * half
}
return half * half * x
}
```
=== "JS"
```javascript title="fast_power.js"
/* Быстрое возведение в степень */
function fastPow(x, n) {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "TS"
```typescript title="fast_power.ts"
/* Быстрое возведение в степень */
function fastPow(x: number, n: number): number {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "Dart"
```dart title="fast_power.dart"
/* Быстрое возведение в степень */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n ~/ 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Rust"
```rust title="fast_power.rs"
/* Быстрое возведение в степень */
fn fast_pow(x: i32, n: i32) -> i32 {
if n == 0 {
return 1;
}
let half = fast_pow(x, n / 2);
if n % 2 == 0 {
return half * half;
}
half * half * x
}
```
=== "C"
```c title="fast_power.c"
/* Быстрое возведение в степень */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Kotlin"
```kotlin title="fast_power.kt"
/* Быстрое возведение в степень */
fun fastPow(x: Int, n: Int): Int {
if (n == 0) {
return 1
}
val half = fastPow(x, n / 2)
if (n % 2 == 0) {
return half * half
}
return half * half * x
}
```
=== "Ruby"
```ruby title="fast_power.rb"
### Быстрое возведение в степень ###
def fast_pow(x, n)
return 1 if n == 0
half = fast_pow(x, n / 2)
return half * half if n.even?
half * half * x
end
```
Задайте `x = 3` и `n = 5`, затем вычислите результат с помощью этой функции.
<!-- numbered-subquestions -->
1. Какие значения последовательно принимает параметр `n` при рекурсивных вызовах?
2. Какие значения поочередно возвращаются на каждом уровне, начиная с самого глубокого?
3. Почему результат нужно сначала сохранить в `half`, а не дважды записывать `fast_pow(x, n // 2)`?
3. Почему результат рекурсии нужно сначала сохранить в `half`, а не вызывать одну и ту же подзадачу по одному разу с каждой стороны умножения?
??? success "Ответ"
@@ -54,7 +247,7 @@ def fast_pow(x, n):
2. При `n = 0` возвращается 1; при `n = 1` возвращается $1×1×3=3$;
при `n = 2` — $3×3=9$; при `n = 5` — $9×9×3=243$.
3. Если записать `fast_pow(x, n // 2)` по обе стороны умножения, два рекурсивных вызова будут решать одну и ту же подзадачу.
3. Если вызвать одну и ту же подзадачу по одному разу с каждой стороны умножения, два рекурсивных вызова выполнят одинаковые вычисления.
Когда результат сохраняется в `half`, на каждом уровне выполняется только один рекурсивный вызов, а глубина рекурсии составляет примерно $\log n$;
два вызова привели бы к множеству повторных вычислений.
zh-hant/docs/chapter_computational_complexity/exercises.md
+678 -32
View File
@@ -11,33 +11,287 @@ comments: true
下面兩段程式碼都計算 $1 + 2 + \dots + n$（設 $n \ge 1$）。請把 `n` 設為 4，
按照程式實際執行的順序回答問題，然後比較兩種寫法的效率。
```python
def sum_iter(n):
s = 0
for i in range(1, n + 1):
s += i
return s
=== "Python"
def sum_recur(n):
if n == 1:
return 1
return n + sum_recur(n - 1)
```
```python title="complexity_exercises.py"
def sum_iter(n: int) -> int:
"""迭代求和"""
res = 0
for i in range(1, n + 1):
res += i
return res
def sum_recur(n: int) -> int:
"""遞迴求和"""
if n == 1:
return 1
return n + sum_recur(n - 1)
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* 迭代求和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; ++i) {
res += i;
}
return res;
}
/* 遞迴求和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Java"
```java title="complexity_exercises.java"
/* 迭代求和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 遞迴求和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* 迭代求和 */
int SumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 遞迴求和 */
int SumRecur(int n) {
if (n == 1) {
return 1;
}
return n + SumRecur(n - 1);
}
```
=== "Go"
```go title="complexity_exercises.go"
/* 迭代求和 */
func sumIter(n int) int {
res := 0
for i := 1; i <= n; i++ {
res += i
}
return res
}
/* 遞迴求和 */
func sumRecur(n int) int {
if n == 1 {
return 1
}
return n + sumRecur(n-1)
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* 迭代求和 */
func sumIter(n: Int) -> Int {
var res = 0
for i in 1 ... n {
res += i
}
return res
}
/* 遞迴求和 */
func sumRecur(n: Int) -> Int {
if n == 1 {
return 1
}
return n + sumRecur(n: n - 1)
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* 迭代求和 */
function sumIter(n) {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 遞迴求和 */
function sumRecur(n) {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* 迭代求和 */
function sumIter(n: number): number {
let res = 0;
for (let i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 遞迴求和 */
function sumRecur(n: number): number {
if (n === 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* 迭代求和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 遞迴求和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* 迭代求和 */
fn sum_iter(n: i32) -> i32 {
let mut res = 0;
for i in 1..=n {
res += i;
}
res
}
/* 遞迴求和 */
fn sum_recur(n: i32) -> i32 {
if n == 1 {
return 1;
}
n + sum_recur(n - 1)
}
```
=== "C"
```c title="complexity_exercises.c"
/* 迭代求和 */
int sumIter(int n) {
int res = 0;
for (int i = 1; i <= n; i++) {
res += i;
}
return res;
}
/* 遞迴求和 */
int sumRecur(int n) {
if (n == 1) {
return 1;
}
return n + sumRecur(n - 1);
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* 迭代求和 */
fun sumIter(n: Int): Int {
var res = 0
for (i in 1..n) {
res += i
}
return res
}
/* 遞迴求和 */
fun sumRecur(n: Int): Int {
if (n == 1) {
return 1
}
return n + sumRecur(n - 1)
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### 迭代求和 ###
def sum_iter(n)
res = 0
for i in 1..n
res += i
end
res
end
### 遞迴求和 ###
def sum_recur(n)
return 1 if n == 1
n + sum_recur(n - 1)
end
```
<!-- numbered-subquestions -->
1. 執行 `sum_iter(4)` 時，每輪迴圈結束後，變數 `s` 的值分別是多少？
2. 執行 `sum_recur(4)` 時，會依次呼叫哪些函式？從最深的一層開始返回時，結果怎樣得到？
1. 輸入 `n = 4` 執行迭代函式時，每輪迴圈結束後，累加變數 `res` 的值分別是多少？
2. 輸入 `n = 4` 執行遞迴函式時，參數 `n` 會依次取哪些值？從最深的一層開始返回時，結果怎樣得到？
3. 兩種寫法的時間複雜度和空間複雜度分別是多少？結合第 1、2 問的執行過程說明理由。
??? success "參考答案"
1. 迴圈變數 `i` 依次為 `1、2、3、4`，每輪結束後，`s` 依次變為
`1、3、6、10`，所以 `sum_iter(4)` 返回 10。
1. 迴圈變數 `i` 依次為 `1、2、3、4`，每輪結束後，`res` 依次變為
`1、3、6、10`，所以迭代函式返回 10。
2. 函式依次呼叫
`sum_recur(4) → sum_recur(3) → sum_recur(2) → sum_recur(1)`。
`sum_recur(1)` 返回 1，隨後各層依次得到 `2 + 1 = 3`、`3 + 3 = 6`、`4 + 6 = 10`。
2. 參數 `n` 依次為 `4 → 3 → 2 → 1`。
最深一層返回 1，隨後各層依次得到 `2 + 1 = 3`、`3 + 3 = 6`、`4 + 6 = 10`。
在最深處，4 次函式呼叫都尚未結束。
3. 兩段程式碼都進行與 $n$ 成正比的迴圈或呼叫，因此時間複雜度均為 $O(n)$ 。
@@ -51,22 +305,414 @@ def sum_recur(n):
以下三個程式碼片段的輸入均為正整數 $n$ 。請按時間複雜度從低到高排序，並寫出各自的複雜度。
```python
# 片段一
s = 0
for i in range(n):
s += i
=== "Python"
# 片段二
s = 0
for i in range(n):
for j in range(i, n):
s += j
```python title="complexity_exercises.py"
def linear_loop(n: int) -> int:
"""線性階迴圈"""
res = 0
for i in range(n):
res += i
return res
# 片段三
while n > 1:
n = n // 2
```
def quadratic_loop(n: int) -> int:
"""平方階迴圈"""
res = 0
for i in range(n):
for j in range(i, n):
res += j
return res
def logarithmic_loop(n: int) -> int:
"""對數階迴圈"""
while n > 1:
n //= 2
return n
```
=== "C++"
```cpp title="complexity_exercises.cpp"
/* 線性階迴圈 */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
res += i;
}
return res;
}
/* 平方階迴圈 */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
res += j;
}
}
return res;
}
/* 對數階迴圈 */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Java"
```java title="complexity_exercises.java"
/* 線性階迴圈 */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方階迴圈 */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 對數階迴圈 */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "C#"
```csharp title="complexity_exercises.cs"
/* 線性階迴圈 */
int LinearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方階迴圈 */
int QuadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 對數階迴圈 */
int LogarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Go"
```go title="complexity_exercises.go"
/* 線性階迴圈 */
func linearLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
res += i
}
return res
}
/* 平方階迴圈 */
func quadraticLoop(n int) int {
res := 0
for i := 0; i < n; i++ {
for j := i; j < n; j++ {
res += j
}
}
return res
}
/* 對數階迴圈 */
func logarithmicLoop(n int) int {
for n > 1 {
n /= 2
}
return n
}
```
=== "Swift"
```swift title="complexity_exercises.swift"
/* 線性階迴圈 */
func linearLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
res += i
}
return res
}
/* 平方階迴圈 */
func quadraticLoop(n: Int) -> Int {
var res = 0
for i in 0 ..< n {
for j in i ..< n {
res += j
}
}
return res
}
/* 對數階迴圈 */
func logarithmicLoop(n: Int) -> Int {
var n = n
while n > 1 {
n /= 2
}
return n
}
```
=== "JS"
```javascript title="complexity_exercises.js"
/* 線性階迴圈 */
function linearLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方階迴圈 */
function quadraticLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 對數階迴圈 */
function logarithmicLoop(n) {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "TS"
```typescript title="complexity_exercises.ts"
/* 線性階迴圈 */
function linearLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方階迴圈 */
function quadraticLoop(n: number): number {
let res = 0;
for (let i = 0; i < n; i++) {
for (let j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 對數階迴圈 */
function logarithmicLoop(n: number): number {
while (n > 1) {
n = Math.floor(n / 2);
}
return n;
}
```
=== "Dart"
```dart title="complexity_exercises.dart"
/* 線性階迴圈 */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方階迴圈 */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 對數階迴圈 */
int logarithmicLoop(int n) {
while (n > 1) {
n ~/= 2;
}
return n;
}
```
=== "Rust"
```rust title="complexity_exercises.rs"
/* 線性階迴圈 */
fn linear_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
res += i;
}
res
}
/* 平方階迴圈 */
fn quadratic_loop(n: i32) -> i32 {
let mut res = 0;
for i in 0..n {
for j in i..n {
res += j;
}
}
res
}
/* 對數階迴圈 */
fn logarithmic_loop(mut n: i32) -> i32 {
while n > 1 {
n /= 2;
}
n
}
```
=== "C"
```c title="complexity_exercises.c"
/* 線性階迴圈 */
int linearLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
res += i;
}
return res;
}
/* 平方階迴圈 */
int quadraticLoop(int n) {
int res = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
res += j;
}
}
return res;
}
/* 對數階迴圈 */
int logarithmicLoop(int n) {
while (n > 1) {
n /= 2;
}
return n;
}
```
=== "Kotlin"
```kotlin title="complexity_exercises.kt"
/* 線性階迴圈 */
fun linearLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
res += i
}
return res
}
/* 平方階迴圈 */
fun quadraticLoop(n: Int): Int {
var res = 0
for (i in 0 until n) {
for (j in i until n) {
res += j
}
}
return res
}
/* 對數階迴圈 */
fun logarithmicLoop(n: Int): Int {
var value = n
while (value > 1) {
value /= 2
}
return value
}
```
=== "Ruby"
```ruby title="complexity_exercises.rb"
### 線性階迴圈 ###
def linear_loop(n)
res = 0
for i in 0...n
res += i
end
res
end
### 平方階迴圈 ###
def quadratic_loop(n)
res = 0
for i in 0...n
for j in i...n
res += j
end
end
res
end
### 對數階迴圈 ###
def logarithmic_loop(n)
n /= 2 while n > 1
n
end
```
??? success "參考答案"
zh-hant/docs/chapter_divide_and_conquer/exercises.md
+205 -12
View File
@@ -29,23 +29,216 @@ comments: true
下面的遞迴函式用分治計算 $x^n$：
```python
def fast_pow(x, n):
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "Python"
用它計算 `fast_pow(3, 5)`：
```python title="fast_power.py"
def fast_pow(x: int, n: int) -> int:
"""快速冪"""
if n == 0:
return 1
half = fast_pow(x, n // 2)
if n % 2 == 0:
return half * half
return half * half * x
```
=== "C++"
```cpp title="fast_power.cpp"
/* 快速冪 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Java"
```java title="fast_power.java"
/* 快速冪 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "C#"
```csharp title="fast_power.cs"
/* 快速冪 */
int FastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = FastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Go"
```go title="fast_power.go"
/* 快速冪 */
func fastPow(x, n int) int {
if n == 0 {
return 1
}
half := fastPow(x, n/2)
if n%2 == 0 {
return half * half
}
return half * half * x
}
```
=== "Swift"
```swift title="fast_power.swift"
/* 快速冪 */
func fastPow(x: Int, n: Int) -> Int {
if n == 0 {
return 1
}
let half = fastPow(x: x, n: n / 2)
if n % 2 == 0 {
return half * half
}
return half * half * x
}
```
=== "JS"
```javascript title="fast_power.js"
/* 快速冪 */
function fastPow(x, n) {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "TS"
```typescript title="fast_power.ts"
/* 快速冪 */
function fastPow(x: number, n: number): number {
if (n === 0) {
return 1;
}
const half = fastPow(x, Math.floor(n / 2));
if (n % 2 === 0) {
return half * half;
}
return half * half * x;
}
```
=== "Dart"
```dart title="fast_power.dart"
/* 快速冪 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n ~/ 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Rust"
```rust title="fast_power.rs"
/* 快速冪 */
fn fast_pow(x: i32, n: i32) -> i32 {
if n == 0 {
return 1;
}
let half = fast_pow(x, n / 2);
if n % 2 == 0 {
return half * half;
}
half * half * x
}
```
=== "C"
```c title="fast_power.c"
/* 快速冪 */
int fastPow(int x, int n) {
if (n == 0) {
return 1;
}
int half = fastPow(x, n / 2);
if (n % 2 == 0) {
return half * half;
}
return half * half * x;
}
```
=== "Kotlin"
```kotlin title="fast_power.kt"
/* 快速冪 */
fun fastPow(x: Int, n: Int): Int {
if (n == 0) {
return 1
}
val half = fastPow(x, n / 2)
if (n % 2 == 0) {
return half * half
}
return half * half * x
}
```
=== "Ruby"
```ruby title="fast_power.rb"
### 快速冪 ###
def fast_pow(x, n)
return 1 if n == 0
half = fast_pow(x, n / 2)
return half * half if n.even?
half * half * x
end
```
令 `x = 3`、`n = 5`，用這個函式計算：
<!-- numbered-subquestions -->
1. 遞迴呼叫時，參數 `n` 依次變成哪些值？
2. 從最深層開始返回時，各層依次返回什麼值？
3. 為什麼要先儲存 `half`，而不是把 `fast_pow(x, n // 2)` 寫兩遍？
3. 為什麼要先把遞迴結果儲存為 `half`，而不是在乘法兩邊各呼叫一次相同的子問題？
??? success "參考答案"
@@ -54,7 +247,7 @@ def fast_pow(x, n):
2. `n = 0` 時返回 1；`n = 1` 時返回 $1×1×3=3$；
`n = 2` 時返回 $3×3=9$；`n = 5` 時返回 $9×9×3=243$。
3. 如果把 `fast_pow(x, n // 2)` 在乘法兩邊各寫一次，兩次遞迴會計算完全相同的子問題。
3. 如果在乘法兩邊各呼叫一次相同的子問題，兩次遞迴會進行完全相同的計算。
先把結果儲存為 `half`，每層就只遞迴一次，遞迴深度約為 $\log n$；
呼叫兩次會造成大量重複計算。