SELECT 
    visited_on, 
    amount, 
    ROUND(AVG(amount) OVER (
        ORDER BY visited_on 
        ROWS BETWEEN 6 PRECEDING AND CURRENT ROW
    ), 2) AS avg_amount
FROM 
    customers
ORDER BY 
    visited_on;

Restaurant Growth✅

def card_game(N, K, A, B):
    result = []
    set_b = set(B)
    for a in A:
        if a == K:
            result.append("1")
        elif a in set_b:
            result.append("0")
        else:
            result.append("#")
    return " ".join(result)

Tiger Analytics ✅

from collections import deque
def bfs(start, n, adj):
    dist = [-1] * (n + 1)
    dist[start] = 0
    queue = deque([start])
    while queue:
        node = queue.popleft()
        for neighbor in adj[node]:
            if dist[neighbor] == -1:  
                dist[neighbor] = dist[node] + 1
                queue.append(neighbor)
    return dist
def solve(node_from, node_to, N, K, special_nodes):
    adj = [[] for _ in range(N + 1)]
    for i in range(len(node_from)):
        u = node_from[i]
        v = node_to[i]
        adj[u].append(v)
        adj[v].append(u)
    dist_from_1 = bfs(1, N, adj)
    dist_from_n = bfs(N, N, adj)
    min_dist = dist_from_1[N]
    for i in range(K):
        for j in range(i + 1, K):
            u = special_nodes[i]
            v = special_nodes[j]
            new_dist = min(dist_from_1[u] + 1 + dist_from_n[v], dist_from_1[v] + 1 + dist_from_n[u])
            min_dist = min(min_dist, new_dist)
    return min_dist

Special Nodes Path ✅

def generate_log_stream(N, A):
    log_stream = []
    prev = None
    i = 0
    while i < N:
        val = A[i]
        count = 1
        while i + 1 < N and A[i + 1] == val:
            i += 1
            count += 1
        if count >= 2:
            if prev is None:
                log_stream.append(1)
            else:
                if val > prev:
                    log_stream.append(1)
                elif val < prev:
                    log_stream.append(-1)
                else:
                    log_stream.append(-1)
            prev = val
        i += 1
    for log in log_stream:
        print(log)

Tiger Analytics ✅

from collections import Counter
def findDuplicateUsers(a, b):
    c = {x: ''.join(sorted(x)) for x in a}
    d = Counter(''.join(sorted(x)) for x in b)
    e = []
    for x, y in c.items():
        if d[y] > 1:
            e.append(x)
    return sorted(e) if e else ["None"]

Amazon ✅

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
int bfs(vector<vector<int>> &g, int n, int m, int x, int y, vector<vector<int>> &d) {
    queue<pair<int, int>> q;
    q.push(make_pair(x, y));
    d[x][y] = 0;
    int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};

    while (!q.empty()) {
        pair<int, int> p = q.front();
        q.pop();
        int cx = p.first, cy = p.second;

        for (int i = 0; i < 4; i++) {
            int nx = cx + dx[i], ny = cy + dy[i];
            if (nx >= 0 && ny >= 0 && nx < n && ny < m && d[nx][ny] == 1e9) {
                d[nx][ny] = d[cx][cy] + 2;
                q.push(make_pair(nx, ny));
            }
        }
    }
    return 0;
}

int minDays(vector<vector<int>> &g, int n, int m) {
    vector<pair<int, int>> s;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            if (g[i][j] > 0) s.push_back(make_pair(i, j));

    if (s.empty()) return 0;

    vector<vector<int>> d(n, vector<int>(m, 1e9));
    bfs(g, n, m, s[0].first, s[0].second, d);

    int t = g[s[0].first][s[0].second];
    for (int i = 1; i < s.size(); i++) {
        t += d[s[i].first][s[i].second] + g[s[i].first][s[i].second];
        fill(d.begin(), d.end(), vector<int>(m, 1e9)); 
        bfs(g, n, m, s[i].first, s[i].second, d);
    }
    return (t + 7) / 8;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> g(n, vector<int>(m));
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> g[i][j];
    cout << minDays(g, n, m) << endl;
}

Nucleus ✅

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
int kthP(int k) {
    vector<bool> p(10000, true);
    p[0] = p[1] = false;
    vector<int> ps;
    for (int i = 2; i < 10000; i++) {
    if (p[i]) {
    ps.push_back(i);
    for (int j = i * 2; j < 10000; j += i)
    p[j] = false;
        }
    }
    return ps[k - 1];
}

