Company Name : Odoo

Role : Software Developer Internship - 4 Months

Batch : 2024 passouts

Stipend : 20,000 INR per month

Link : https://www.odoo.com/jobs/software-developer-intern-rs20000-00-month-stipend-685

Company Name: Cornerstone

Role: Junior Engineer (Testing Role)

Batch eligible: 2023 and 2024 passouts

Apply: https://cornerstone.csod.com/ux/ats/careersite/2/home/requisition/9133?c=cornerstone

Analyst Position at Dassault Systèmes

Location - Pune

Qualifications/Experience:
- Bachelor’s Degree in Business, Finance, or Accounting (equivalent work experience considered)
- 0 to 1-year experience in finance and accounting streams preferred
- Excellent communication skills (verbal and written)
- Proficient with MS Office (Excel, Word, and PowerPoint)
- Strong analytical skills and a good team player
- Keen learner with a positive attitude
- Structured, disciplined, and flexible approach towards work
- Ability to work in cross-functional teams with a solution-finding approach
- Able to work in multiple and culturally different environments
- Able to maintain high quality in all deliverables and according to the operating principles
- Education: BCom/BCA/MCom/MBA-Finance/MBA-Marketing (Only passouts candidates)
- Immediate Joiners will be preferred

Interested candidates, please send your CV to

ganesh.thik@3ds.com

Company Name: Credflow

Role: Backend Developer

Batch eligible: 2022 and 2023 passouts

CTC: 17-20 LPA

Apply: https://bit.ly/48RnuhZ

#include <iostream>
#include <vector>

using namespace std;

vector<vector<int>> Availability(int N, vector<int> L, vector<int> R) {
    int cur = 0;
    vector<vector<int>> ans;
if (N == 0) {
        ans.push_back({0, 1000000000});
     }
    for (int i = 0; i < N; i++) {
        if (cur < L[i]) {
            ans.push_back({cur, L[i]});
        }
        cur = R[i];
    }

    if (cur < 1000000000) {
        ans.push_back({cur, 1000000000});
    }

    return ans;
}

Availability ✅

vector<string> solve(string t, int Q, vector<string> q) {
    stringstream ss(t);
    string tk;
    vector<string> p;
    while (getline(ss, tk, '\"')) {
        p.push_back(tk);
    }

    vector<string> r;
    for (string qry : q) {
        size_t pos = qry.find_last_of('.');
        qry = qry.substr(pos + 1);
        int j = 0;
        for (j = 0; j < p.size(); j++) {
            if (p[j] == qry) {
                break;
            }
        }
        r.push_back(p[j + 2]);
    }
    return r;
}

Json parsing ✅

#include<bits/stdc++.h>
using namespace std;
    
int findMessages (int N, vector<string> A) {
    int ans=N;
    set<string> st;

    for(int i=0; i<N; i++) {
        string s;
        for(int j=0; j<A[i].size(); j++)
            s += 'a' + ('z' - A[i][j]);
       
        if (st.find(s) != st.end())
            ans -= 1;

        st.insert(A[i]);
    }

    return ans;
}
    
int main() {
    
    ios::sync_with_stdio(0);
    cin.tie(0);
    int N;
    cin >> N;
    vector<string> A(N);
    for(int i_A = 0; i_A < N; i_A++)
    {
        cin >> A[i_A];
    }
    
    int out_;
    out_ = findMessages(N, A);
    cout << out_;
}

Alice and messages ✅

def solve(N, A, D, V):
    info_index = {
        'bank_account_number': 0,
        'account_holder_first_name': 1,
        'account_holder_last_name': 2,
        'registered_mobile_number': 3,
        'branch_code': 4
    }
   
    filtered_accounts = [account for account in A if str(account[info_index[D]]) == V]
    sorted_accounts = sorted(filtered_accounts, key=lambda x: int(x[0]))

    output = "\n".join([" ".join(map(str, account)) for account in sorted_accounts])
    return output

N = int(input())
A = []
for _ in range(N):
    account_info = input().split()
    account_info[0] = int(account_info[0])
    account_info[3] = int(account_info[3])
    account_info[4] = int(account_info[4])
    A.append(account_info)

