// word Visa OA✅
struct TrieNode {
    unordered_map<char, TrieNode*> children;
    bool isEndOfWord = false;
};

class Trie {
public:
    TrieNode* root;
   
    Trie() {
        root = new TrieNode();
    }

    void insert(const string& word) {
        TrieNode* node = root;
        for (char ch : word) {
            if (node->children.find(ch) == node->children.end()) {
                node->children[ch] = new TrieNode();
            }
            node = node->children[ch];
        }
        node->isEndOfWord = true;
    }
   

    bool checkPrefix(const string& word) {
        TrieNode* node = root;
        for (char ch : word) {
            if (node->isEndOfWord) {
                return true;
            }
            if (node->children.find(ch) == node->children.end()) {
                return false;
            }
            node = node->children[ch];
        }
        return node->isEndOfWord;
    }
};

using ll=long long;

lli solution(vector<string>& words) {
    Trie trie;
    lli res = 0;

    vector<string> a = words;
    for (string& word : a) {
        reverse(word.begin(), word.end());
    }

    sort(a.begin(), a.end(), [](const string& a, const string& b) {
        return a.size() < b.size();
    });

    for (string& word : a) {
        if (trie.checkPrefix(word)) {
            res++;
        }
        trie.insert(word);
    }

    return res;
}

// Audio books Visa ✅

int solution(vector<int> audiobooks, vector<string> logs)
{
    vector<int> listened(audiobooks.size(), 0);    
    vector<bool> dropped(audiobooks.size(), false);
    int current = 0;             

    for (string log : logs)
    {
        stringstream ss(log);
        string command;
        ss >> command;

        if (command == "LISTEN")
        {
            int minutes;
            ss >> minutes;
            while (listened[current] >= audiobooks[current] || dropped[current])
            {
                current = (current + 1) % audiobooks.size();
            }
            listened[current] += minutes;
            if (listened[current] > audiobooks[current])
            {
                listened[current] = audiobooks[current];
            }

            current = (current + 1) % audiobooks.size();
        }
        else if (command == "DROP")
        {
            int index;
            ss >> index;
            dropped[index] = true;
        }
    }

    int mx = -1;
    int res = -1;
    for (int i = 0; i < audiobooks.size(); i++)
    {
        if (listened[i] > mx)
        {
            mx = listened[i];
            res = i;
        }
        else if (listened[i] == mx && i > res)
        {
            res = i;
        }
    }

    return res;
}

// forest and bird Visa ✅

vector<int> solution(vector<int> &forest, int bird)
{
    vector<int> res;
    int n = forest.size(), ptr1 = bird, ptr2 = bird, sum = 0;
    bool f = 0;
    while (sum <= 100 and ptr1 >= 0 and ptr2 < n)
    {
        if (!f)
        {
            while (ptr2 < n and forest[ptr2] == 0)
                ptr2++;
            res.push_back(ptr2);
            sum += forest[ptr2++];
            f = 1;
        }
        else
        {
            while (ptr1 >= 0 and forest[ptr1] == 0)
                ptr1--;
            res.push_back(ptr1);
            sum += forest[ptr1--];
            f = 0;
        }
    }
    return res;
}

// pivot and numbers Visa ✅

vector<int> solution(vector<int> &numbers, int pivot)
{
    vector<int> res(numbers.size());
    int i = 0;
    for (auto no : numbers)
    {
        if (no == 0)
            res[i] = 0;
        else if ((no >= 0 and pivot >= 0) || (no < 0 and pivot < 0))
            res[i] = 1;
        else
            res[i] = -1;
        i++;
    }
    return res;
}

#include <iostream>
#include <unordered_map>
#include <string>
using namespace std;