int bfs(int s, vector<vector<int>> &adj, vector<bool> &vis) {
    queue<int> q;
    q.push(s);
    vis[s] = true;
    int c = 0;
    while (!q.empty()) {
    int u = q.front();
    q.pop();
    c++;
    for (int v : adj[u]) {
    if (!vis[v]) {
    vis[v] = true;
    q.push(v);
            }
        }
    }
    return c;
}
int main() {
    int a, b;
    cin >> a >> b;
    vector<vector<int>> adj(a + 1);
    for (int i = 0; i < b; i++) {
        int c, d;
        cin >> c >> d;
        adj[c].push_back(d);
        adj[d].push_back(c);
    }

    vector<bool> vis(a + 1, false);
    int mx = 0;
    for (int i = 1; i <= a; i++) {
    if (!vis[i]) {
    mx = max(mx, bfs(i, adj, vis));
        }
    }

    cout << mx << " " << kthP(mx) << endl;
    return 0;
}

Nucleus ✅

SELECT DISTINCT R.REV_NAME
FROM REVIEWER R
JOIN MOVIES M ON R.REV_ID = M.REV_ID
WHERE M.REV_STARS >= 6;

Cleartax ✅

def solution(a, signs, b, c):
    output = []
    for i in range(len(a)):
        if signs[i] == '+':
            output.append(a[i] + b[i] == c[i])
        elif signs[i] == '-':
            output.append(a[i] - b[i] == c[i])
        else:
            output.append(False) 
    return output

Ugabyte ✅

import heapq
def min_time(n, p, q, r, t1, t2, t3):
    d = [0] * p
    e = [0] * q
    x = [0] * r
    t = 0
    for _ in range(n):
        sd = heapq.heappop(d)
        se = heapq.heappop(e)
        sx = heapq.heappop(x)
        se = max(se, sd + t1)
        sx = max(sx, se + t2)
        f = sx + t3
        heapq.heappush(d, sd + t1)
        heapq.heappush(e, se + t2)
        heapq.heappush(x, sx + t3)
        t = max(t, f)
    return t

n = int(input())
p, q, r, t1, t2, t3 = map(int, input().split())
print(min_time(n, p, q, r, t1, t2, t3))

Airtel
perfume factory✅

string solution(vector<vector<int>> operations) {
    set<int> obstacles;
    string ans = "";   
    for (auto &op : operations) {
        if (op[0] == 1) {
            obstacles.insert(op[1]);
        } else if (op[0] == 2) {
            int x = op[1];
            int size = op[2];
            int start = x - size;
            auto it = obstacles.lower_bound(start);
            if (it != obstacles.end() && *it < x) {
                ans += '0';
            } else {
                ans += '1';
            }
        }
    }
    return ans;
}

Yugabyte ✅

#include <bits/stdc++.h>
using namespace std;
#define ll long long
class SegmentTree {
private:
    vector<ll> t;
    ll n;
    void upd(ll i, ll v, ll x, ll s, ll e) {
        if (s == e) {
            t[x] += v;
        } else {
            ll m = (s + e) / 2;
            if (i <= m) {
                upd(i, v, 2 * x, s, m);
            } else {
                upd(i, v, 2 * x + 1, m + 1, e);
            }
            t[x] = t[2 * x] + t[2 * x + 1];
        }
    }
    ll qry(ll l, ll r, ll x, ll s, ll e) {
        if (r < s || e < l) return 0;
        if (l <= s && e <= r) return t[x];
        ll m = (s + e) / 2;
        ll left = qry(l, r, 2 * x, s, m);
        ll right = qry(l, r, 2 * x + 1, m + 1, e);
        return left + right;
    }

public:
    SegmentTree(ll sz) : n(sz) {
        t.resize(4 * n, 0);
    }

    void upd(ll i, ll v) {
        upd(i, v, 1, 0, n - 1);
    }

    ll qry(ll l, ll r) {
        return qry(l, r, 1, 0, n - 1);
    }
};

