#include <iostream> 
#include <vector> 
#include <unordered_map> 
#include <queue> 
#include <algorithm> 
#include <unordered_set> 
using namespace std; 

vector<string> fep(unordered_map<string, vector<string>>& g, string s) { 
    vector<string> st = {s}; 
    deque<string> p; 
    while (!st.empty()) { 
        string u = st.back(); 
        if (!g[u].empty()) { 
            string v = g[u].front(); 
            g[u].erase(g[u].begin()); 
            st.push_back(v); 
        } else { 
            p.push_front(st.back()); 
            st.pop_back(); 
        } 
    } 
    return vector<string>(p.begin(), p.end()); 
} 

int main() { 
    int n, m; 
    cin >> n >> m; 
    unordered_map<string, vector<string>> g; 
    unordered_set<string> ads; 
    for (int i = 0; i < n; i++) { 
        string a, b; 
        cin >> a >> b; 
        g[a].push_back(b); 
        ads.insert(a); 
        ads.insert(b); 
    } 
    for (auto it = g.begin(); it != g.end(); ++it) { 
        sort(it->second.begin(), it->second.end()); 
    } 
    string s = "ABC"; 
    vector<string> p = fep(g, s); 
    for (const auto& x : p) { 
        cout << x << " "; 
    } 
    cout << endl; 
    return 0; 
}

Flipkart ✅

using namespace std;

vector<int> rc;
vector<vector<int>> adj;
vector<int> seq;

void dfs(int node) {
    if(adj[node].size() > 0) dfs(adj[node][0]);
    seq.push_back(rc[node]);
    if(adj[node].size() > 1) dfs(adj[node][1]);
}

int main() {
    int rCount;
    cin >> rCount;
    rc.resize(rCount);
    for(int i=0; i<rCount; i++) cin >> rc[i];
    int cRow, cCol;
    cin >> cRow >> cCol;
    adj.resize(rCount);
    for(int i=0; i<cRow; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
    }
    int rM;
    cin >> rM;
    dfs(0);
    cout << seq[rM-1] << endl;
    return 0;
}

Restaurant ✅
Flipkart

using namespace std;

void pop_front(vector<int> &v) {
    if (v.size() > 0) {
        v.erase(v.begin());
    }
}

vector<int> helper(vector<int> nums, int c_len) {
    vector<int> ans;
    int In = nums.size();
    for(int i = 0; i < In; i++) {
        while(ans.size() > 0 && ans.back() < nums[i] && ((In - i) > (c_len - ans.size()))) {
            ans.pop_back();
        }
        if(ans.size() < c_len) {
            ans.push_back(nums[i]);
        }
    }
    return ans;
}

vector<int> solve(vector<int> nums1, vector<int> nums2, int k) {
    int l1 = nums1.size();
    int l2 = nums2.size();
    vector<int> rs;
    for (int s1 = max(0, k - l2); s1 <= min(k, l1); s1++) {
        vector<int> p1, p2;
        p1 = helper(nums1, s1);
        p2 = helper(nums2, k - s1);
        vector<int> temp;
        for (int j = 0; j < k; j++) {
            vector<int> temp2 = max(p1, p2);
            int fr = temp2.front();
            if (p1 > p2) {
                pop_front(p1);
            } else {
                pop_front(p2);
            }
            temp.push_back(fr);
        }
        rs = max(rs, temp);
    }
    return rs;
}

int main() {
    int n;
    cin >> n;
    vector<int> arr1(n);
    for(int i = 0; i < n; i++) {
        cin >> arr1[i];
    }
    int m;
    cin >> m;
    vector<int> arr2(m);
    for(int i = 0; i < m; i++) {
        cin >> arr2[i];
    }
    int k;
    cin >> k;
    vector<int> v = solve(arr1, arr2, k);
    for(int i = 0; i < v.size(); i++) {
        cout << v[i] << " ";
    }
    return 0;
}

University
Flipkart ✅

Meesho is hiring for SDE 1 role.

Batch eligible: 2022 and 2023 grads only

Link: https://docs.google.com/forms/d/e/1FAIpQLSccczQRZsQPXR_GPaomStgK2Vem3MspsmiLBJWC0FDXMVWjuw/viewform

Note: this is the referral form and will take only 200 resumes and refer best out of that!!

