#include <iostream>
#include <cmath>
#include <iomanip>

using namespace std;

long double pi = 3.14159265358979323846;

long double volume(long double h, long double r) {
    return pi * h * h * (r - h/3);
}

long double find_height(long double r, long double v) {
    long double low = 0, high = r;
    long double eps = 1e-18;

    while (high - low > eps) {
        long double mid = (low + high) / 2;
        if (volume(mid, r) < v) {
            low = mid;
        } else {
            high = mid;
        }
    }
    return low;
}

int main() {
    long double r, v;
    cin >> r >> v;

    long double h = find_height(r, v);
    cout << fixed << setprecision(7) << h << endl;

    return 0;
}
Astrome || Binary Search✅

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

using namespace std;

string sortWord(string word) {
    transform(word.begin(), word.end(), word.begin(), ::tolower);
    vector<char> charArr(word.begin(), word.end());
    int sum = 0;
    for (char ch : charArr) {
        sum += ch - 'a' + 1;
    }
    sort(charArr.begin(), charArr.end());
    if (sum % 2 == 0) {
        return string(charArr.begin(), charArr.end());
    }
    reverse(charArr.begin(), charArr.end());
    return string(charArr.begin(), charArr.end());
}

int main() {
    string s;
    getline(cin, s);
    vector<string> strArr;
    size_t pos = 0;
    string delimiter = "-";
    while ((pos = s.find(delimiter)) != string::npos) {
        strArr.push_back(s.substr(0, pos));
        s.erase(0, pos + delimiter.length());
    }
    strArr.push_back(s);
   
    sort(strArr.begin(), strArr.end(), [](string a, string b) {
        transform(a.begin(), a.end(), a.begin(), ::tolower);
        transform(b.begin(), b.end(), b.begin(), ::tolower);
        return a < b;
    });
   
    transform(strArr.begin(), strArr.end(), strArr.begin(), sortWord);
   
    string result = strArr[0];
    for (int i = 1; i < strArr.size(); i++) {
        result += "-" + strArr[i];
    }
    cout << result << endl;

    return 0;
}
Astrome||Sort Word✅

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

string multiply(string num1, string num2) {
    int len1 = num1.size();
    int len2 = num2.size();

    if (len1 == 0 len2 == 0) {
        return "0";
    }

    vector<int> result(len1 + len2, 0);
    int i_n1 = 0;
    int i_n2 = 0;

    for (int i = len1 - 1; i >= 0; i--) {
        int carry = 0;
        int n1 = num1[i] - '0';
        i_n2 = 0;

        for (int j = len2 - 1; j >= 0; j--) {
            int n2 = num2[j] - '0';
            int sum = n1 * n2 + result[i_n1 + i_n2] + carry;
            carry = sum / 10;
            result[i_n1 + i_n2] = sum % 10;
            i_n2++;
        }

        if (carry > 0) {
            result[i_n1 + i_n2] += carry;
        }

        i_n1++;
    }

    int i = result.size() - 1;
    while (i >= 0 && result[i] == 0) {
        i--;
    }

    if (i == -1) {
        return "0";
    }

    string s = "";
    while (i >= 0) {
        s += to_string(result[i--]);
    }

    return s;
}

int main() {
    string str1, str2;
    cin >> str1 >> str2;

    if ((str1.at(0) == '-' str2.at(0) == '-') &&
        (str1.at(0) != '-' str2.at(0) != '-')) {
        cout << "-";
    }

    if (str1.at(0) == '-') {
        str1 = str1.substr(1);
    }

    if (str2.at(0) == '-') {
        str2 = str2.substr(1);
    }

    cout << multiply(str1, str2);

    return 0;
}
Astrome Big Integer Multiplication ✅

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

int main() {
    string s;
    getline(cin, s);

    stringstream ss(s);
    string word;

    vector<string> v;
    while(ss >> word) {
        v.push_back(word);
    }


    int ans = 0;

    int n = v.size();

    for(int i = 0; i < v.size(); i++) {
        if(v[i] == "null")
            continue;
       
        int left = 2 * i + 1;
        int leftSum = 0;

        while(left < n){
            if(v[left] == "null")
                break;
            leftSum += stoi(v[left]);
            left = 2 * left + 1;
        }

        int right = 2 * i + 2;
        int rightSum = 0;

        while(right < n){
            if(v[right] == "null")
                break;
            leftSum += stoi(v[right]);
            right = 2 * right + 2;
        }

        if(2 * i + 1 >= n or 2 * i + 2 >= n){
            break;
        }
        else if(leftSum + rightSum == 0){
            ans++;
        }
    }

    cout << ans;
}