vector<ll> solve(ll n, vector<ll>& a, ll q, vector<ll>& qrs) {
    vector<ll> res;
    SegmentTree st(n);
    vector<ll> b = a;
    sort(b.begin(), b.end());
    unordered_map<ll, ll> mp;
    for (ll i = 0; i < n; ++i) mp[b[i]] = i;

    auto cnt_inv = [&]() -> ll {
        ll inv = 0;
        for (ll i = n - 1; i >= 0; --i) {
            ll idx = mp[a[i]];
            inv += st.qry(0, idx - 1);
            st.upd(idx, 1);
        }
        for (ll i = 0; i < n; ++i) {
            st.upd(mp[a[i]], -1);
        }
        return inv;
    };

    for (ll x : qrs) {
        reverse(a.begin(), a.begin() + x);
        res.push_back(cnt_inv());
    }
    return res;
}

Reverse Inversion ✅

def transformMatrix(X):
    rows = len(X)
    cols = len(X[0])
    a = []
    for i in range(rows):
        new_row = []
        for j in range(cols):
            new_row.append(X[i][j])
            if j < cols - 1:
                new_row.append(X[i][j] + X[i][j + 1])
                new_row.append(X[i][j] - X[i][j + 1])
        a.append(new_row)
    return a

KPMG ✅

#include <bits/stdc++.h>
using namespace std;
struct ST {
    int n;
    vector<long long> t, lz;
    ST(int sz) {
        n = sz;
        t.resize(4 * n, 0);
        lz.resize(4 * n, 0);
    }
    void p(int nd, int s, int e) {
    if (lz[nd] != 0) {
    t[nd] += lz[nd];
    if (s != e) {
    lz[2 * nd + 1] += lz[nd];
    lz[2 * nd + 2] += lz[nd];
    }
    lz[nd] = 0;
    }
    }
    void ru(int nd, int s, int e, int l, int r, long long v) {
    p(nd, s, e);
    if (s > r || e < l) return;
    if (s >= l && e <= r) {
    lz[nd] += v;
    p(nd, s, e);
    return;
    }
    int m = (s + e) / 2;
    ru(2 * nd + 1, s, m, l, r, v);
    ru(2 * nd + 2, m + 1, e, l, r, v);
    t[nd] = max(t[2 * nd + 1], t[2 * nd + 2]);
    }
long long rq(int nd, int s, int e, int l, int r) {
p(nd, s, e);
if (s > r || e < l) return 0;
if (s >= l && e <= r) return t[nd];
int m = (s + e) / 2;
return max(rq(2 * nd + 1, s, m, l, r), rq(2 * nd + 2, m + 1, e, l, r));
}

void u(int l, int r, long long v) {
ru(0, 0, n - 1, l, r, v);
    }

    long long q(int l, int r) {
        return rq(0, 0, n - 1, l, r);
    }
};

long long SkillUpdate(int n, int q, vector<tuple<int, int, int>>& u) {
    ST st(n);
    vector<long long> mx(q, 0);
    for (auto& [l, r, x] : u) {
        st.u(l - 1, r - 1, x);
    }

    for (int i = 0; i < q; i++) 
    {
        auto [l, r, x] = u[i];
        st.u(l - 1, r - 1, -x);
        mx[i] = st.q(0, n - 1);
        st.u(l - 1, r - 1, x);
    }

    return *min_element(mx.begin(), mx.end());
}

Minimize and Maximum✅

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
int main(){
     int n;
     cin>>n;
     vector<int>arr(n);
     for(int i=0;i<n;i++)cin>>arr[i];
     vector<int>presum(n);
     presum[0]=arr[0];
     for(int i=1;i<n;i++)presum[i]=presum[i-1]+arr[i];
     vector<int>dp(n); 
     vector<int>val(n);
     dp[0]=1;
     val[0]=arr[0];

     for(int i=1;i<n;i++){
        
        int l=0,h=i;
        int ind=0;
        while(h>=l){
          int mid=(l+h)/2;
          int sum= presum[i]- (mid>0?presum[mid-1]:0);
          int prev = (mid>0?val[mid-1]:0);
          if(sum>=prev){
            ind=mid;
            l=mid+1;
          }
          else h=mid-1;
        }
        if(ind==0){
          dp[i]=1;
          val[i]=presum[i];
        }
        else{
          dp[i]=dp[ind-1]+1;
          val[i]=presum[i]-presum[ind-1];
        }
     }
     cout<<dp.back();
}

 
Operate the subarray✅

📌SurveySparrow Hiring
Role: Quality Assurance Intern

Experience: 0 - 6 months

Eligibility: Students from the 2024 batch
Internship Duration: 4 to 6 months
Location: Chennai (Work from Office)
THIS IS AN INTERN ONLY OPPORTUNITY

💻Apply Link: https://surveysparrow.keka.com/careers/jobdetails/12253