Pseudocode is a high-level informal way of describing the instructions of a program. The result of writing these instructions for a program using pseudocode is called an Algorithm.

Just to give you a taste, the example below is a program that adds up three numbers 45, 67 and 90.

// prints the sum of 45, 67 and 90

sum <- 45 + 67 + 90
PRINT sum

While the above example is very simple, in practice, we will be involved with more complex algorithms, writing them based on requirements before venturing into analyzing them.

This article will be focused on explaining how we can write algorithms based on what the input and output will be and the task we want performed using the knowledge of pseudocode we will be acquiring from below.

The following are constructs we need to know how to use for us to be able to write algorithms that are correct, readable, easy to understand and analyze.

Note that pseudocode uses a symbolic coding language which can be different for different people. So the syntax that will be defined below is just a variant of the syntax we can have.

• Reserved Keywords
• Operators
• Variables
• Data Types
• Data Structures
• Conditionals
• Iterations or Loops
• Functions

Reserved Keywords

There are some operations we can perform in how program, without having to write some other algorithms. These operations are accessible in our program using Reserved Keywords. Such as for getting input from users, printing output to users, making a function return a value etc.

Below are few common reserved keywords you will be seeing as you go through this article.

READ // Get an input from the user

PRINT // Output data to the user

RETURN // make a function return a value

INCREMENT // Increment a number by 1

DECREMENT // Decrement a number by 1

Note the use of “//” in the above, it is used to start comments, which do not have any effect on the program, they are majorly used for code documentation and explanation for easy understanding.

Operators

There are different types of operator we can use in our programs, which includes the following

Arithmetic Operators

+  : Addition
-  : Subtraction
×  : Multiplication
/  : Division
mod  : Modulo

Comparison Operators

== : Test for equality 
<  : Less than
>  : Greater than
<= : Less than or equal to
>= : Greater than or equal to

Other operators

<-  : Assignment operator
and : Logical and
or  : Logical or

Variables

These are used to hold data temporarily while a program is running. Suppose we create some data at some point in our program, how do we store the data such that we can reference it at another point in our program? Yes !!! We use variables.

Variables have names, but below are things we need to note when naming variables.

• Variable names can only start with an underscore or alphabet
• Variables can only contain underscores, integers and alphabets

Examples of variable names are

name , name123 , _age , gender_field etc.

In pseudocode, we assign data to variables using the assignment operator

name <- "Joe"

gender <- "male"

_age <- 56

prices <- ["$45", "$123", "$900"]

Data Types

Most of the time, basic tasks of a program is usually in data manipulation, where the program takes in some data and spit out another version of the data after been worked on.

However, for us to be able to handle these data properly in our programs, we need a way to represent them. So for this reason, we have the notion of data types which are used to identify the type of a data and give us an understanding of how to deal or relate with the data without causing our program to crash.

Below are primitive data types we will be dealing with…

Numeric Data Types

• Integers : 1, 3485, 100, etc
• Floating point numbers: 1.1, 45.0, 43.35, etc

Other Data Types

• Strings : “hello”, “1233”, “hell12345”, etc.
• Boolean : true , false

Note that what make strings is simply the quotes that wraps the actual content, which can be either single or double.

Data Structures

As we can see from above, these data types are used to describe a single data, but what if we want a collection of these data of different types, how do we do that? This is where the concept of data structures comes in.

Data structures are collection of homogeneous(same) or heterogeneous(different) primitive data types in order to have a single representation of these data.

For instance, a human can have the following properties

• age : Integer
• name : String
• is_baby : Boolean

Having these properties in one place to describe a human will be awesome, say something like

human <- {"age": 50, "name": "John Doe", "is_baby": false}

In the above, the human attributes has been collated in what we call a Data Structure (A structure holding multiple data of different or same data type),

The two data structures we will be talking about here are Array and HashMap.

Note that data structures are simply collections of data and hence they are data themselves. Which means that we can assign them to variables as we do other kinds data.

Basic properties of an array

