📌Suma Soft is Hiring for Software Developer (Freshers)

Location: Pune (Aundh)

Experience: Freshers

Notice Period - Immediate joiner only

Skill Set:
.NET & C#: Familiarity is key!
MVC Magic: Understand the MVC architecture.
Web Savvy: Basic knowledge of HTML, CSS, and JavaScript.
Entity Framework Enthusiast: Experience is a plus!
Problem Solver: Strong analytical thinking and a passion for learning.
Why Join Us?
Empowering Environment: Collaborate with a supportive team that values your growth.
Hands-On Experience: Work on exciting projects that make a real impact.
Career Development: Opportunities for continuous learning and professional advancement.


Share your resume: anamika.shukla@sumasoft.net

Company Name: 1% Club
Role: SDE Intern
Batch eligible: 2025 grads

Apply: https://docs.google.com/forms/d/e/1FAIpQLSePA4nDt2pn5Mo_JgEMQYxdiFEhsOvpUNrcZCyUvMKfAngU6A/viewform

Company Name: CRED
Role: Android Intern
Batch eligible: 2024 and 2025 grads

Apply: https://careers.cred.club/openings/4673bd6c-44ae-49e2-8a6a-c7bef447ccff

Company Name: Cisco
Role: Software Engineer Test
Batch eligible: 2025 grads

Apply: https://jobs.cisco.com/jobs/ProjectDetail/Software-Engineer-Test-Full-Time-India-Engineering-UHR/1431448

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

int solve(int n, vector<int>& front, vector<int>& back, int frontend, int backend) {
    vector<vector<int>> dp(n + 1, vector<int>(frontend + 1, INT_MAX));
    dp[0][0] = 0;

    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= frontend; j++) {
            if (dp[i][j] == INT_MAX) continue;
            if (j < frontend) {
                dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + front[i]);
            }
            int b = i - j;
            if (b < backend) {
                dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + back[i]);
            }
        }
    }

    return dp[n][frontend];
}

int32_t main() {
    int frontend, backend;
    cin >> frontend >> backend;
    int n = frontend + backend;
    vector<int> front(n), back(n);
    
    for (int i = 0; i < n; i++) {
        cin >> front[i];
    }
    for (int i = 0; i < n; i++) {
        cin >> back[i];
    }

    int result = solve(n, front, back, frontend, backend);
    cout << result << endl;

    return 0;
}

Hiring Drive ✅

#include <iostream>
#include <unordered_set>
#include <string>
using namespace std;
int password_strength(const string& password, int k) {
    unordered_set<string> u;

    if (k > password.length() || k <= 0) {
        return 0;
    }
    for (size_t i = 0; i <= password.length() - k; ++i) {
        string substring = password.substr(i, k);
        u.insert(substring);
    }

    return u.size();
}

Python: Password Strength ✅
BNY(Intern)

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

ll ss(ll A, ll B) {
    ll rounds = 0;
        while (A != B) {
        if (A > B) {
            A -= B;
        } else {
            B -= A;
        }
        rounds++; 
    }
    
    return rounds;
}

int main() {
    ll A, B;
    cin >> A >> B;
    cout << ss(A, B) << endl;
    return 0;
}

Rivals ✅

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

int solve(int n, int m, int x, vector<int>& a) {

    int rem = m % x;

    if (rem == 0) {
        return m % MOD;
    }

    int minAdd = -1;
    for (int i = 0; i < n; i++) {
        int add = a[i];
        if ((m + add) % x == 0) {
            if (minAdd == -1 || add < minAdd) {
                minAdd = add;
            }
        }
    }

    if (minAdd == -1) {
        return -1;
    }

    return (m + minAdd) % MOD;
}

int main() {
    int t; 
    cin >> t;
    
    while (t--) {
        int n, m, x;
        cin >> n >> m >> x;
        
        vector<int> a(n);
        for (int i = 0; i < n; i++) {
            cin >> a[i];
        }

        int res =solve(n, m, x, a);

        cout << res << endl;
    }

    return 0;
}

Greedy power ✅

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

