CS1010 AY21/22 S1 Lecture 8

class: middle, center

# Lecture 8

### 11 October 2021

.smaller[
Admin Matters<br>
Unit 19: **Multi-D Arrays**<br>
Unit 20: **C Preprocessor**<br>
Unit 21: **Efficiency**<br>
]
---
class: middle

### Assignment 5

- Due Tuesday night (23:59)
- Graded on correctness (including syntax, practices, approach, and logic), style, and documentation.

---
class: middle

### Tutorial 7

- Problem Sets 19-21

### Lab 7

- Assignments 5-6
- Exercises 8-9

---
class: middle

### Midterm Results

- Expect Announcements in 1-2 Days
- Solution/Analysis on Piazza 
- Your "Script" in Email

---
class: middle,wide
<table width=100% height=100%>
	<tr valign="top">
		<th style="border-right:solid 1px">
		<h5 style="margin:0px";>
			Problem Solving
		</h5>
	    </th>
		<th style="border-right:solid 1px">
		<h5 style="margin:0px";>
			C Language & Syntax
		</h5>
	    </th>
		<th style="border-right:solid 1px">
		<h5 style="margin:0px";>
			Behaviorial Model
		</h5>
	    </th>
		<th>
		<h5 style="margin:0px";>
			Tools & Practices
		</h5>
	    </th>
	</tr>
	<tr valign="top">
	<td style="border-right:solid 1px; border-bottom:none;">
		<ul style="margin:1px;font-size:70%;">
		<li>decomposition
		<li>recursion
		<li>flowchart
		<li>conditionals
		<li>assertions
		<li>loops
		<li>invariants
		<li><font color="pink">efficiency</font>
		</ul>
	</td>
	<td style="border-right:solid 1px; border-bottom:none;">
		<ul style="margin:1px;font-size:70%;">
		<li>types 
		<li>functions 
		<li>arithmetic ops 
		<li>if-else
		<li>logical expressions
		<li>loops
		<li>1D arrays
		<li>pointers
		<li>memory management
		<li><font color="pink">nD arrays</font>
		<li><font color="pink">preprocessor</font>
		</ul>
	</td>
	<td style="border-right:solid 1px; border-bottom:none;">
		<ul style="margin:1px;font-size:70%;">
		<li>machine code
		<li>data in memory
		<li>types
		<li>call stack
		<li>memory addr
		<li>call by value/ref
		<li>heap
		</ul>
	</td>
	<td style="border-bottom:none;">
		<ul style="margin:1px;font-size:70%;">
		<li>clang
		<li>vim
		<li>bash
		<li>style
		<li>docs
		</ul>
	</td>
	</tr>
</table>
---
class: middle,center
## Multi-dimensional Arrays

---
class: middle

```C
long matrix[10][20];
  :
matrix[i][j] = max[i][j] + 4;
```

---
class: middle

`matrix[i]` is an array and decays to `&matrix[i][0]`

`&matrix[i][0]` is a pointer to a `long`.

---
class: middle

`matrix` is an array and decays to `&matrix[0]`

`&matrix[0]` is a pointer to an array of 20 `long` values.

---
class: middle, top

```C
long (*a)[20];
```

---
class: middle

Passing a 2D array into a function:

.tiny[
```C
void foo(size_t nrows, size_t ncols, long matrix[10][20]) { .. }
void foo(size_t nrows, size_t ncols, long matrix[nrows][20]) { .. }
void foo(size_t nrows, size_t ncols, long matrix[][20]) { .. }
void foo(size_t nrows, size_t ncols, long (*matrix)[20]) { .. }
```
]

---
class: middle,wide

`long (*a)[20];` vs `long *(a[20])` vs `long *a[20]`

---
class: middle

### Recap

![compilation](figures/c-compile-run-dark/c-compile-run-dark.001.png)

---
class: middle

### Preprocessor

![compilation](figures/c-compile-run-dark/c-compile-run-dark.002.png)

---
class: middle, center