Create an array using the literal []. Below is an array containing four data(elements) of different data types.

array <- [23, "hello", false, 7.8]

Array items are accessed using their position number called indexes which starts from 0.

PRINT array[0] // gives 23

PRINT array[3] // gives 7.8

PRINT array[4] // raises error

Trying an index outside the range of the size of an array will raise a program error, so we want to be careful when using indexes.

We can as well update the items in an array using the indexes.

array[0] <- 90 // changes 7.8 to 90

array[1] <- false // changes "hello" to false

array[4] <- 80 // raises error

Basic properties of a hash map

An important difference between an array and a hash map, is that arrays uses indexes to identify elements, while hash map uses keys to identify elements.

Create a hash map using the literal {}. Below is a hash map containing two key-value pairs of data.

hash <- { "age": 50, "name": "human" }

Note that the keys are of string data types, so for this article, we will always use string keys as hash map keys. However, the values assigned to these keys can be of any data type.

Similar to an array, elements are accessed using their keys, as in below

PRINT hash["age"] // gives 50

PRINT array["name"] // gives "human"

PRINT array["undefined"] // raises error

Also, trying to use a key not in the hash map raises a program error.

We can as well update the elements in a hash map using the keys,

hash["name"] <- "Jane Doe" // changes "human" to "Jane Doe"

hash["age"] <- 45// changes 50 to 45

array["undefined"] <- 80 // raises error

Conditionals

Conditionals are constructs used in making the decision of when a single or group of instructions should execute.

We use the IF/ELSEIF/ELSE/ENDIF construct for this. Below are examples of how to use this construct.

array <- [1,2,3]

IF 5 in array THEN
   PRINT "Five is in the array"
ELSE
   PRINT "Five is not in the array"
ENDIF

Note that

• Both ELSEIF and ELSE part of the construct are optional
• ELSE must always occur once and last if it is to be present
• We can have multiple ELSEIF, but must come after IF and before ELSE.

age <- 90

IF age >= 50 THEN
   PRINT "Old"
ELSEIF age >= 20 THEN
   PRINT "Adult"
ELSE
   PRINT "Child"
ENDIF

Iterations or Loops

Loops are constructs used in making instructions execute in a repetitively.

We use the FOR/ENDFOR construct for this. Below are examples of how to use this construct.

Looping over a range of numbers

FOR number <- 1 to 10
   PRINT "Executing 10 times"
ENDFOR

Looping over items in an array, where n represent the size of the array

array <- [45, 67, 89, 12, 34]

FOR index <- 0 to n-1   // Here, n = 5
   PRINT array[index]
ENDFOR

Functions

These are used for grouping instructions together to make a program accomplish a particular task.

Defining a function PrintR that prints out numbers from 1 to 20

PrintR()
   FOR number <- 1 to 20
      PRINT number
   ENDFOR

Sometimes, we want to create a function that takes inputs as parameters in order to do some work on them.

Define a function PrintAR that takes an array(arr) and length(n) as parameters, loops through its items and print them out

PrintAR(arr, n)
   FOR index <- 0 to n-1
      PRINT arr[index]
   ENDFOR

Other times, we don’t want to just print out data to the screen for users, we want the function to have a return value which we can store in a variable and use later.

Define a function RetArrSum that takes an array(arr) and length(n) as parameters, loops through its items, sums them up and return the sum.

RetArrSum(arr, n)
   sum <- 0
   
   FOR index <- 0 to n-1
      sum <- sum + arr[index]
   ENDFOR
   
   RETURN sum

Ok, this is awesome !!!

Now, the question is, how do we use these defined functions in our program? Say for instance we have in our program an array with 5 numbers whose sum we need. The program below demonstrates how we can call a function previously defined.

array <- [45, 67, 12, 90, 34]

sum <- RetArrSum(array, 5)

PRINT sum

Note that it make sense for us to assign the RetArrSum function call to sum, because it returns a value. Unlike the PrintAR function which does not return any value but just prints out array items.