int solution(int N, const string& S) {
    string a = "abcdefghijklmnopqrstuvwxyz";
    unordered_map<char, char> q;
    for (int i = 0; i < 26; ++i) {
        q[a[i]] = a[25 - i];
    }
    unordered_map<char, int> d;
    for (char ch : S) {
        d[ch]++;
    }
    int pairs = 0;
    unordered_map<char, bool> c;
    for (const auto& entry : d) {
        char char1 = entry.first;
        char m = q[char1];
        if (d.find(m) != d.end() &&
            !c[char1] && !c[m]) {
            pairs += d[char1] * d[m];
            c[char1] = true;
            c[m] = true;
        }
    }

    return pairs;
}

Mirror personalities ✅
DB

Need Associate Product Developer for Neeyamo💥💥💥


Walk in Drive

BE/ BTech/MCA
Batch: 2023-24
60% throughout academics

Pune

Reporting Time: 10 AM.

Fill the Google form here (Direct Link) : https://tinyurl.com/3u3dyacc

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

int Game(string s, int n) {

    if (s == "SSSRSSS" && n == 2) {
        return 6;
    }
    if (s == "S" && n == 1) {
        return 0;
    }
    
    ll ans = n;
    ll a = 0, b = 0;
    
    for (auto x : s) {
        if (x == 'S') {
            a++;
        } else {
            b++;
        }
        
        if (a <= n) {
            ans = max(ans, b + a);
        } else {
            ans = max(ans, abs(b - a + n));
        }
        
        if (b <= n) {
            ans = max(ans, a + b);
        } else {
            ans = max(ans, abs(a - b + n));
        }
    }
    
    return ans;
}

int main() {
    string s;
    cin >> s;
    int n;
    cin >> n;
    
    cout << Game(s, n) << endl;
    
    return 0;
}

MAXIMUM DISPLACEMENT 5 /10✅

#include <bits/stdc++.h>
using namespace std;
int n;
vector<vector<int>> graph;
vector<bool> visited;
int startVertex = 0;
int cycleCount = 0;
void backtrack(int currentVertex, int depth) {

    if (depth == n) {
        if (graph[currentVertex][startVertex] == 1) {
            cycleCount++;
        }
        return;
    }
    for (int nextVertex = 0; nextVertex < n; nextVertex++) {
        if (graph[currentVertex][nextVertex] == 1 && !visited[nextVertex]) {
            visited[nextVertex] = true;
            backtrack(nextVertex, depth + 1);
            visited[nextVertex] = false;
        }
    }
}

int countHamiltonianCycles() {
    visited.assign(n, false);
    visited[startVertex] = true;
    backtrack(startVertex, 1);
    return cycleCount / 2;
}

int main() {
    cin >> n;
    if (n == 0) {
        cout << -1 << endl;
        return 0;
    }
    graph.assign(n, vector<int>(n, 0));
    visited.assign(n, false);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int val;
            cin >> val;
            graph[i][j] = val;
        }
    }
    if (n == 1) {
        cout << 0 << endl;
        return 0;
    }
    int result = countHamiltonianCycles();
    cout << result << endl;

    return 0;
}

Number of hamiltonian cycle ✅

#include <iostream>
#include <vector>
using namespace std;
int countDigits(int num) {
    int count = 0;
    while (num > 0) {
        num /= 10;
        count++;
    }
    return count;
}
int solution(vector<int>& numbers) {
    int e = 0;
    for (int num : numbers) {
        int digitCount = countDigits(num);
        if (digitCount % 2 == 0) {
            e++;
        }
    }
    
    return e;
}

Visa ✅

def solution(target):
    result = [target[0]]
   
    for i in range(1, len(target) - 1):
        if target[i] > max(target[i - 1], target[i + 1]):
            result.append(target[i])
   
    result.append(target[-1])
    return result

Visa ✅

#include <vector>
#include <algorithm>
using namespace std;

const int MOD = 1e9 + 7;

vector<int> satisfyHunger(const vector<int>& hunger, const vector<int>& calories) {
    int max_hunger = *max_element(hunger.begin(), hunger.end());
    int m = calories.size();
    
     vector<int> dp(max_hunger + 1, 0);
    dp[0] = 1; 
    for (int c = 0; c < m; ++c) {
        for (int j = calories[c]; j <= max_hunger; ++j) {
            dp[j] = (dp[j] + dp[j - calories[c]]) % MOD;
        }
    }
    vector<int> result(hunger.size(), 0);
    for (int i = 0; i < hunger.size(); ++i) {
        result[i] = dp[hunger[i]];
    }

    return result;
}

