#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
int main() {
    int N;
    cin >> N;
    vector<int> squareFreeDivisorCount(N + 1, 0);
    long long count = 0;
    for (int i = 1; i <= N; ++i) {
        for (int j = i; j <= N; j += i) {
            int product = i * j;
            int root = sqrt(product);
            if (root * root == product) {
                if (i == j)
                    count = (count + 1) % MOD; 
                else
                    count = (count + 2) % MOD;
            }
        }
    }

    cout << count << endl;
    return 0;
}

Square investment ✅

I'm rooting for your success more than you do...♥️

def getInaccurateProcesses(processOrder, executionOrder):
    class FenwickTree:
        def __init__(self, size):
            self.size = size
            self.tree = [0] * (size + 2)  

        def update(self, index, delta=1):
            while index <= self.size:
                self.tree[index] += delta
                index += index & -index

        def query(self, index):
            res = 0
            while index > 0:
                res += self.tree[index]
                index -= index & -index
            return res

        def range_query(self, left, right):
            if left > right:
                return 0
            return self.query(right) - self.query(left -1)

    n = len(processOrder)
    pid = {}
    for idx, process in enumerate(processOrder):
        pid[process] = idx

    ft = FenwickTree(n)

    inaccurate =0

    for process in executionOrder:
        index = pid[process] 
        fti = index +1
        count = ft.query(fti -1)
        if count != index:
            inaccurate +=1
        ft.update(fti)
    
    return inaccurate

Amazon ✅

def solve(a, b, k):
    n = len(a)
    r = 0
    for i in range(n):
        x = a[i]
        y = b[n - 1 - i]
        v = int(str(x) + str(y))
        if v < k:
            r += 1
    return r

Motive✅

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

class DSU {
    vector<int> parent, rank;
public:
    DSU(int n) {
        parent.resize(n + 1);
        rank.resize(n + 1, 0);
        for (int i = 0; i <= n; i++) {
            parent[i] = i;
        }
    }

    int find(int u) {
        if (u != parent[u]) {
            parent[u] = find(parent[u]);
        }
        return parent[u];
    }

    void unite(int u, int v) {
        int root_u = find(u);
        int root_v = find(v);
        if (root_u != root_v) {
            if (rank[root_u] > rank[root_v]) {
                parent[root_v] = root_u;
            } else if (rank[root_u] < rank[root_v]) {
                parent[root_u] = root_v;
            } else {
                parent[root_v] = root_u;
                rank[root_u]++;
            }
        }
    }
};

int solve(int n, vector<vector<int>>& edges) {
    
    sort(edges.begin(), edges.end(), [](vector<int>& a, vector<int>& b) {
        return a[2] > b[2];
    });

    DSU dsu(n);
    int mst_weight = 0;
    int total_weight = 0;

    for (const auto& edge : edges) {
        total_weight += edge[2];
    }

    for (const auto& edge : edges) {
        int u = edge[0], v = edge[1], w = edge[2];
        if (dsu.find(u) != dsu.find(v)) {
            dsu.unite(u, v);
            mst_weight += w;
        }
    }

    return total_weight - mst_weight;
}

int main() {
    int t;
    cin >> t;
    while (t--){
        int n;
        cin >> n;
        vector<vector<int>> edges(n - 1);

        for (int i = 0; i < n - 1; i++) {
            int u, v, w;
            cin >> u >> v >> w;
            edges[i] = {u, v, w};
        }

        cout << solve(n, edges) << endl;
    }

    return 0;
}

Break and Add ✅
Google

import math
def ss(arr):
    n = len(arr)
    if n == 1:
        return 0 
    a = [0] * n
    b = [0] * n
    a[0] = arr[0]
    for i in range(1, n):
        a[i] = math.gcd(a[i - 1], arr[i])
    b[n - 1] = arr[n - 1]
    for i in range(n - 2, -1, -1):
        b[i] = math.gcd(b[i + 1], arr[i])
    m = 0
    for i in range(n):
        if i == 0:
            q = b[1]
        elif i == n - 1:
            q = a[n - 2]
        else:
            q = math.gcd(a[i - 1], b[i + 1])
        m = max(m, q)
    return m

Score Maximize ✅

def solve(N, candies):
    a = set()
    b = set()
    for candy in candies:
        if 'a' <= candy <= 'z':
            a.add(candy)
        elif 'A' <= candy <= 'Z':
            b.add(candy)
    d = ''
    for large in b:
        small = large.lower()
        if small in a:
            if d == '' or large > d:
                d = large
    return d if d else '0'

Candy Pairs ✅

def ss(n, arr):
    a = 0
    b = set([0])
    c = 0
    for num in arr:
        a += num
        if a in b:
            c += 1
            a = num
            b = set([0, a]) 
        else:
            b.add(a)
    return c

Pretty Array ✅

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

using namespace std;

