1.

Analysis of algorithm
The analysis of algorithms is the study of the efficiency and performance characteristics of
algorithms. It involves evaluating the resources, such as time and space, required by an algorithm
to solve a problem as the input size increases.

The primary goals of algorithm analysis are:

1. Efficiency: Determining how well an algorithm performs in terms of its resource usage.
2. Comparisons: Comparing different algorithms that solve the same problem to determine
which one is more efficient.
3. Optimization: Identifying bottlenecks and areas for improvement in an algorithm to make it
more efficient.

2. Here's a brief introduction to the design and analysis of algorithms:

Algorithm Design:
This step involves designing algorithms to solve specific computational problems. The algorithm
should take input, perform a sequence of well-defined steps, and produce the desired output. There
are various techniques for algorithm design, such as divide and conquer, greedy algorithms,
dynamic programming, and more.
Correctness:
It's essential to ensure that an algorithm produces the correct output for all possible inputs.
Techniques like mathematical induction, loop invariants, and formal proofs are used to establish
the correctness of an algorithm.
Time Complexity:
The time complexity of an algorithm measures the amount of time it takes to run as a function of
the input size. It provides an estimate of the running time and helps identify how the algorithm's
performance scales with larger inputs. Common notations used to express time complexity include
Big O, Omega, and Theta.
Space Complexity:
The space complexity of an algorithm measures the amount of memory it requires as a function of
the input size. It helps understand the memory usage of an algorithm and determines how the
memory requirements grow with larger inputs.
Algorithm Analysis:
Analyzing algorithms involves studying their time and space complexity to evaluate their
efficiency. It helps in comparing different algorithms for the same problem and selecting the most
efficient one. Techniques like worst-case analysis, average-case analysis, and amortized analysis
are used to analyze algorithms.
Optimization Techniques:
After analyzing an algorithm and identifying its bottlenecks, optimization techniques can be applied
to improve its efficiency. This may involve algorithmic improvements, data structure selection,
pruning unnecessary computations, parallelization, and more.
Algorithm Paradigms:
There are various algorithm paradigms that provide general approaches to problem-solving. Some
common paradigms include divide and conquer, greedy algorithms, dynamic programming,
backtracking, and more. Understanding these paradigms helps in designing efficient algorithms by
leveraging established techniques.
The design and analysis of algorithms is a fundamental part of computer science and plays a crucial role in
developing efficient software solutions. By designing algorithms with good time and space complexity and
analyzing their efficiency, we can ensure that computational problems are solved in an optimal and scalable
manner.

Here's how you can determine the Big O, Omega, and Theta notations for the GCD algorithm:

1. Big O notation (O):

- The Big O notation provides an upper bound on the growth rate of the algorithm's running time. For
the GCD algorithm, the worst-case time complexity is O(log min(a, b)). This means that the running time
of the algorithm grows logarithmically with the minimum value between `a` and `b`. In terms of Big O
notation, you can express the time complexity as O(log n), where `n` represents the input size.

2. Omega notation (Ω):

- The Omega notation provides a lower bound on the growth rate of the algorithm's running time. For
the GCD algorithm, the best-case time complexity is Ω(1) because in the best case, when one number is a
multiple of the other, the algorithm terminates in constant time. Therefore, the best-case time complexity
is Ω(1), indicating that the algorithm will always take at least constant time to complete.

3. Theta notation (Θ):

- The Theta notation provides both an upper and lower bound on the growth rate of the algorithm's
running time. For the GCD algorithm, the time complexity is Θ(log min(a, b)) because it matches both the
upper bound (O(log min(a, b))) and the lower bound (Ω(1)). This notation indicates that the algorithm's
running time grows logarithmically with the minimum value between `a` and `b` and is tightly bounded
by this growth rate.

In summary, the time complexity of the GCD algorithm implemented using the Euclidean algorithm is
O(log min(a, b)), Ω(1), and Θ(log min(a, b)).

Asymptotic Analysis

 To compare two algorithms with running times f(n) and g(n), we need a rough measure that
characterizes how fast each function grows.
 Hint: use rate of growth
 Compare functions in the limit, that is, asymptotically!
(i.e., for large values of n)

 O notation :Big-O is the formal method of expressing the upper bound of an algorithm's running
time.
 It's a measure of the longest amount of time it could possibly take for the algorithm to complete.
 Formally, for non-negative functions, f(n) and g(n), if there exists an integer n0 and a constant c >
0 such that for all integers n > n0, f(n) ≤ cg(n), then f(n) is Big O of g(n).
  O-notation

 Big-Omega Notation Ω
 This is almost the same definition as Big Oh, except that "f(n) ≥ cg(n)”
 This makes g(n) a lower bound function, instead of an upper bound function.
 It describes the best that can happen for a given data size.
 For non-negative functions, f(n) and g(n), if there exists an integer n0 and a constant c > 0 such
that for all integers n > n0, f(n) ≥ cg(n), then f(n) is omega of g(n). This is denoted as "f(n) =
Ω(g(n))".
 Theta Notation Θ
 Theta Notation For non-negative functions, f(n) and g(n), f(n) is theta of g(n) if and only if f(n) =
O(g(n)) and f(n) = Ω(g(n)). This is denoted as "f(n) = Θ(g(n))".
This is basically saying that the function, f(n) is bounded both from the top and bottom by the same
function, g(n).

(g(n)) is the set of

functions with the same order
of growth as g(n)