Application Developer

Approach (Using Kruskal's Algo) :

1) First, we will add all the edges (that can be formed by any two points) and their cost in a min-heap. 

2) Now, we will process each and every edge present in the min-heap one by one. 

3) If the current edge in processing forms a cycle in the MST, then discard the edge; otherwise, include it in the MST. We will be adding the cost of edges included in the MST in an integer variable, ‘result’.

4) The process will be repeated till ‘n - 1’ edges are not included in the MST, where ‘n’ is the number of points in the ‘coordinates’ array. In the end, the ‘result’ will have the cost of MST so formed.

TC : O((N ^ 2) * (log (N)), where ‘N’ is the size of ‘coordinates’ array.
SC : O(N ^ 2)

Approach (Using Merge Sort) : 

1) The idea is similar to merge sort, divide the array into two equal or almost equal halves in each step until the base case is reached.

2 )Create a function merge that counts the number of inversions when two halves of the array are merged, create two indices i and j, i is the index for the first half, and j is an index of the second half. if a[i] is greater than a[j], then there are (mid – i) inversions. 

3) Create a recursive function to divide the array into halves and find the answer by summing the number of inversions is the first half, the number of inversion in the second half and the number of inversions by merging the two.

4) The base case of recursion is when there is only one element in the given half.

5) Print the answer

TC : O(N*log(N)), where N=size of the array.
SC : O(N)

Approach (Using Slow and Fast Pointers) : 

1) Initially, the 'FAST' pointer advances the list by 'K' nodes from the beginning and the 'SLOW' is a pointer to the head of the linked list.

2) Now both pointers are exactly separated by 'K' distance from each other. We will maintain a constant gap by advancing both pointers together until the 'FAST' pointer reaches the last node.

3) When the 'FAST' pointer is at the last node then the 'SLOW' pointer will be at ('K' + 1)th node from the end of the linked list.

4) At last, we will set the next of 'SLOW' pointer to its next of next node.

TC : O(N), where N=number of nodes in the linked list
SC : O(1)

Normalization is the process of minimizing redundancy from a relation or set of relations. Redundancy in relation may cause insertion, deletion, and update anomalies. So, it helps to minimize the redundancy in relations. Normal forms are used to eliminate or reduce redundancy in database tables.

Types of Normal Form :

1) 1NF: It is known as the first normal form and is the simplest type of normalization that you can implement in a database. A table to be in its first normal form should satisfy the following conditions:
i) Every column must have a single value and should be atomic.
ii) Duplicate columns from the same table should be removed.
iii) Separate tables should be created for each group of related data and each row should be identified with a unique column.


2) 2NF: It is known as the second normal form. A table to be in its second normal form should satisfy the following conditions:
i )The table should be in its 1NF i.e. satisfy all the conditions of 1NF.
ii) Every non-prime attribute of the table should be fully functionally dependent on the primary key i.e. every non-key attribute should be dependent on the primary key in such a way that if any key element is deleted then even the non_key element will be saved in the database.

3) 3NF: It is known as the third normal form. A table to be in its second normal form should satisfy the following conditions:
i) The table should be in its 2NF i.e. satisfy all the conditions of 2NF.
ii) There is no transitive functional dependency of one attribute on any attribute in the same table. 

4) BCNF: BCNF stands for Boyce-Codd Normal Form and is an advanced form of 3NF. It is also referred to as 3.5NF for the same reason. A table to be in its BCNF normal form should satisfy the following conditions:
i) The table should be in its 3NF i.e. satisfy all the conditions of 3NF.
ii) For every functional dependency of any attribute A on B
(A->B), A should be the super key of the table. It simply implies that A can’t be a non-prime attribute if B is a prime attribute.

SELECT A.ID_Name, B.ID_Name
FROM A
INNER JOIN B ON A.ID=B.ID;

JVM is platform dependent because it takes java byte code and generates byte code for the current operating system. So Java software is platform dependent but Java language is platform independent because different operating system have different JVMs.

Approach : 

1)Iterate through the string and keep a count of the given character in a variable ct.
2) If ct==count, strore the index in a variable say idx and break from the loop
3) Final Ans=string.substr(idx)

TC : O(N) , where N=length of the string
SC : O(1)

//Pseudo Code : 
int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}

TC : O(log(min(a,b))
SC : O(1)

Answer :

0 0 0 0
0
0
0 0 0 0

This is the required configuration

Approach : 
The lady should take out 1 coin from the 1st bag, 2 coins from the 2nd bag, 3 coins from the 3rd bag and similarly 10 coins from the 10th bag.
Now she should simply weigh all these picked coins together.
If there were no forgeries, then the total weight should be (1+2+3+ . . . +10) = 55 grams.
Now, if the total weight comes out to be 55.3 then she can conclude that the 3rd bag contain forgeries. So, if the total weight is (55.n), then it is clear that the nth bag contain forgeries.

Tip 1 : Oracle technologies are modern, cutting edge and built for enterprise requirements (think world class security, availability, performance, scalability, integrated ML/AI and so forth). Oracle Database is #1 worldwide.
Tip 2 : Since it’s inception, Oracle has become a market leader when it comes to database. Oracle has its own all possible solution for it’s clients whether it is into IT or Banking.
Tip 3 : Oracle gives your job sustainability with better career growth - in terms of job profile and package both.