Analysis of algorithms and performance evaluation can be divided into two different phases:
1) A Priori estimates:
This is a theoretical performance analysis of an algorithm. Efficiency of an algorithm is measured by assuming the external factors.
2) A Posteriori testing:
This is called performance measurement. In this analysis, actual statistics like running time and required for the algorithm executions are collected.

Analysis of algorithms and performance evaluation can be divided into two different phases:
1) A Priori estimates:
This is a theoretical performance analysis of an algorithm. Efficiency of an algorithm is measured by assuming the external factors.
2) A Posteriori testing:
This is called performance measurement. In this analysis, actual statistics like running time and required for the algorithm executions are collected.

The following shows a simple Dynamic programming approach for the generation of Fibonacci series.
Initialize f0 = 0,f1 =1
Step 1 - Print the initial values of Fibonacci f0 and f1
Step 2 - Calculate fibanocci fib \(\leftarrow \) f0+ f1
Step 3 - Assign f0\(\leftarrow \) fl , f1\(\leftarrow \) fib
Step 4 - Print the next consecutive value of fibanocci fib
step 5 - Goto step-2 and repeat until the specified number of terms generated
For example if we generate fibobnacci series upto 10 digits, the algorithm will generate the series as shown below:
The Fibonacci series is : 0 1 1 2 3 5 8 13 21 34 55

Dynamic programming is an algorithmic design method that can be used when the solution to a problem can be viewed as the result of a sequence of decisions. Dynamic Programming approach is similar to divide and conquer.
(i) The given problem will be divided into smaller overlapping sub-problems.
(ii) An optimum solution for the given problem can be achieved by using result of smaller sub-problem.
(iii) Dynamic algorithms uses Memoization.

Step 1 - If it is the first element, it is already sorted.
Step 2 - Pick next element
Step 3 - Compare with all elements in the sorted sub-list
Step 4 - Shift all the elements in the sorted sub-list that is greater than the value to be sorted
Step 5 - Insert the value
Step 6 - Repeat until list is sorted

(i) Start from the first element i.e., index-0, we search the smallest element in the array, and replace it with the element in the first position.
(ii) Now we move on to the second element position, and look for smallest element present in the sub-array, from starting index to till the last index of sub - array.
(iii) Now replace the second smallest identified in step-2 at the second position in the or original array, or also called first position in the sub array.
(iv) This is repeated, until the array is completely sorted.

(i) Start with the first element i.e., index = 0, compare the current element with the next element of the array.
(ii) If the current element is greater than the next element of the array, swap them.
(iii) If the current element is less than the next or right side of the element, move to the next element. Go to Step 1 and repeat until end of the index is reached.

Start with the middle element:
(I) If the search element is equal to the middle element of the array i.e., the middle value = number of elements in array/2, then return the index of the middle element.
(ii) If not, then compare the middle element with the search value,
(iii) If the search element is greater than the number in the middle index, then select the elements to the right side of the middle index, and go to Step-1
(iv) If the search element is less than the number in the middle index, then select the elements to the left side of the middle index, and start with Step-1 ( When a match is found, display success message with the index of the element matched.
(vi) If no match is found for all comparisons, then display unsuccessful message

(i) Traverse the array using 'for loop'
(ii) In every iteration, compare the target search key value with the current value of the list.
(iii) If the values match, display the current index and value of the array
(iv) If the values do not match, move on to the next array element
(v) If no match is found, display the search element not found.

The execution time that you measure in this case would depend on a number of factors such as:
(i) Speed of the machine
(ii) Compiler and other system Software tools
(iii) Operating System
(iv) Programming language used
(v) Volume of data required

The space required by an algorithm is equal to the sum of the following two components: 
(i) A fixed part is defined as the total space required to store certain data and variables for an algorithm. For example, simple variables and constants used in an algorithm.
(ii) A variable part is defined as the total space required by variables, which sizes depends on the problem and its iteration. For example: recursion used to calculate factorial of a given value n.

(i) A space-time or time-memory trade off is a way of solving in less time by using more storage space or by solving a given algorithm in very little space by spending more time.
(ii) To solve a given programming problem, many different algorithms may be used. Some of these algorithms may be extremely time-efficient and others extremely spaceefficient.
(iii) Time/space trade off refers to a situation where you can reduce the use of memory at the cost of slower program execution, or reduce the running time at the cost of increased memory usage.

The algorithm can be written as:
Step 1: start the process
Step 2: get the input x
Step 3: calculate the square by multiplying the input value ie., square \(\leftarrow \)x* x
Step 4: display the result square
Step 5: stop