SDE - 1

Originally, let the number of seats for Mathematics, Physics and Biology be 5x, 7x and 8x respectively.

Number of increased seats are (140% of 5x), (150% of 7x) and (175% of 8x).

140 x 5x , 150 x 7x and 175 x 8x 
100 100 100
7x, 21x and 14x.
2
The required ratio = 7x : 21x : 14x
2
14x : 21x : 28x

2 : 3 : 4.

Angle traced by hour hand in 12 hrs = 360°.

Angle traced by hour hand in 5 hrs 10 min. i.e., 31 hrs = 360 x 31 ° = 155°.

110

Tip 1: Pseudocode is used to document algorithms in a way that is readable to humans, representing how a program will work without worrying about syntax.
Tip 2: Answer: To document algorithms in natural language

int lisEndAtI(vector& arr, int i)
{
if (i == 0)
return 1;

int mx = 1;
for (int prev = 0; prev < i; prev++)
if (arr[prev] < arr[i])
mx = max(mx, lisEndAtI(arr, prev) + 1);
return mx;
}

int lis(vector& arr)
{
int n = arr.size();
int res = 1;
for (int i = 1; i < n; i++)
res = max(res, lisEndAtI(arr, i));
return res;
}

// Driver program 
int main()
{
vector arr = { 10, 22, 9, 33, 21, 50, 41, 60 };
cout << "Length of lis is " << lis(arr);
return 0;
}

output: Length of lis is 5

A cycle occurs when a node's next points back to a previous node in the list. The linked list is no longer linear with a beginning and end—instead, it cycles through a loop of nodes.

The idea is to insert the nodes in the hashmap and whenever a node is encountered that is already present in the hashmap then return true.

class Node {
public:
int data;
Node* next;
Node(int new_data) {
this->data = new_data;
this->next = nullptr;
}
};

bool detectLoop(Node* head) {
unordered_set h_map;

while (head != nullptr) {


if (h_map.find(head) != h_map.end())
return true;

h_map.insert(head);

head = head->next;
}
return false;
}

int main() {

Node* head = new Node(10);
head->next = new Node(20);
head->next->next = new Node(30);
head->next->next->next = new Node(40);
head->next->next->next->next = new Node(50);
head->next->next->next->next->next = new Node(60);

head->next->next->next->next = head;

if (detectLoop(head))
cout << "Loop Found";
else
cout << "No Loop";

return 0;
}

Example 1:

Input: s = "()"
Output: true
Example 2:

Input: s = "()[]{}"
Output: true
Example 3:

Input: s = "(]"
Output: false


public class Solution {
public static boolean isValid(String s) {
while (true) {
if (s.contains("()")) {
s = s.replace("()", "");
} else if (s.contains("{}")) {
s = s.replace("{}", "");
} else if (s.contains("[]")) {
s = s.replace("[]", "");
} else {
// If the string becomes empty, it indicates all brackets are matched.
return s.isEmpty();
}
}
}
}

We prefer STL over user-defined data structure and functions because:
It saves time spent writing code for user-defined data structures.
It is tried, efficient, and debugged code tested over a long period.
STL is the part of C++ Language Standard so it is easy to understand for other programmers.
STL allows us to parameterize the code with the required data type.

Insertion: If the size of the vector is N, then the time complexity of insertion of an element in the vector is:

At the end: O(1)
At M index: O(N – M)
Deletion: If the size of the vector is N, then the time complexity of deletion of an element in the vector is:

At the end: O(1) 
At M index: O(N-M)

// C program to Find the Factorial Using for Loop

unsigned int factorial(unsigned int N) {
int fact = 1, i;
for (i = 1; i <= N; i++) {
fact *= i;
}

return fact;
}

int main() {
int N = 5;
int fact = factorial(N);
printf("Factorial of %d is %d", N, fact);
return 0;
}




// using recursion

unsigned int factorial(unsigned int n) {

if (n == 1) {
return 1;
}

return n * factorial(n - 1);
}

int main() {
int num = 5;
printf("Factorial of %d is %d", num, factorial(num));
return 0;
}

An element is a peak element if it is greater than or equal to its four neighbors, left, right, top and bottom. 
A Diagonal adjacent is not considered a neighbour. 
A peak element is not necessarily the maximal element. 
More than one such element can exist. 
There is always a peak element. 
For corner elements, missing neighbors are considered of negative infinite value.



vector findPeakGrid(vector > arr)
{
vector result;
int row = arr.size();
int column = arr[0].size();

for (int i = 0; i < row; i++) {
for (int j = 0; j < column; j++) {

if (i > 0)
if (arr[i][j] < arr[i - 1][j])
continue;

if (j < column - 1)
if (arr[i][j] < arr[i][j + 1])
continue;

if (i < row - 1)
if (arr[i][j] < arr[i + 1][j])
continue;

if (j > 0)
if (arr[i][j] < arr[i][j - 1])
continue;

result.push_back(i);
result.push_back(j);
break;
}
}
return result;
}


int main()
{
vector > arr = { { 9, 8 }, { 2, 6 } };
vector result = findPeakGrid(arr);
cout << "Peak element found at index: " << result[0]
<< ", " << result[1] << endl;
return 0;
}

const int MAX = 100;

void printDiagonalSums(int mat[][MAX], int n)
{
int principal = 0, secondary = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {


if (i == j)
principal += mat[i][j];

if ((i + j) == (n - 1))
secondary += mat[i][j];
}
}

cout << "Principal Diagonal:" << principal << endl;
cout << "Secondary Diagonal:" << secondary << endl;
}


int main()
{
int a[][MAX] = { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, 
{ 1, 2, 3, 4 }, { 5, 6, 7, 8 } };
printDiagonalSums(a, 4);
return 0;
}

Also, prepare for the following questions
Tip 1:Tell us about an incident where something went wrong in your project while you were managing it.
Tip 2:How do you facilitate an environment of collaboration on your team?
Tip 3: How do you define an ideal project?