Conclusion

These concepts and constructs defined above are used in writing algorithms to be analyzed using the different algorithm analysis techniques.

However, the first step before even trying to analyze any algorithm is to first write it down using pseudocode (Not always true for experts), hence the necessity of this article.

Prerequisite :

https://medium.com/@abdulfataiaka/understanding-big-o-notation-18424089437d

Inexperienced programmers believe that a working program is a good program. However as they become more experienced, they start becoming less concerned about whether the program works or not and become more concerned about the quality of the algorithms that make up the program.

The objective of this article is to present the idea of algorithm analysis in a more granular and less complex and complicated form, understandable by total beginners and inexperienced programmers.

Definition of terms

Algorithm analysis simply has to do deal with getting or computing the complexity of an algorithm

The complexity of an algorithm is simply defined by the amount of resources required for such algorithm to execute completely.

Analyzing the complexity of algorithms is always done with respect to the size or length of the input passed to such algorithms, as what determines the rate at which complexity changes is the input size.

So we can say, the rate of growth complexity is a measure of how the input size changes.

Efficiency of an algorithm

An algorithm is said to be efficient if the rate at which its complexity grows is lesser than the rate at which the input size grows.

When some algorithms executes when passed input of small size, the execute very fast and use minimal amount of resources. However if the input size is increased, the complexity of these algorithm grows, which means that we cannot conclude that an algorithm is efficient just because it behaves best when the input size is small.

So for this reason we introduce the three different cases we can have when analyzing algorithms so we can get reliable and satisfying result about the behaviour of algorithms.

A case of an algorithm describes the scenarios where the amount of resources consumed is at its

• Minimum : Best case
• Maximum : Worst Case
• Average : Average Case

The most important one of these cases is the “Worst case scenario”, as this is usually a safe way of deciding if an algorithm is efficient or not when compared to other algorithms, with the constraint that the same input is passed to all algorithms been compared.

There are different tools and approaches we can use to compute the complexity of an algorithm. However, the commonly used one is the Big O Notation.

An algorithm that has a worst case complexity of O(n²) is said to be less efficient when compared to that another algorithm of complexity O(n), with the same input passed to both algorithms.

Similarly, an algorithm that has a best case complexity of O(log n) is better in efficiency than that with best case complexity of O(n).

So moving forwards, we will be using the Big O Notation in expressing our complexities.

Complexities

The complexities of algorithms is can be categorized by the kind of consumable resource we want to consider, such as time and space, hence the terms “Time Complexity” and “Space Complexity”.

In summary, the time complexity (Also called Running Time) is a measure of the amount of computation steps It takes an algorithm to execute with respect to its input size, while the Space complexity is a measure of the amount of memory space it takes for an algorithm to execute also with respect to its input size.

A little bit on time complexity

We can classify time complexity into the following based on the type of expression we pass to Big O, while using Big O Notation to express complexity.

• Constant : O(1)
• Linear : O(n)
• Quadratic : O(n²)
• Cubic : O(n³)
• Logarithmic : O(log n)
• Quasilinear : O(n log n)
• Exponential : O(2^n)

So, when we say the time complexity of an algorithm is Logrithmic, we mean that the rate of growth of the amount of computation steps required with respect to the rate of growth of the input size is O(log n).

If we pay attention, we will noticed that in order to be able to express the complexity of an algorithm using the Big O Notation, we will first need to express it as a mathematical function, so we can extract the highest ordered term which we will pass to Big O.

Below are upcoming articles that talks more on these complexities in details

• Running time function T(x) of an algorithm
• Time complexity of an algorithm
• Space complexity of an algorithm

The purpose of this article is to introduce some basic Mathematics concepts that will aid the understanding of Big O Notation and make it easy to grasp the concept introduced in my next article about complexity of algorithms, see link at the bottom.

My target viewers are beginners or inexperienced programmers probably with no background of Mathematics but wishes to understand the concept of complexity in algorithm analysis.

Some of the topics I will cover in this article includes

