#### Transcript CS107: Introduction to Computer Science

## CS107: Introduction to Computer Science

Lecture 2 Jan 29th

• Last time – What is not Computer Science – What is Computer Science – Algorithms, properties and examples • Today – Expressing algorithms: Pseudocode – Examples • Algorithm for adding two m-digit numbers • Algorithm for computing miles-per-gallon

**What is Computer Science?**

The study of

*algorithms*

: – their formal properties • correctness, limits • efficiency/cost (Chapters 2, 3, 10) – their hardware realizations • computer design (Chapters 4-6) – their linguistic realizations • programming languages (Chapters 7-9) – their applications • network design, ocean modeling, bioinformatics, ...

**What is an algorithm?**

Algorithm = well-defined procedure that allows an agent to solve a problem.

Algorithms must: 1. Be well-ordered and unambiguous 2. Be executable (understandable), 3. Solve the problem, and 4. Terminate.

*Note: often the agent is a computer or a robot…*

**Example Algorithms**

• Cooking a dish • Making a peanut-butter jelly sandwich • Shampooing hair • Adding two numbers (p 7) • Programming a VCR (p 6) • Making a pie (p 13)

**Designing Algorithms**

We need: • A

*problem*

for which an effective algorithm can be written (i.e., one that is tractable), • A

*language*

(e.g., “pseudocode” or C++), A

*methodology*

for translating the problem into an algorithm, and • A computing “

*agent*

” that can understand and execute such algorithms.

## Expressing algorithms

• Is natural language good? – For daily life, yes…but for CS is lacks structure and would be hard to follow – Too rich, ambiguous, depends on context • How about a programming language? – Good, but not when we try to solve a problem..we want to think at an abstract level – It shifts the emphasis from how to solve the problem to tedious details of syntax and grammar.

## Pseudocode

• Pseudocode = English but looks like programming • Good compromise – Simple, readable, no rules, don’t worry about punctuation. Lets you think at an abstract level about the problem. – Contains only instructions that have a well-defined structure and resemble programming languages

## Pseudocode elements

Basic (primitive) operations – Read the input from user – Print the output to the user – Cary out basic arithmetical computations • Conditional operations – Execute an operation if a condition is true • Sequential operations • Repeat operations – Execute a block of operation multiple times until a certain condition is met

**Variables**

Variable – A named memory location that can store a value – Think of it as a box into which you can store a value, and from which you can retrieve a value Examples: i carry – List variables: used when the input comes as a list of elements a m-1 a m-2 … a 1 a 0 … a 1 a 2 … a m-1 a m …

**Expression and assignment statements**

Function: change the value of a variable by evaluating arithmetic expressions • can use any arithmetic expression, just like on a typical calculator: +. -. *, /, … Examples

*set the value of m to 2 set the value of i to 6.*

*set the value of carry to i+2*m set the value of a i to 0*

a 1 a 2 … a m-1 a m …

**Input/Output Statements**

Function: transfer values from the user to a variable, or vice versa

*get values for print value of *

• Examples – Get the value of

*n*

from the user – Get value of the list of elements

*a 1 , a 2 , …,a m*

the user – Print the value of

*result*

to the user from

**Sequential statements**

The steps of an algorithm are carried out in the order they are written.

**Conditional statements**

Function: specifying a statement that may or may not be done:

*if then *

Example if the value of

*carry*

is 0 then set the value of a to else set the vale of a to a+1 0

**Loop statements**

Function

*: *

specify a group of statements that may be done several times (repeated):

*repeat until < statements to be repeated >*

• How does this work? – Condition is evaluated – If it is true than the loop terminates and the next instruction to be executed will be the instruction immediately following the loop – If it is false, then the algorithm executes the <

*statements to be repeated> *

in order, one by one

## Example

Step 1: set count to 1 Step 2: repeat step 3 to step 5 until count is > 10 Step 3: set square to count *count Step 4: print value of square and value of count Step 5: add 1 to count Step 6: end • What does this algorithm do? • Note: indentation – Not necessary, but makes reading/understanding algorithms easier

**An example pseudocode algorithm (Fig 1.2)**

Given: m ≥ 1 and two positive numbers a and b, each containing m digits, compute the sum c = a + b.

0 Get values for

*m, a m-1 … a 0*

and

*b m-1 … b 0*

1 Set the value of

*carry*

to

*0*

.

2 Set the value of

*i*

to

*0*

.

3 4 5 Repeat steps 4-6 until i > m-1 Set the value of if

*c i ≥ 10*

then

*c i*

to

*a i + b i + carry*

subtract

*10*

from

*c i*

to

*1*

and set the value of

*carry*

7 8 6 else set the value of

*carry*

to

*0*

Add

*1*

to

*i*

Set the value of

*c m*

to

*carry*

Print value of

*c = c m c m-1 c m-2 … c 0*

**So, how does this work???**

For example, the input is m = 4, a = 3276, and b = 7345.

After step 0, the variables

*m, a*

, and

*b*

have those values: m 4 3 2 7 6 a 3 a 2 a 1 a 0 b 7 3 4 5 3 b 2 b 1 b 0 After steps 1 and 2, the variables

*i*

and

*carry*

are initialized.

i 0 carry 0 Next, steps 4-6 are repeated until the value of

*i > 3*

. Each repetition computes a single digit of

*c*

.

c 4 c 3 c 2 c 1 c 0

**A model for visualizing an algorithm’s behavior**

*Computer Algorithm Input (keyboard) Output (screen) Variables*

**E.g., Visualizing Fig 1.2**

*Computer*

0 Get values for … … 8 Print value of …

*Input (keyboard)*

4 3276 7345 m 4 i 0 carry 3 2 7 6 a 3 a 2 a 1 a 0 7 3 4 5 b 3 b 2 b 1 b 0 0 c 4 c 3 c 2 c 1 c 0

*Output (screen)*

**Another example: computing MPG (Fig 2.5)**

0 1 2 Set

*response*

to “Yes” Repeat steps 2-10 until

*response*

= “No” Get

*gallons*

,

*start*

,

*end*

11 3 4 5 Set

*distance*

to

*end - start*

Set

*mpg*

to

*distance*

÷

*gallons*

Print 6 7 8 9 if

*mpg*

> 25.0 then print “You are getting good gas mileage” else print “You are NOT getting good gas mileage” Print “Do you want to do this again, Yes or No?” 10 Get

*response*

Stop

*mpg*

**So, how does this work???**

For example, suppose we use 25 gallons, beginning at 12000 and ending at 13000 on the odometer. Then, after step 2, some variables have the following values: Yes

*response*

25

*gallons*

12000

*start*

13000

*end*

After step 4, the variables

*distance*

and

*mpg*

are computed.

*distance*

1000

*mpg*

40 Steps 5-9 displays these results on the output screen: 40 You are getting good gas mileage Do you want to do this again, Yes or No?

**Visualizing Fig 2.5**

*Computer*

0 Set response … … 11 Stop

*Input (keyboard)*

25 12000 13000 response Yes gallons start end distance mpg

*Output (screen)*

## Summary

• Pseudocode – Get/print statements (input/output statements) – Conditional statements – Sequential statements – Loops • Algoritms – Compute sum of two m-digit numbers – Compute miles-per-gallon

**Over the weekend…**

1. Get the textbook.

2. Read Chapter 1, 2.1 and 2.2

3. Discuss and solve the problems in the Lab 1 (in groups or individually).

Lab 1 is due on Monday in class. If you have questions we’ll discuss them in class on Monday.

4.

Bring a digital picture for the lab tomorrow. You will need it for your website.