long long help(vector<long long>& a, long long l, long long n, long long max_price) {
    for (long long i = 0; i < n; i++)
        a[i] = (i + 1) * l + a[i];
    
    sort(a.begin(), a.end());
    long long sum = 0;
    for (long long i = 0; i < l; i++) {
        sum += a[i];
    }
    return sum <= max_price;
}

int getMaxSubsequenceLen(vector<int> arr, long long max_sum) {
    long long n = arr.size();
    vector<long long> a(n);
    
    for (long long i = 0; i < n; i++) {
        a[i] = static_cast<long long>(arr[i]);
    }
    
    long long ans = 0;
    long long l = 0, r = n;
    
    while (l <= r) {
        long long mid = (l + r) / 2;
        if (help(a, mid, n, max_sum)) {
            ans = mid;  
            l = mid + 1;  
        } else {
            r = mid - 1;  
        }
    }
    
    return ans+1;  
}

DE Shaw ✅

📌Bottomline is hiring Associate Software Engineer

For 2023, 2024 grads
Location: Multiple

💻Apply:
https://boards.greenhouse.io/bottomlinetechnologies/jobs/7666351002

Company: Google
Role: Associate Product Manager

Batch : 2024/2025 from a degree related to PM, CS, Maths or Data Science. 
The application starts on 28th of October.

Apply : https://www.google.com/about/careers/applications/jobs/results/124204114060944070-associate-product-manager-university-graduate-2025-start

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

string nextBeautifulString(string s, int n, int k) {
    for (int i = n - 1; i >= 0; --i) {
        if (s[i] < 'a' + k - 1) {
            s[i]++;
            fill(s.begin() + i + 1, s.end(), 'a');
            
            for (int j = 1; j < n; ++j) {
                if (s[j] == s[j - 1]  (j > 1 && s[j] == s[j - 2])) {
                    if (s[j] < 'a' + k - 1) {
                        s[j]++;
                        fill(s.begin() + j + 1, s.end(), 'a');
                    } else {
                        return "-1";
                    }
                }
            }
            
            bool valid = true;
            for (int j = 1; j < n; ++j) {
                if (s[j] == s[j - 1]  (j > 1 && s[j] == s[j - 2])) {
                    valid = false;
                    break;
                }
            }
            if (valid) return s;
            else return "-1";
        }
    }
    return "-1";
}

int main() {
    int t;
    cin >> t;
    while (t--) {
        int n, k;
        string s;
        cin >> n >> k >> s;
        
        cout << nextBeautifulString(s, n, k) << endl;
    }
    return 0;
}

Beautiful Strings
Google ✅

Company Name: Palo Alto Network
Role: Software Engineer
Batch eligible: 2025 grads

Apply: https://jobs.paloaltonetworks.com/en/job/-/-/47263/71837933584

ACL Digital (An Alten Group Company) is hiring Freshers for Chennai Location.

Qualification - B.Tech/B.E-(CS, ECE, EEE) only

Experience 0-1 year

Mandatory skills - C, C++,embedded, linux, unit testing

Good to have - Python
Academics - above 70%

Interested candidates can share your resume to nishi.r@acldigital.com

int cleanupDataset(string dataset, int x, int y){
    vector<int> F(26, 0);
    for(char ch : dataset) F[ch - 'a']++;
    int ans = 0;
    if(x <= y){
        int cnt = 0;
        for(int num : F) ans += x * (num >> 1) , cnt += num & 1;
        ans += y * (cnt >> 1);
    }
    else{
        priority_queue<int> pq;
        for(int num : F) if(num) pq.push(num);
        while(pq.size() > 1){
            int x1 = pq.top(); pq.pop();
            int x2 = pq.top(); pq.pop();
            int rem = min(x1, x2);
            ans += y * rem;
            if(max(x1, x2) - rem) pq.push(max(x1 , x2) - rem);
        }
        if(pq.size()){
            int rem = pq.top(); pq.pop();
            ans += x * (rem >> 1);
        }
    }
    return ans;
}

Amazon ✅

def findminimumvariance(n, height):
    freq = {}
    mini = float('inf')
    for i in range(n):
        if height[i] in freq:
            s = freq[height[i]]
            sub = i - s + 1
            fir = height[s]
            cnt = height[s:i + 1].count(fir)
            var = sub - cnt
            mini = min(mini, var)
        freq[height[i]] = i
    if mini == float('inf'):
        return 0
    return mini

Amazon ✅

def getMaxEqualIndices(inv1, inv2):
    n = len(inv1)
    sinv1 = sum(inv1)
    sinv2 = sorted(inv2)
    
    prefixSum = [0] * (n + 1)
    for i in range(n):
        prefixSum[i + 1] = prefixSum[i] + sinv2[i]
    
    left = 0
    right = n
    
    while left < right:
        mid = (left + right + 1) // 2
        if mid < n:
            if prefixSum[mid] <= sinv1:
                left = mid
            else:
                right = mid - 1
        else:  
            if prefixSum[mid] == sinv1:
                left = mid
            else:
                right = mid - 1
    
    return left

Amazon ✅