Algorithm Basic

This is only for quick revision for syntax. If you want to know deeper, please refer to class ppt or other online tutorials.

Key Points

Pseudocode

Operators

Arithmetic operators:

Relational operators:
= equal to             < smaller than               > greater than

>= greater than or equal to     <= smaller than or equal to     <> not equal to

Logical operators:

AND  OR  NOT

if & elseif & else

structure:

if <condition>
    <statement>
elseif <coindition>
    <statement>
else
    <statement>
endif 

example:

Declare A: integer
A ← -3
if A>0
    output 'positive'
elseif A=0
    output 'zero'
else
    output 'negative'
endif


result>>>negative

– there can be no, one or multiple elseif(s)

– end with endif

Nested-if: if-loop contains another if-loop

 if <condition>
    if <condition>
        <statement>
    else
        if <condition>
            <statement>
        else
            <statement>
        endif
           ······ 

Case

structure:

case of <variable>
    <condition1>:<statement1>
    <condition2>:<statement2>
    otherwise:<statement3>
endcase

example:

declare Score: integer
input Score
case of Score:
    0: output 'You Lose'
    100: output 'You Win'
endcase 

– no restriction on the number of conditions

– ends with endcase

for

structure:

 for <condition>
    <statement>
endfor

example:

declare A: integer
for A ← 1 to 5
    output A
endfor


result>>> 
1
2
3
4
5 

– ands with endfor

skip / step

example:

for A ← 1 to 10 skip 2
    output A
endfor


result>>>
1
3
5
7
9

for B ← 100 to 10 skip -20
    output B
endfor


result>>>
100
80
60
40
20 

while

structure:

 while <condition>
    <statement>
endwhile 

example:

declare i: integer
i ← 1
while i <= 5
    output i
    i ← i + 1
endwhile


result>>>
1
2
3
4
5 

– pre-condition loop: when the condition is False, terminate the loop; loop might not be executed at all (if the condition is False in the first place)

– ends with endwhile

repeat…until

structure:

repeat
    <statement>
until <condition> 

example:

declare i: integer
i ← 1
repeat
    output i
    i ← i+1
until i = 5


result>>>
1
2
3
4 

– post-condition loop:：when condition is True, terminate the loop; loop will be at least executed once

declaration of an array:

declare <name>: array [lower bound,upper bound] of <data type>

e.g.

traversing the array:

declare i: integer
for i ← 0 to 99
    input Marks[i]
endfor 

assign value：

Marks[2] ← 89

– one Array may only contain one datatype（ int / real / bool / str )

– efficient linear search: once found, come out of the loop

2D Array

declaration of  a 2D array:

declare <name>: array [lower bound1..upper bound1,lower bound2..upperbound2] of <data type>

e.g.

to initialize (to 0 in this case)

#row-by-row traversal
for r ← 0 to 3
    for c ← 0 to 9
        Num[r][c] ← 0


#col-by-col traversal
for c ← 0 to 9
    for r ← 0 to 3
        Num[r][c] ← 0 

– transpose: convert row into column and column into row

procedure

structure:

#procedure header 
procedure <name>(<parameter1>:<datatype>,<parameter2>:<datatype>)

#procedure call 
call <name>(<value1>,<value2>)

example:

#procedure definition
procedure Add(a:integer,b:integer)
    declare c: integer
    c ← a+b
    output c
endprocedure

#procedure call
call Add(21,35)


result>>>
56 

definition syntax:

procedure <name>(<parameter>:<datatype>[])

e.g.

procedure Add(ThisArray: string[])

– ends with endprocedure

– use call to execute procedure

– not restriction on number of parameters

function

structure:

#function header 
function <name>(<parameter>:<datatype>,<parameter>:<datatype>) : returns <datatype>

example:

#function definition
function Add(a:integer, b:integer): returns integer
    declare c: integer
    c ← a + b
    return c
endfunction

#function call
declare c: integer
c ← call Add(51,75)
output c


result>>>
126 

definition syntax:

function <name>(<parameter>:<datatype>[]):  returns <datatype>

e.g.

function Add(ThisArray: string[]): returns integer

– ends with endfunction

– datatype of returned value must be specified

– return value of the call can be directly assigned to variable

Python

operators

Arithmetic operators:

+ plus (or concat strings)   – minus

* multiply                                   / divide

** exponent                              % get divide reminder

// integer divide

e.g. 5%2=1

5//2=2

Relational operators:

== equals           > greater than             < smaller than

>= greater than or equal to      < smaller than or equal to    != not equal to

Logical operators:

and   or   not

if & elif & else

Use colons (“:”) to start python blocks, and “endxxx” is not necessary

structure:

if <condition>:
    <statement>
elif <condition>:
    <statement>
else:
    <statement>

example:

a=-3
if a > 0:
     print('positive')
elif a==0:
     print('zero')
else:
     print('negative')
result>>>
positive 

– there may be no, one or multiple elif(s)

nested-if: if that contains one or multiple other if(s)

if <condition>:
    if <condition>:
        <statement>
    else:
        if <condition>:
            <statement>
        else:
            <statement>
        ......

for

structure:

for <condition>:
     <statement>

example:

for a in range (1,5):
      print(a)

result>>>
1
2
3
4
5

while

structure:

while <condition> and <condition>:
      <statement>
      <statement>

example:

i=0
while i < 5:
     print(i)
     i=i+1

result>>>
0
1
2
3
4
5

– while loop will not automatically manipulate the counter variable

function

structure:

def FunctionName(parameter):
     body_of_function
     return ... 

example:

def add(a,b):
      return a+b
print(add(3,5))


result>>>
8

procedure

structure:

def ProcedureName(parameter):
     body_of_procedure

example:

def add(a,b):
      print(add(a,b)) 
add(3,5)


result>>>
8

– function must return a value，procedure doesn’t return any value

– function and procedure can be used in a program for multiple times

list

# empty list
list = []
# init with values (can contain mixed types) list = [1, "eels"] # get item by index
list = [1, 2, 3, 4, 5, 6]
list[0]  # 1
list[-1]  # 6

2-dimensional list

list = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

list[0][1]  # 2
list[2][2]  # 9
list[-1][2]  # 9