Program Associate

int countWays(int n)
{
if(n == 1) return n;
int mod = 1000000000 + 7;
int prev = 2, prev2 = 1, curr = 0;

for(int i = 2 ; i < n ; i++){
curr = (prev + prev2) % mod;
prev2 = prev;
prev = curr;
}

return prev ;
}

#include 
using namespace std;

// Tree Node
struct Node {
int data;
Node *left;
Node *right;

Node(int val) {
data = val;
left = right = NULL;
}
};

// Function to Build Tree
Node* buildTree(string str)
{ 
// Corner Case
if(str.length() == 0 || str[0] == 'N')
return NULL;

// Creating vector of strings from input 
// string after spliting by space
vector ip;

istringstream iss(str);
for(string str; iss >> str; )
ip.push_back(str);

// Create the root of the tree
Node* root = new Node(stoi(ip[0]));

// Push the root to the queue
queue queue;
queue.push(root);

// Starting from the second element
int i = 1;
while(!queue.empty() && i < ip.size()) {

// Get and remove the front of the queue
Node* currNode = queue.front();
queue.pop();

// Get the current node's value from the string
string currVal = ip[i];

// If the left child is not null
if(currVal != "N") {

// Create the left child for the current node
currNode->left = new Node(stoi(currVal));

// Push it to the queue
queue.push(currNode->left);
}

// For the right child
i++;
if(i >= ip.size())
break;
currVal = ip[i];

// If the right child is not null
if(currVal != "N") {

// Create the right child for the current node
currNode->right = new Node(stoi(currVal));

// Push it to the queue
queue.push(currNode->right);
}
i++;
}

return root;
}


// } Driver Code Ends
/*The Node structure is defined as
struct Node {
int data;
Node *left;
Node *right;

Node(int val) {
data = val;
left = right = NULL;
}
};
*/

// return the Kth largest element in the given BST rooted at 'root'
class Solution
{public:
void solve(Node*root,int k,int&c,int &ans){
if(root==NULL||c>=k){
return ;
}
solve(root->right,k,c,ans);
c++;
if(c==k){
ans=root->data;
return;
}
solve(root->left,k,c,ans);
}
public:
int kthLargest(Node *root, int k)
{
int c=0;int ans;
solve(root,k,c,ans);
return ans;
}
};

// { Driver Code Starts.

int main()
{
int t;
cin>>t;
getchar();

while(t--)
{
string s;
getline(cin,s);
Node* head = buildTree(s);

int k;
cin>>k;
getchar();

Solution ob;
cout << ob.kthLargest( head, k ) << endl;
}
return 1;
} }

Ans: Thread is a path of execution that is composed of a program counter, thread id, stack, and set of registers within the process. It is a basic unit of CPU utilization that makes communication more effective and efficient, enables utilization of multiprocessor architectures to a greater scale and greater efficiency, and reduces the time required in context switching. It simply provides a way to improve and increase the performance of applications through parallelism. Threads are sometimes called lightweight processes because they have their own stack but can access shared data.

Multiple threads running in a process share: Address space, Heap, Static data, Code segments, File descriptors, Global variables, Child processes, Pending alarms, Signals, and signal handlers.

Each thread has its own: Program counter, Registers, Stack, and State.