Company Name: ful.io

Role: Software Developer Intern

Batch eligible: 2024 and 2025 grads

Stipend: 10k per month

Apply: https://bit.ly/3P4DWnL

def find_submatrix(board, pattern):
    def is_match(x, y):
        current_subs = substitutions.copy()
       
        for i in range(len(pattern)):
            for j in range(len(pattern[0])):
                if pattern[i][j].isalpha():
                    if pattern[i][j] not in current_subs:
                        current_subs[pattern[i][j]] = board[x+i][y+j]
                    elif current_subs[pattern[i][j]] != board[x+i][y+j]:
                        return False
                else:
                    if board[x+i][y+j] != pattern[i][j]:
                        return False
        return True
   
    earliest_match = [-1, -1]
   
    for x in range(len(board) - len(pattern) + 1):
        for y in range(len(board[0]) - len(pattern[0]) + 1):
            substitutions = {}
           
            if is_match(x, y):
                return [x, y]
   
    return earliest_match

# Example usage
board = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 1, 2, 3]
]

pattern = [
    ['A', 'B'],
    ['C', 'D']
]

result = find_submatrix(board, pattern)
print(f"Pattern found at coordinates {result}")  # Prints the earliest match or [-1, -1]

bool isNextLetter(char s, char t) {
    int distance = (t - s + 26) % 26;
    return distance == 1;
}

bool areAllNextLetters(const std::string& s, const std::string& t) {
    if (s.length() != t.length()) {
        return false; // Different lengths, not comparable
    }

    for (std::size_t i = 0; i < s.length(); ++i) {
        if (!isNextLetter(s[i], t[i])) {
            return false; // Found a position where the condition doesn't hold
        }
    }

    return true; // All positions satisfy the condition
}

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n;cin>>n;int A[n];for(int i=0;i<n;i++)cin>>A[i];vector<vector<int>>minim(n,vector<int>(n,INT_MAX));
    for(int i=0;i<n;i++)minim[i][i]=i;
    for(int size=2;size<=n;size++)for(int st=0;st<=n-size;st++)
    {
        int en=st+size-1;
        if(A[minim[st+1][en]]>=A[st])minim[st][en]=st;else minim[st][en]=minim[st+1][en];
    }int dp[n+3][n+3];memset(dp,0,sizeof(dp));
    for(int i=0;i<n;i++)dp[i][i]=A[i];
    for(int size=2;size<=n;size++)for(int st=0;st<=n-size;st++)
    {
        int en=st+size-1;int x=minim[st][en];
        dp[st][en]=A[x];if(x-2>=0)dp[st][en]+=dp[st][x-2];if(x+2<=n)dp[st][en]+=dp[x+2][en];
    }cout<<dp[0][n-1];return 0;
}

Airtel ✅

def shorten_string(s):
    stack = []
    for char in s:
        if stack and stack[-1] == char:
            stack.pop()
        else:
            stack.append(char)
    return ''.join(stack) if stack else "Empty String"

s = input().strip()
print(shorten_string(s))

class Solution {
public:
    long long maxValue(int n, int arr[]) {
        long long max_geek_value = 0;
       
        int max_right[n];
        max_right[n - 1] = arr[n - 1];
       
        for (int i = n - 2; i >= 0; --i) {
            max_right[i] = max(max_right[i + 1], arr[i]);
        }
       
        int max_left = arr[0];
       
        for (int i = 1; i < n - 1; ++i) {
            long long geek_value = static_cast<long long>(max_left - arr[i]) * max_right[i + 1];
            max_geek_value = max(max_geek_value, geek_value);
            max_left = max(max_left, arr[i]);
        }
       
        return max(max_geek_value, 0LL);
    }
};  GFG |JOB-THON 1

class Solution {
    Map<Integer, Boolean> mp = new TreeMap<>();

    public long MaxScore(int N, int arr[]) {
        int n = arr.length - 1;
        long dp[][] = new long[n + 1][n + 1];
        for (long[] a : dp)
            Arrays.fill(a, -1);
        return solve(0, n, arr, dp);
    }

    public long solve(int f, int b, int[] arr, long[][] dp) {
        if (b < f)
            return 0;
        if (dp[f][b] != -1)
            return dp[f][b];
        long min = mi(f, b, arr);
        long p1 = (long) arr[f] * (long) (b - f + 1) + min + solve(f + 1, b, arr, dp);
        long p2 = (long) arr[b] * (long) (b - f + 1) + min + solve(f, b - 1, arr, dp);
        return dp[f][b] = Math.max(p1, p2);
    }