# Efficiency

---
class: middle, center

## 1. No Redundant Work

---
class: middle

.tiny[
```C
bool is_prime(long n)
{
  bool is_prime = true;
  for (long i = 2; i <= n - 1; i += 1) {
    if (n % i == 0) {
      is_prime = false;
    }
  }
  return is_prime;
}
```
]

---
class: middle

.tiny[
```C
bool is_prime(long n)
{
  for (long i = 2; i <= sqrt(n); i++) {
    if (n % i == 0) {
      return false;
    }
  }
  return true;
}
```
]
---
class: middle

- Return `false` as soon as we know n is not a prime
- Not checking for divisor that is redundant

What if n is a prime?
---
class: middle

## 2. No Duplication

---
class: middle

$$range(L, k) = |max(L, k) - min(L, k)|$$

We have to go through the list twice.

---
class: middle

.tiny[
```C
void find_min_max(long len, long array[], 
			      long *min, long *max)
{
  :
}
```
]

We can combine both loops into one.

---
class:middle
.tiny[
```C
long fib(long n)
{
  if (n == 1 || n == 2) {
    return 1;
  }
  long first = 1;
  long second = 1;
  long third = 2;
  for (long i = 2; i <= n; i += 1) {
    first = second;
    second = third;
    third = first + second;
  }
  return third;
}
```
]
---
class:middle
.tiny[
```C
long fib(long n)
{
  if (n == 1 || n == 2) {
    return 1;
  }
  return fib(n-1) + fib(n-2);
}
```
]

---
class:top,center

how many times is fib() called?

---
class: middle

how many steps (in terms on n)?

.moretiny[
```C
long fib(long n)
{
  if (n == 1 || n == 2) {
    return 1;
  }
  long first = 1;
  long second = 1;
  long third = 2;
  for (long i = 2; i != n; i += 1) {
    first = second;
    second = third;
    third = first + second;
  }
  return third;
}
```
]

---
class:middle,center

$$O\left(\frac{n^4}{10} + 10000n^2 - n\right) = O(n^4)$$

We drop terms with lower rate of growth and multiplicative constant.

---
class: middle

### Comparing Rate of Growth

$f(n)$ grows faster than $g(n)$ if we can find constants $n_0$ and $c$ such that $f(n) > cg(n)$ for all $n \ge n_0$.

---
class: top, center

$f(n) = n^n$ vs. $g(n) = 2^n$

---
class: middle

### Running Time / Time Complexity

- A notion of how efficient an algorithm is
- In CS1010, we are interested in the _worst case_ running time
- Should be expressed in simplest big-O notation with tighest bound

---
class: middle

.tiny[
```C
void selection_sort(long n, long list[])
{
  for (long j = n - 1; j >= 1; j -= 1) {
    long max_pos = max(j, list);
    swap(list, max_pos, j);
  }
}
```
]
---
class: middle,wide

.tiny[
```C
long max(long length, const long list[])
{
  long max_so_far = list[0];
  long max_index = 0;
  for (long i = 1; i <= length; i += 1) {
    if (list[i] > max_so_far) {
      max_so_far = list[i];
      max_index = i;
    }
  }
  return max_index;
}
```
]
---
class:middle
### Finding Fibonacci Numbers

.tiny[
```C
long fib(long n)
{
  if (n == 1 || n == 2) {
    return 1;
  }
  return fib(n-1) + fib(n-2);
}
```
]
---
class:top

---
class:middle
### Run-time analysis is not always trivial

.tiny[
```C
long count_num_of_steps(long n)
{
  long num_of_steps = 0;
  while (n != 1) {
    n = collatz(n);
    num_of_steps += 1;
  }
  return num_of_steps;
}
```
]
---
class:middle
### Time vs Space Complexity

- We only focus on time efficient now.
- Space efficiency is equally important.
- Big O applies to space complexity too.

---
class: bottom

.tiny[
Version: 1.2

Last Updated: Mon Oct 11 02:37:46 +08 2021
]