D = input()
V = input()

result = solve(N, A, D, V)
print(result)

Searching google pay saved account ✅

def getSeatsAllocation(arr):
    n = len(arr)
    ppl = [[] for i in range(2 * n + 4)]
   
    for i, x in enumerate(arr):
        ppl[x].append(i)

    h = []
    ans = [-1] * n
   
    for pos in range(1, 2 * n + 1):
        for i in ppl[pos]:
            heapq.heappush(h, (-pos, i))
       
        if len(h) > 0:
            ans[heapq.heappop(h)[1]] = pos
   
    return ans

Queued Seats ✅

int lastStoneWeight(vector<int>& stones) {
    priority_queue<int> pq;
        for(auto &i: stones) pq.push(i);
       
        int a,b;
        while(pq.size()>1){
            a=pq.top();pq.pop();
            b=pq.top();pq.pop();
            if(a!=b)pq.push(abs(a-b));         
        }
        if(pq.empty())return 0;
        return pq.top();
    }

Last stone weight
Nivedia ✅

vector<int> solve(int N, const vector<vector<int>>& A, const vector<vector<int>>& queries) {
    vector<int> results;
    results.reserve(queries.size());

    for (const auto& query : queries) {
        int l = query[0];
        int r = query[1];
        int x = query[2];
        int count = 0;

        for (int i = l - 1; i < r; ++i) {
            if (A[i][1] > x) {
                ++count;
            }
        }

        results.push_back(count);
    }

    return results;
}

//Partial 6/10

Tax Payment ✅

def PowerLimit(a, b):
  current_resource, max_seconds = 1, 0
  while a > 0 and b > 0:
    if a > b:
      current_resource, a, b = 1, a - 2, b + 1
    else:
      current_resource, b, a = 2, b - 2, a + 1
    max_seconds += 1
  max_seconds += a // 2 if current_resource == 1 else b // 2
  return max_seconds

power limit ✅

long long OneBlock(int N, vector<int> Arr) {
    vector<int> one_indices;
    for (int i = 0; i < N; ++i) {
        if (Arr[i] == 1) {
            one_indices.push_back(i);
        }
    }

    if (one_indices.size() <= 1) {
        return 1;
    }

    long long ways = 1;
    for (int i = 1; i < one_indices.size(); ++i) {
        int zeros_between_ones = one_indices[i] - one_indices[i - 1] - 1;
        ways *= (zeros_between_ones + 1);
    }

    return ways;
}

//one block

string solve(int n, string op[]) {
    stack<string> bs, fs;
    bs.push("/home");

    for(int i = 0; i < n; i++) {
        if(op[i] == "back") {
            if(bs.size() > 1) {
                fs.push(bs.top());
                bs.pop();
            }
        } else if(op[i] == "forward") {
            if(!fs.empty()) {
                bs.push(fs.top());
                fs.pop();
            }
        } else {
            while(!fs.empty()) {
                fs.pop();
            }
            bs.push(bs.top() + "/" + op[i]);
        }
    }

    return bs.top();
}

Browser history ✅

int main() {
    int N;
    cin >> N;
    vector<pair<int, int>> p(N);
    for(int i = 0; i < N; i++)
        cin >> p[i].first >> p[i].second;

    ll wt = 0, ct = 0;
    for(int i = 0; i < N) {
        if(p[i].first > ct) {
            ct = p[i].first;
        }
        wt += ct + p[i].second - p[i].first;
        ct += p[i].second;
    }
    cout << wt / N << endl;
    return 0;
}

Doctor ✅

def solveLC(key, text):
    def check(key, subt):
        res = []
        for i, (a,b) in enumerate(zip(key, subt)):
            if a != b:
                res.append(i)
        if len(res) == 1 or len(res) > 2:
            return False
        if not res: return True
        if res[0] + 1 != res[1]: return False
        i = res[0]
        return key[i:i+2] == subt[i:i+2][::-1]
    res = 0
    for i in range(len(text) - len(key) + 1):
        if check(key, text[i:i+len(key)]):
            res += 1
    return res
print(solveLC("moon","monomon"))
print(solveLC("aaa","aaaa"))

Amazon ✅