    public long mi(int f, int b, int[] arr) {
        long min = Long.MAX_VALUE;
        for (int i = f; i <= b; i++) {
            min = Math.min(min, (long) arr[i]);
        }
        return min;
    }
} Job-thon 2

class Solution
{
    public:
    vector<int> geeksJourney(vector<int>& geeksTown, int n, vector<int>& journey, int m, vector<vector<int>>& queries, int q)
    {
        // code here
        vector<int> result;
        vector<pair<int, int>> subarrayIndices;

        for (int i = 0; i <= m - n; ++i) {
            bool match = true;
            for (int j = 0; j < n; ++j) {
                if (geeksTown[j] != journey[i + j]) {
                    match = false;
                    break;
                }
            }
            if (match) {
                subarrayIndices.push_back(make_pair(i, i + n - 1));
            }
        }

        for (int i = 0; i < q; ++i) {
            int left = queries[i][0];
            int right = queries[i][1];
            int count = 0;

            for (const auto& indices : subarrayIndices) {
                if (indices.first >= left && indices.second <= right) {
                    ++count;
                }
            }

            result.push_back(count);
        }

        return result;
    }
}; jon - thon 3

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

int solution(vector<string>&v, int n){
   int ans=0,count;
   for(int i=0; i<v.size(); i++){
       count=1;
       int idx=-1;
       int strln = v[i].length();
       for(int j=1; j<strln; j++){
           if(v[i][j]==v[i][j-1]) count++;
           else{
               if(count==n) ans++;
               count=1;
               idx=j;
           }
       }
       if(idx!=strln-1)
       if(count==n) ans++;
   }
   return ans;
}

int main() {
   int n,m; cin>>n>>m;
   vector<string>v(m);
   for(int i=0; i<m; i++) cin>>v[i];
   cout<<solution(v,n)<<endl;
    return 0;
}

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

int solve(vector<vector<int>>&v, vector<vector<int>>&vis, int x, int y, int sum,int dx, int dy){
   if(vis[x][y]) return sum;
   if((x==0 and y==0) (x==0 and y==v[0].size()-1) (x==v.size()-1 and y==0) (x==v.size()-1 and y==v[0].size()-1)){
      sum+=v[x][y];
       return sum;
   }
   sum+=v[x][y];
   vis[x][y]=1;
   if(x+dx==v.size() x+dx<0){
       if(dx==1) dx=-1;
       else dx=1;
   }
   if(y+1==v[0].size() || y+dy<0){
       if(dy==1) dy=-1;
       else dy=1;
   }
   return solve(v,vis,x+dx,y+dy,sum,dx,dy);
}

int solution(vector<vector<int>>&v, int x, int y){
    int n=v.size();
    int m=v[0].size();
    vector<vector<int>>vis(n,vector<int>(m,0));
    return solve(v,vis,x,y,0,1,1);
}
signed main(){
    int n,m,x,y;
    cin>>n>>m>>x>>y;
    vector<vector<int>>v(n,vector<int>(m,0));
    for(int i=0; i<n; i++)
    for(int j=0; j<m; j++) cin>>v[i][j];
    cout<<solution(v,x,y)<<endl;
    return 0;
}

Visa ROBOT Traversal✅

Flexi Analyst is Hiring !!

Role: Software Engineer Intern

Batch: 2024, 2025

Apply: https://www.linkedin.com/jobs/view/3692344146

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

vector<int> Solve(int N, int K) {
    vector<int> slots(K, 0);

    int bagCount = 1;
    while (N > 0) {
        for (int i = 0; i < K && N > 0; ++i) {
            if (bagCount <= N) {
                slots[i] += bagCount;
                N -= bagCount;
                bagCount++;
            } else {
                slots[i] += N;
                N = 0;
            }
        }
    }

    return slots;
}

int main() {
    int N, K;
    cin >> N >> K;
    vector<int> result = Solve(N, K);
    for (int bags : result) {
        cout << bags << " ";
    }
    cout << endl;
    return 0;
}

Bag Distribution Algorithm C++✅

Company Name: Zerodha

Role: Frontend Intern

Batch eligible: 2024 grads only

Apply: https://careers.zerodhafundhouse.com/jobs/ybkmnewaO6cf/frontend-intern