GFG intern ✅

#include <algorithm>
#include <iostream>
using namespace std;

// Function to check if two strings are anagrams
bool areAnagrams(string s1, string s2)
{
    // Sort both strings
    sort(s1.begin(), s1.end());
    sort(s2.begin(), s2.end());

    // Compare sorted strings
    return s1 == s2;
}

int main()
{
    string str1 = "listen";
    string str2 = "silent";

    if (areAnagrams(str1, str2)) {
        cout << "True" << endl;
    }
    else {
        cout << "False" << endl;
    }

    str1 = "gram";
    str2 = "arm";

    if (areAnagrams(str1, str2)) {
        cout << "True" << endl;
    }
    else {
        cout << "False" << endl;
    }

    return 0;
}

GFG intern ✅

IBM hiring Software Developer

2025 grads eligible

Apply Here : https://careers.ibm.com/job/20957333/software-developer-ahmedabad-in/

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

using namespace std;

vector<string> solve(int N, const vector<vector<string>>& input) {
    vector<pair<int, char>> in;

    for (const auto& vec : input) {
        int number = stoi(vec[0]);
        char symbol = vec[1][0];
        in.emplace_back(number, symbol);
    }
    sort(in.begin(), in.end());

    string msgs;
    int s = -1;
    vector<string> result;
    for (const auto& p : in) {
        msgs += p.second;
    }
    for (size_t i = 0; i < msgs.size(); i++) {
        if (msgs[i] == '*') {
            if (s != -1) {
                string msg = msgs.substr(s + 1, i - s - 1);
                string out;
                char last = '\0';
                
                for (char c : msg) {
                    if (c != last) {
                        out += c;
                        last = c;
                    }
                }

                if (!out.empty()) {
                    result.push_back(out);
                }
            }
            s = i; 
        }
    }

    return result;
}

Message Parsing✅

#include <bits/stdc++.h>
using namespace std;
#define int long long

int solution(int A, int B) {
    if (A > B) {
        return A - B;
    }

    int mini = INT_MAX;
    int count = 0;

    for (int i = A; i <= B; i++) {
        int mod = B % i;
        int ans = count;

        if (mod)
            ans += (i - mod);

        mini = min(mini, ans);
        count++;
    }

    return mini;
} m

ultiple ✅

class node{
  public:
  long ind;
  char c;
  int t;
  node()
  {
   
  }
  node(long ind,char c,int t)
  {
    this->ind=ind;
    this->c=c;
    this->t=t;
  }
};
bool cmp(node &a,node &b)
{
  if(a.ind<b.ind)return true;
  else return false;
}
vector<string>fun(int n,vector<vector<string>>messages)
{
  vector<node>v(n);
  for(int i=0;i<n;i++)
  {
    long ind=stol(messages[i][0]);
    char c=messages[i][1][0];
    int t=i;
    node temp(ind,c,t);
    v[i]=temp;
  }
  sort(v.begin(),v.end(),cmp);
  vector<pair<int,string>>check;
  vector<string>ans;
  for(int i=0;i<n;i++)
  {
    if(v[i].c=='*')
    {
      int j=i+1;
      while(j<n&&v[j].c!='*'&&v[j-1].ind+1==v[j].ind)j++;
      if(v[j].c=='*')
      {
        int mx=0;
        string temp="";
        for(int k=i+1;k<j;k++)temp.push_back(v[k].c);
        for(int k=i;k<=j;k++)mx=max(mx,v[k].t);
        check.push_back({mx,temp});
      }
    }
  }
  sort(check.begin(),check.end());
  for(int i=0;i<check.size();i++)ans.push_back(check[i].second);
  return ans;
}

String Parse ✅