About MeMy Stats
About Me
My Name is Ankit Kumar Mohanty. Results-driven and self-motivated Electronics and Telecommunication graduate from Veer Surendra Sai University Of Technology, who gradually developed an interest in the Computer Science field and passionate about creating software and web applications.
Good problem-solving skills and ability to perform well in a team. Seeking to be a part of an organization where I can grow in terms of knowledge, skills, and attitude and put my best efforts to learn the new trends and adopt the new environment. I assure you of my level best work if given a chance to perform and willing to give total support to the organization I work for with my capabilities.
I am a Software Developer during the day, who loves to code and build various Projects in the evening.
100+
Projects
Completed
1+
Years of
experience
10000+
Hours of
Hustle
10+
Technologies
Used
My Skills
My Timeline
Aug 2021 - Present
Associate Software Engineer - Accenture
QA Engineer in a Telecom Project.
Tech Stack Used - Java, Selenium, UFT
Jul 2017 - Jul 2021
Bachelor Of Technology - Electronics and Telecommunication - VSSUT
University Rank - 2
CGPA - 8.94
Jul 2017 - Present
Tech Enthusiast - Self Learn
Learning new technologies by implementing them in projects.
My PortfolioMy Work
Here are some of my works that I have done in various programming languages.
My BlogsMy Blogs
Binary Search Implementation
The usual way to implement binary search resembles lookong for a word in a dictionary. The search maintains an active region in the array, which initially contains all array elements. Then a number of steps is performed , each of which halves the size of the region.
At each step, the search checks the middle element of the active region. If the middle element is the target element, the search terminates. Otherwise, the search recursively continues to the left or right of the region, depending on the value of the middle element. Time Complexity -> O(logN).
int a = 0, b = n-1;
while (a <= b) {
int k = (a+b)/2;
if (array[k] == x) {
// x found at index k
}
if (array[k] > x) b = k-1;
else a = k+1;
}
In this implementation, the active region is a...b, and initially the region is
0...n¡1. The algorithm halves the size of the region at each step, so the time
complexity is O(logn).
An alternative method to implement binary search is based on an efficient way to
iterate through the elements of the array. The idea is to make jumps and slow
the speed when we get closer to the target element.
The search goes through the array from left to right, and the initial jump
length is n/2. At each step, the jump length will be halved: first n/4, then n/8,
n/16, etc., until finally the length is 1. After the jumps, either the target element
has been found or we know that it does not appear.
The following code implements the above idea:
int k = 0;
for (int b = n/2; b >= 1; b /= 2) {
while (k+b < n && array[k+b] <= x) k += b;
}
if (array[k] == x) {
// x found at index k
}
Complexity Classes
The Following list contains common time complexities of algorithms:
=> O(1)-> The running time of a constant-time algorithm does not depend on the
input size. A typical constant-time algorithm is a direct formula that
calculates the answer.
=> O(logn)-> A logarithmic algorithm often halves the input size at each step. The
running time of such an algorithm is logarithmic, because log2 n equals the
number of times n must be divided by 2 to get 1.
=> O(n1/2)-> A square root algorithm is slower than O(logn) but faster than O(n).
A special property of square roots is that n1/2 = n/n1/2 ,so the square root lies, in some sense, in the middle of the input.
=> O(n)-> A linear algorithm goes through the input a constant number of times. This
is often the best possible time complexity, because it is usually necessary to
access each input element at least once before reporting the answer.
=> O(nlogn)-> This time complexity often indicates that the algorithm sorts the input,
because the time complexity of efficient sorting algorithms is O(nlogn).
Another possibility is that the algorithm uses a data structure where each
operation takes O(logn) time.
=> O(n2)-> A quadratic algorithm often contains two nested loops. It is possible to
go through all pairs of the input elements in O(n2) time.
=> O(n3)-> A cubic algorithm often contains three nested loops. It is possible to go
through all triplets of the input elements in O(n3) time.
=> O(2n)-> This time complexity often indicates that the algorithm iterates through
all subsets of the input elements. For example, the subsets of {1,2,3} are phi,
{1}, {2}, {3}, {1,2}, {1,3}, {2,3} and {1,2,3}.
=> O(n!)-> This time complexity often indicates that the algorithm iterates through
all permutations of the input elements. For example, the permutations of
{1,2,3} are (1,2,3), (1,3,2), (2,1,3), (2,3,1), (3,1,2) and (3,2,1).
Backtracking Algorithm
A backtracking algorithm begins with an empty solution and extends the
solution step by step. The search recursively goes through all different ways how
a solution can be constructed.
As an example, consider the problem of calculating the number of ways n
queens can be placed on an nXn chessboard so that no two queens attack each
other. For example, when n = 4, there are two possible solutions:
The problem can be solved using backtracking by placing queens to the board
row by row. More precisely, exactly one queen will be placed on each row so that
no queen attacks any of the queens placed before. A solution has been found
when all n queens have been placed on the board.
The algorithm can be implemented as follows:
void search(int y) {
if (y == n) {
count++;
return;
}
for (int x = 0; x < n; x++) {
if (column[x] || diag1[x+y] || diag2[x-y+n-1]) continue;
column[x] = diag1[x+y] = diag2[x-y+n-1] = 1;
search(y+1);
column[x] = diag1[x+y] = diag2[x-y+n-1] = 0;
}
}
The search begins by calling search(0). The size of the board is nXn, and the
code calculates the number of solutions to count.
The code assumes that the rows and columns of the board are numbered from
0 to n-1. When the function search is called with parameter y, it places a queen
on row y and then calls itself with parameter y+1. Then, if y = n, a solution has
been found and the variable count is increased by one.
The array column keeps track of columns that contain a queen, and the arrays
diag1 and diag2 keep track of diagonals. It is not allowed to add another queen
to a column or diagonal that already contains a queen.
Contact MeMy Socials
Contact Me Here
You can reach out to me through the given socials.
Jajpur,Odisha,India
ankitmohanty1804@gmail.com
VSSUT,Burla,Sambalpur
English, Hindi, Odia