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

int main() {
    string str;
    cin >> str;

    vector<int> count(26, 0); // Initialize count for each alphabet letter to 0

    for (int i = 0; i < str.size(); i++) {
        int index = str[i] - 'a'; // Convert character to corresponding index in count array
        cout << str[i] << ":" << count[index] << " ";
        cout<<endl;// Output letter and its count
        count[index]++; // Increment count for current letter
    }

    return 0;
}

Hacks on Amazon ✅

6/9 Test cases passed ✅
Hacks on Amazon

Swish Club is hiring Product Management Intern

For 2024 grads

Check out this job at Swish Club: https://www.linkedin.com/jobs/view/3936821216

Victoria's Secret and Co is hiring Associate Software Engineer

Location - Bangalore

For 2023, 2022 grads

https://careers.victoriassecret.com/job-2/20193431

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
#include <climits>
using namespace std;
vector<int> dijkstra(int start, int end, const vector<vector<int>>& graph, int N) {
    vector<int> dist(N + 1, INT_MAX);
    dist[start] = 0;
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    pq.push({0, start});
    while (!pq.empty()) {
        int d = pq.top().first;
        int u = pq.top().second;
        pq.pop();
        if (d > dist[u]) continue;
        for (int v : graph[u]) {
            if (dist[u] + 1 < dist[v]) {
                dist[v] = dist[u] + 1;
                pq.push({dist[v], v});
            }
        }
    }
    return dist;
}
vector<int> solution(const vector<int>& A, const vector<int>& B, int N) {
    vector<vector<int>> graph(N + 1);
    for (int i = 1; i < N; ++i) {
        graph[i].push_back(i + 1);
        graph[i + 1].push_back(i);
    }
    vector<int> initial_dist = dijkstra(1, N, graph, N);
    vector<int> results;
    for (int i = 0; i < A.size(); ++i) {
        graph[A[i]].push_back(B[i]);
        graph[B[i]].push_back(A[i]);
        vector<int> new_dist = dijkstra(1, N, graph, N);
        results.push_back(new_dist[N]);
    }
    return results;
}

Hashedin ✅

#include <vector>
#include <iostream>
#include <algorithm>
#include <climits>
using namespace std;
int solution(vector<vector<int>>& chessboard) {
    int N = chessboard.size();
    vector<vector<pair<int, int>>> topTwoMax(N, vector<pair<int, int>>(2, {0, -1}));
    for (int i = 0; i < N; ++i) {
        int max1 = INT_MIN, max2 = INT_MIN;
        int idx1 = -1, idx2 = -1;

        for (int j = 0; j < chessboard[i].size(); ++j) {
            if (chessboard[i][j] >= max1) {
                max2 = max1;
                idx2 = idx1;
                max1 = chessboard[i][j];
                idx1 = j;
            } else if (chessboard[i][j] > max2) {
                max2 = chessboard[i][j];
                idx2 = j;
            }
        }

        topTwoMax[i][0] = {max1, idx1};
        topTwoMax[i][1] = {max2, idx2};
    }

    int maxSum = 0;
    for (int i = 0; i < N; ++i) {
        for (int j = i + 1; j < N; ++j) {
            int sum = topTwoMax[i][0].first + topTwoMax[j][0].first;
            if (topTwoMax[i][0].second != topTwoMax[j][0].second) {
                maxSum = max(maxSum, sum);
            } else {
                sum = max(topTwoMax[i][0].first + topTwoMax[j][1].first,
                          topTwoMax[i][1].first + topTwoMax[j][0].first);
                maxSum = max(maxSum, sum);
            }
        }
    }

    return maxSum;
}

def solution(numbers, pivot):
    count_greater = 0
    count_less = 0

    for num in numbers:
        if num > pivot:
            count_greater += 1
        elif num < pivot:
            count_less += 1

    if count_greater > count_less:
        return "greater"
    elif count_greater < count_less:
        return "smaller"
    else:
        return "tie"

Autodesk ✅

#include <iostream>
#include <vector>

using namespace std;

int solution(vector<int> &numbers) {
    for (size_t i = 1; i < numbers.size(); ++i) {
        if ((numbers[i] % 2) == (numbers[i - 1] % 2)) {
            return i;
        }
    }
    return -1;
}

Autodesk ✅

In case you’re from Delhi NCR (2023 and 2024 grads)

Accenture Interview Experience :

Introduction
Hobbies
Talk on virat Kohli
Chees
Programming language
Oops
C++ and java difference
Why Accenture
Project
Your role
Technology
Strength
Weakness

public boolean robotRectangle(String moves){
        if(moves.length()<1) return false;
        int upDown=0, rightLeft=0;
        char[] movesArr= moves.toCharArray();
        for(int i= 0; i< movesArr.length; i++){
            if(movesArr[i] == '^')  upDown++;
            else if(movesArr[i] == 'v')  upDown--;
            else if(movesArr[i] == '>')  rightLeft++;
            else if(movesArr[i] == '<')  rightLeft--;
        }
        return upDown== 0 && rightLeft== 0?true:false;   
    }

#include <iostream>
#include <unordered_map>
#include <string>

using namespace std;

int solution(vector<int> &A) {
    int max_sum = -1; 

    unordered_map<int, int> same_digits; 

    for (int num : A) {
        int first_last = stoi(to_string(num).substr(0, 1) + to_string(num).substr(to_string(num).length() - 1)); 
        if (same_digits.find(first_last) != same_digits.end()) {
            max_sum = max(max_sum, same_digits[first_last] + num);
        } else {
            same_digits[first_last] = num;
        }
    }

    return max_sum;
}

Company Name: Swiggy

🛄 Job Title: SDET
✍🏻 YOE: 0-2 years

➡️ Apply: https://docs.google.com/forms/d/1cr-Z3bwEP9g4UtBlDfD76EHXuS7UuYt9l3fGHo35jSQ/viewform?edit_requested=true

Please do share in your college grps and in case you are applying please react on this post:) 😇❤️