CS1010 AY20/21 S1 Lecture 8

class: middle, center

# Lecture 8

### 12 October 2020

.smaller[
Admin Matters<br>
Unit 20: **C Preprocessor**<br>
Unit 21: **Assert**<br>
Unit 22: **Efficiency**<br>
]
---
class: middle

### Assignment 5

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

---
class: middle

### Tutorial/Lab 7

- Problem Sets 20-22
- Midterm Questions

---
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>arrays
		<li>pointers
		<li>memory management
		<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>documentation
		</ul>
	</td>
	</tr>
</table>
---
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

### Problem 17.1

.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 = 1;
  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 = 1;
  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
double kendall_tau(long n, const long rank[])
{
  long count = 0;
  for (long i = 0; i < n - 1; i += 1) {
    count += count_inversion(i, n, rank);
  }
  return 2.0*count/(n*(n - 1));
}
```
]
---
class: middle,wide

.tiny[
```C
long count_inversion(long i, long n, const long rank[])
{
  long count = 0;
  for (long j = i + 1; j < n; j += 1) {
    if (rank[i] > rank[j]) {
      count ++;
    }
  }
  return count;
}
```
]
---
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 space complexity too.

---
class: bottom

.tiny[
Version: 1.2

Last Updated: Mon Oct 12 10:38:26 +08 2020
]