Parent node ✅

int minimumChunksRequired(long long totalPackets,vector<vector<long long>>uploadedChunks){
    long long ans=0;
    long long prev=0;

    sort(uploadedChunks.begin(),uploadedChunks.end());

    for(int i=0;i<uploadedChunks.size();i++){
        if(uploadedChunks[i][0]==prev+1){
            prev=uploadedChunks[i][1];
            continue;
        }
        else{

            long diff=uploadedChunks[i][0]-prev-1;


            for(int k=0;k<64;k++){
                if(diff&(1LL<<k)){
                    ans++;
                }
            }

            prev=uploadedChunks[i][1];
        }
    }

    long diff=totalPackets-prev;

    for(int k=0;k<64;k++){
        if(diff&(1LL<<k)){
            ans++;
        }
    }

    return ans;

}

#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <cctype>

using namespace std;

string encodeString(const string &s) {
    stringstream ss(s);
    string word;
    vector<string> words;

    while (ss >> word) {
        reverse(word.begin(), word.end());
        words.push_back(word);
    }

    string reversedSentence;
    for (const auto &w : words) {
        reversedSentence += w + " ";
    }
    reversedSentence = reversedSentence.substr(0, reversedSentence.size() - 1);

    string encodedChars;
    for (size_t i = 0; i < reversedSentence.size(); ++i) {
        char c = reversedSentence[i];
        if (i % 2 == 0) {
            encodedChars += toupper(c);
        } else {
            encodedChars += tolower(c);
        }
    }

    for (size_t i = 0; i < encodedChars.size(); ++i) {
        if (encodedChars[i] == ' ') {
            encodedChars[i] = (i % 2 == 0) ? '#' : '*';
        } else if (encodedChars[i] == ',') {
            encodedChars[i] = '@';
        } else if (encodedChars[i] == '.') {
            encodedChars[i] = '@';
        } else if (encodedChars[i] == '-') {
            encodedChars[i] = ':';
        }
    }

    return encodedChars;
}

int main() {
    string inputString = "The mangy, scrawny stray dog hurriedly gobbled down the grain-free, organic dog food.";
    string outputString = encodeString(inputString);
    cout << outputString << endl;
    return 0;
}



// Mini orange 1st ✅

string shortestPalindrome(string s)
    {
        reverse(s.begin(), s.end());
        string rev = s;
        reverse(s.begin(), s.end());
        string temp = s + "@" + rev;
        vector<int> vr = fail_fun(temp);

        int maxm = vr[vr.size()-1];

        temp = "";
        for(int i = maxm; i < s.length(); i++)
        {
            temp = temp + s[i];
        }       
        reverse(temp.begin(), temp.end());
        return temp + s;
    }

    vector<int> fail_fun(string &s)
    {
        int n = s.length();
        vector<int> fail_ar(n, 0);

        for(int i = 1, k = 0; i < n; i++)
        {
            while(k > 0 && s[k] != s[i])
            {
                k = fail_ar[k-1];
            }

            if(s[k] == s[i])
            {
                fail_ar[i] = ++k;
            }
        }

        return fail_ar;
    }

Miniorange

const int MOD = 1e9 + 7;
const int MAXN = 1e6;
using namespace std;
vector<bool> sieve() {
    vector<bool> isPrime(MAXN + 1, true);
    isPrime[0] = isPrime[1] = false;
    for (int i = 2; i <= sqrt(MAXN); ++i) {
        if (isPrime[i]) {
            for (int j = i * i; j <= MAXN; j += i) {
                isPrime[j] = false;
            }
        }
    }
    return isPrime;
}

int solve(const string& s) {
    int n = s.size();
    vector<bool> isPrime = sieve();
    vector<int> dp(n + 1, 0);
    dp[0] = 1;

    for (int i = 1; i <= n; ++i) {
        int num = 0;
        for (int j = 1; j <= 6 && i - j >= 0; ++j) {
            num = num + (s[i - j] - '0') * pow(10, j - 1);
            if (s[i - j] != '0' && num <= MAXN && isPrime[num]) {
                dp[i] = (dp[i] + dp[i - j]) % MOD;
            }
        }
    }

    return dp[n];
}

String estee ✅