• Polynomials
• Logarithms
• Exponentials
• Equations
• Functions
• Growth of functions
• Big O Notation

Polynomials

These are mathematical expressions that usually have just one unknown variable (usually represented by symbols or alphabets), with a particular degree or order.

The degree or order of a polynomial expression is the highest power with which the unknown variable is raised.

Examples

• 3x² + 4x + 1
• 4y - 1

The first example is an polynomial expression of degree 2 with the unknown variable been “x”, while the second is a polynomial expression of degree 1 with the unknown been “y”.

Summary Note

• Expressions can be seen as combination of other expressions, as in example one above. 3x² and 4x are also expressions on their own. However, when they are brought together to form a compound expression, we refer to them individually as terms of the expression.
• The number directly in front of a term is called the coefficient of the term. So for example, 3 is the coefficient of term 3x². Note that only terms with an unknown variable will have coefficient.
• Any number standing alone in an expression is referred to as the constant of the expression.
• An unknown without a power is seen to have power 1, that is why 4y - 1 is of degree 1.

Using the degree of a polynomial expression, we can categorize these expressions into the following

• Linear : Degree 1
• Quadratic : Degree 2
• Cubic : Degree 3
• And so on…

There are different operations we can perform on polynomial expressions, which includes but not limited to addition, subtraction, multiplication, etc.

However, addition and subtraction operations are carried out similar-term wise. That is, performing the operation 4x + 1 will not yield any result as the terms “4x” and “1” are not similar.

Terms are said to be similar if and only if they have the same unknown variable of same power. e.g “4x” is not similar to “4x²”, while “5x²” is similar to “9x²”.

For example,

Lets add 4x + 1 and 5x + 2, then we do (4x +5x) and then (1 +2) as these are terms that are similar, so we get 9x + 3.

I won’t further on explaining these operations in this article so as to not go out of scope. So, endeavour to check out examples of these other operations.

Logarithms

The logarithm of a number is that which describes the power to which a fixed number will be raised to produce a given number.

The above is simply a mathematical way of expressing the definition above. So combining the two, we say

• The number we want to get/produce is “x”
• The fixed number to be raised to some power is “b”
• The power that “b” will be raised to is “y”

Logarithm depends on the different number systems. What differentiates these systems is the maximum number allowed in the system and the way operations are carried out in them.

These number systems all have base value that ranges from 2 upwards. A number system with base value of two is called base 2 number system or binary number system, and that with base value of 3 is called base 3 number system and so on.

The maximum number allowed in number system is one less than its base value. Hence the binary number system will only allow numbers 0 and 1, while base 10 number system allows numbers 0 through 9.

So, what will be the range of numbers allowed by the base 16 number system?

Exponentials

An exponent is simply an expression or a term (when in other expressions) which is a combination of a base and a power. i.e

In the above, the unknown at the bottom “b” is the base of the exponent, while the one at the top “x” is called the power of the exponent. Usually, “b” is set to a fixed value(or number).

Suppose we equate the above expression to a value, what do we call it then? Exponential equation? Correct!

Note that what you call an equation depends on the type of expression you are equating to some value.

Equations

Simply put, equations are expressions equated to some value or some other expression. Hence, if we equate “x⁵ + 1” to 56, then we have “x⁵ + 1 = 56”, which is a polynomial equation of order 5.

Hence when a linear expression is equated to some value, we get a linear equation and so on for other types of expressions.

Functions

In a layman term, a function is some variable to which an expression is assigned. We usually represent a function using either an unknown or variable (e.g “y”) or an unknown with the unknown of the expression it is equated to passed to it. e.g “f(x)”

Example

• y = x² + x + 1
• f(x) = x — 1
• g(y) = y³ +8

Note in the above examples, y, f(x) and g(y) are the representation of functions. Since the functions are unknowns, then we now have two unknowns making up the equation of these functions.