int findOptimalityQuotient(std::vector<int> arr) {
    int n = arr.size();
    sort(arr.begin(), arr.end());
    vector<int> rearranged_arr = arr;
    sort(rearranged_arr.begin(), rearranged_arr.end());

    int greatness_arr = 0;
    int j = 0;

    for (int i = 0; i < n; i++) {
        while (j < n && rearranged_arr[j] <= arr[i]) {
            j++;
        }
        if (j < n) {
            greatness_arr++;
            j++;
        }
    }

    return greatness_arr * 2;
}

Twillo ✅

Twillo Maxsteps ✅

#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ff first
#define ss second
int32_t main(){
    ll n,m;
    cin>>n>>m;
    vector<ll> a(n);
    vector<ll> b(m);
    vector<ll> pre(n+1);
    for(int i=0;i<n;i++){
        cin>>a[i];
        pre[i+1]=pre[i]+a[i];
    }
    for(int i=0;i<m;i++){
        cin>>b[i];
    }
    ll k=(1LL<<m)-1;
    ll dp[n+1][k+1];
    for(int i=0;i<=n;i++){
        for(int j=0;j<=k;j++){
            dp[i][j]=0;
        }
    }
    for(int i=1;i<=n;i++){
        for(int j=0;j<=k;j++){
            dp[i][j]=max(dp[i][j],dp[i-1][j]);
            for(int l=0;l<m;l++){
                if((1LL<<l)&j){
                
                }
                else{
                    ll next=(1LL<<l)|j,idx=i+b[l]-1;
                    if(idx>=0 and idx<=n)
                    dp[idx][next]=max(dp[idx][next],dp[i-1][j]+pre[idx]-pre[i-1]);
                }
            }
        }
    }
    ll ans=0;
    for(int i=0;i<=n;i++){
        ans=max(dp[i][k],ans);
    }
    cout<<ans<<endl;
    return 0;
}

Seat Booking✅

#include <bits/stdc++.h>
using ll = long long ;
using namespace std;
ll calculateResult(vector<ll>& arr, ll n, ll k) {
    set<int> st;
    ll ans = 0;
    ll sum = 0;
    sort(arr.begin(), arr.end(), greater<int>());
    for (ll i = 0; i < n; i++) {
        if (st.find(arr[i]) != st.end()) {
            continue;
        }
        if (arr[i] - sum > 0) {
            sum += k;  
            ans++;    
            st.insert(arr[i]);  
        }
    }
    return ans;
}

Go Daddy ✅

#include <iostream>
#include <vector>
using namespace std;
vector<int> solve(const vector<int>& arr) {
    int n = arr.size();
    vector<int> result;
        for (int i = 0; i < n - 2; i++) {
        int a = arr[i];
        int b = arr[i + 1];
        int c = arr[i + 2];
                if (a + b > c && a + c > b && b + c > a) {
            result.push_back(1);
        } else {
            result.push_back(0);
        }
    }
    
    return result;
}

Motive (SWE) ✅

#include <iostream>
#include <vector>
int solve(vector<int>& visits, int target) {
    int n = visits.size();
    for (int i = 0; i < n; ++i) {
        int sum = 0;
        for (int j = 0; j <= i; ++j) {
            sum += visits[j];
        }
        if (sum >= target) {
            return i;
        }
    }
   
    return -1;
}

Databricks ✅

#include <bits/stdc++.h>
using ll = long long ;
using namespace std;
bool isPalindrome(int number) {
    string str =to_string(number);
    int left = 0, right = str.size() - 1;
    while (left < right) {
        if (str[left] != str[right]) {
            return false;
        }
        left++;
        right--;
    }
    return true; 
}
vector<int> findPalindromicTransactions(vector<int>& transactions) {
    std::vector<int> palindromicIDs;
    for (int transaction : transactions) {
        if (isPalindrome(transaction)) {
            palindromicIDs.push_back(transaction);
        }
    }

    sort(palindromicIDs.begin(), palindromicIDs.end(),greater<int>());

    return palindromicIDs; 
}

Databricks ✅