long getMaxCost(string s) {
    if (s.find('1') == string::npos) {
        return 0;
    }
    int ind = s.find('1');
    int count = 1;
    int n = s.length();
     long res = 0;
    int prev = ind;
   
    for (int i = ind + 1; i < n; ++i) {
        if (s[i] == '1') {
            if (prev != i - 1) {
                res += (i - prev) * count;
            }
            count += 1;
            prev = i;
        }
    }
   
    if (prev == n - 1) {
        prev = n;
    }
   
    return res + count * (n - prev);
}

Binary Circuit
Estee advisor✅

All passed ✅
Miniorange

def star_value_finder():
    import sys
    input = sys.stdin.read
    data = input().split()
   
    index = 0
    N = int(data[index])
    index += 1
   
    array = [0] * N
    for i in range(N):
        array[i] = int(data[index])
        index += 1
   
    M = int(data[index])
    index += 1
    Q = int(data[index])
   
    value_count = {}
   
    for i in range(N):
        current_value = array[i]
        for j in range(-Q, Q + 1):
            new_value = current_value + j * M
            if new_value in value_count:
                value_count[new_value] += 1
            else:
                value_count[new_value] = 1
   
    max_count = 0
    for count in value_count.values():
        if count > max_count:
            max_count = count
   
    print(max_count)

star_value_finder()


// Mini orange 2nd

public int candy(int[] ratings) {
    final int n = ratings.length;

    int ans = 0;
    int[] l = new int[n];
    int[] r = new int[n];
    Arrays.fill(l, 1);
    Arrays.fill(r, 1);

    for (int i = 1; i < n; ++i)
      if (ratings[i] > ratings[i - 1])
        l[i] = l[i - 1] + 1;

    for (int i = n - 2; i >= 0; --i)
      if (ratings[i] > ratings[i + 1])
        r[i] = r[i + 1] + 1;

    for (int i = 0; i < n; ++i)
      ans += Math.max(l[i], r[i]);

    return ans;
  }


//MIni orange 3rd

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

typedef long long lli;

const lli mod = 1000007;

const int mx = 1000000;
const int S = sqrt(mx) + 1;
int prime[mx], np = 0;
bool isnp[mx + 10];

// Sieve of Eratosthenes to find all primes up to mx
void siv(void) {
    int i, j, k;
    np = 0;
    isnp[1] = isnp[0] = true;
    prime[np++] = 2;
    for (i = 3; i <= S; i += 2)
        if (!isnp[i])
            for (prime[np++] = i, j = i * i, k = (i << 1); j <= mx; j += k)
                isnp[j] = true;
    for (; i <= mx; i += 2)
        if (!isnp[i])
            prime[np++] = i;
}

// Function to find the power of prime p in n!
lli pinf(int p, int n) {
    int ans = 0;
    while (n) {
        ans += (n / p);
        n /= p;
    }
    return ans;
}

// Function to find the number of divisors of (n!)^2
lli ndivfact2(int n) {
    int i = 0;
    lli ans = 1;
    while (prime[i] <= n) {
        ans *= (pinf(prime[i], n) * 2) + 1;
        ans %= mod;
        i++;
    }
    return ans;
}

int main() {
    siv();
    int n;
    cin >> n;
    cout << ndivfact2(n) << endl;
    return 0;
}

Modulo arithmetic equation
Estee advisor✅

Mini Orange and estee all solution posted ✅

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

int minTrucks(vector<int>& boulders, int truckCapacity) {
    vector<int> b = boulders;
    int c = truckCapacity;
    sort(b.begin(), b.end());
    int l = 0, r = b.size() - 1, t = 0;
    while (l <= r) {
        if (b[l] + b[r] <= c) {
            l++;
        }
        r--;
        t++;
    }
    return t;
}

#include <vector>
#include <utility>
#include <map>
#include <algorithm>

int deleteProducts(vector<int> ids, int m) {
    vector<pair<int, int>> vp;
    map<int, int> mp;

    for (int x : ids) {
        mp[x]++;
    }

    for (auto it : mp) {
        vp.push_back({it.second, it.first});
    }

    sort(vp.begin(), vp.end());

    int cnt = mp.size();
    for (auto it : vp) {
        if (m >= it.first) {
            m -= it.first;
            cnt--;
        } else {
            break;
        }
    }

    return cnt;
}.

SMART SALE