However, you would notice that for us to be able to get the value of y, f(x) or g(y) we need to first know the value of the unknowns in the expressions assigned to them, meaning that y, f(x) and g(y) are dependent on the unknowns in their respective assigned expressions.

So because of this, we refer to y, f(x) and g(y) as dependent variables while the unknowns in expressions they are assigned to are referred to as independent variables.

Growth of functions

Understanding how to analyse functions in terms of growth makes it easy to understand the complexity of algorithms using the big O notation.

The growth of an expression is determined only by the order or degree of the highest ordered term in an expression.

The highest ordered term of the below expressions are x² and x⁴ respectively

• x² +1
• 9- x⁴ + x²

We do not consider the other terms as they will always grow slower when compared to the highest ordered term.

Also, how does the coefficient of that highest ordered term affect its growth?The coefficient of “x²” in example one above is 1, does it mean that if we change such coefficient to some big value, the rate of growth will be affected? No. The rate at which “x²” grows will also be approximately the same as the rate at which “100x²” grows.

Now considering the function function “y = x² + x + 1”, how do we measure its growth? Simple…

As we can see that the expression to the right has its highest ordered term to be “x²”, so the equation interprets into the below

The rate at which the function “y” grows will always be lesser or approximately equal to the rate at which “x²” grows, that is “y” can never grow at a rate greater than “x²”.

So in short, we say the rate of growth of “y” is the rate of growth of “x²”.

Big O Notation

The Big O Notation is simply a mathematical statement used in expressing the rate of growth of an expression in terms of the highest ordered term as explained above.

So with consideration to the function “y = x² + x + 1”, we can simply say the expression “x² + x + 1” is O(x²). Nice!

But if the rate of growth of function “y” is the rate of growth of “x² + x + 1” as explained above, which is in turn O(x²), then the rate if growth of “y” is also O(x²). Hence “y” is O(x²).

So we say the function “y” cannot grow at a rate faster than O(x²).

Continue studying about algorithms by following the link below, which introduces you to algorithm analysis using the knowledge acquired in this article.

After minutes of watching the video provided for us on the topic “Adaptability” at Andela bootcamp, I came to understand some important facts about having such as part of one’s skill set.

So what is Adaptability ?

Adaptability is the ability of adjusting to new conditions in order to achieve set objectives. People always have the choice of adjusting to new changes or pushing back on these changes. But it will be worth it to mention few importance of adaptability in one’s day to day activities, some of them include …

Easily integrates with teams

Adaptability enables someone to easily work with other members in his team and also make him welcome new members to the team without having the slightest thinking of how to cope and collaborate with these new members. This enables the team to progress and achieve their set goal in a short period.

Acquiring new experiences

For someone that is used to a particular way of doing some things, and he is introduced to a new way that might be more efficient than the approach he knows, provided this individual is ready to accept the new changes that might come by, definitely new experiences will be acquired and such a person would have gotten a step closer to been an expert in doing such things. This is one of the key benefit of adaptability as no knowledge gained is a waste, that in turns add more to the person in question and make him a better person at what he is into.

Becoming a driver of changes

Adaptability enables a person to understand and know when changes are required and to initiate changes when they are needed, in a situation where other members of a team are not seeing the need for change or are afraid to push for changes due to their lack of adaptability, the one with such attribute will not be swayed by the complexity of the changes that might come up, and because he knows the benefits of accepting changes, he will definitely push for it in order for the set goals to be achievable.

So what are the behaviors one must possess in other to be seen as someone that adapts to changes?

Firstly, one should have open mind towards challenges and feedback, be it positive or negative ones that might come from other people.

Becoming emotionally agile is another, as been bias is a factor that can come into decision making at some point, and someone that is emotionally agile will not be bias in making decision even if its going to affect him as he knows that the progress of the project been worked on is far above him.

Lastly the person will be able to identify changes and take the necessary steps to ensure the change is implement and the project is moved some step to completion.

My most recent challenging learning experience was originally published in Aka Abdulfatai Olalekan on Medium, where people are continuing the conversation by highlighting and responding to this story.