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

const int MOD = 10000;

int countArrays(string &S, int C, int K) {
    int N = S.length();
    vector<int> dp(N + 1, 0);
    dp[0] = 1;  

    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= K && j <= i; j++) {
            string num_str = S.substr(i - j, j);
            long long num = stoll(num_str);

            if (num <= C) {
                dp[i] = (dp[i] + dp[i - j]) % MOD;
            }
        }
    }

    return dp[N];
}

int main() {
    int N, C, K;
    cin >> N >> C >> K;

    string S;
    cin >> S;

    cout << countArrays(S, C, K) << endl;

    return 0;
}

Without whitespaces
Uber ✅

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

bool chkValid(const vector<string>& eq, unordered_map<char, int>& l2d) {
    vector<long long> nums;
    for (const string& p : eq) {
        long long num = 0;
        for (char c : p) {
            num = num * 10 + l2d[c];
        }
        nums.push_back(num);
    }
    return nums[0] + nums[1] == nums[2];
}

int dfs(vector<string>& eq, unordered_map<char, int>& l2d, unordered_set<int>& tD, vector<char>& let, int pos) {
    if (pos == let.size()) {
        return chkValid(eq, l2d) ? 1 : 0;
    }
    
    char l = let[pos];
    int count = 0;
    for (int d = 0; d < 10; ++d) {
        if (tD.count(d)) continue;
        if (d == 0 && find_if(eq.begin(), eq.end(), [&](string& p) { return p[0] == l; }) != eq.end()) continue;
        
        tD.insert(d);
        l2d[l] = d;
        
        count += dfs(eq, l2d, tD, let, pos + 1);
        
        tD.erase(d);
        l2d.erase(l);
    }
    
    return count;
}

int cntCryptarithmSolutions(vector<string> eq) {
    unordered_set<char> allLet;
    for (const string& p : eq) {
        for (char c : p) {
            allLet.insert(c);
        }
    }
    
    vector<char> let(allLet.begin(), allLet.end());
    unordered_map<char, int> l2d;
    unordered_set<int> tD;
    
    return dfs(eq, l2d, tD, let, 0);
}

Crypt
Trilogy ✅

bool placeBlock(vector<vector<char>>& field, int row, int& finalRow, int& finalCol) {
    int col = 0;
    while (col < field[0].size() && field[row][col] == '.') ++col;

    while (row < field.size() - 1 && field[row + 1][col] == '.') ++row;

    if (col >= 0 && row >= 0) {
        field[row][col] = '#';
        finalRow = row;
        finalCol = col;
        return true;
    }
    return false;
}

void removeBlock(vector<vector<char>>& field, int row, int col) {
    field[row][col] = '.';
}

void solve(vector<vector<char>>& field, vector<int>& ans, int cnt) {
    bool check = true;
    for (int i = 0; i < field.size(); ++i) {
        if (field[i][0] != '#') {
            check = false;
            break;
        }
    }
    if (check) {
        ans[0] = min(ans[0], cnt);
        ans[1] = max(ans[1], cnt);
        return;
    }

    for (int i = 0; i < field.size(); ++i) {
        int finalRow = -1, finalCol = -1;

        if (placeBlock(field, i, finalRow, finalCol)) {
            solve(field, ans, cnt + 1);

            removeBlock(field, finalRow, finalCol);
        }
    }
}

vector<int> solution(vector<vector<char>> field) {
    vector<int> ans = {INT_MAX, INT_MIN};
    solve(field, ans, 0);
    return ans;
}

Block placing
Trilogy ✅

#include <iostream>
#include <vector>

using namespace std;

const int MOD = 1e9 + 7;

int solve(int N, int M, vector<vector<int>>& nums) {

    vector<vector<long long>> dp(N, vector<long long>(M, 0));
    dp[0][0] = nums[0][0];
    

    for (int j = 1; j < M; ++j) {
        dp[0][j] = (dp[0][j - 1] * nums[0][j]) % MOD;
    }
    
    for (int i = 1; i < N; ++i) {
        dp[i][0] = (dp[i - 1][0] * nums[i][0]) % MOD;
    }
    

    for (int i = 1; i < N; ++i) {
        for (int j = 1; j < M; ++j) {
            dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) * nums[i][j] % MOD;
        }
    }
    
    return dp[N - 1][M - 1];
}

int main() {
    int N, M;
    cin >> N >> M;
    vector<vector<int>> nums(N, vector<int>(M));
    
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            cin >> nums[i][j];
        }
    }
    
    cout << solve(N, M, nums) << endl;
    
    return 0;
}

Maze Craze✅

Take Home Assignment based Hiring

Sample Invoices for reference:
https://drive.google.com/drive/folders/1Q7sU_eiisOvtCAFCRSesyMDkVsMtNF7h?usp=drive_link

Things that keep me going ❤️

Congratulations ❤

Business Analytics ( Freshers to 20 Months Exp)

Candidates Can apply :-
TECHNICAL QUALIFICATION BACKGROUND MANDATE

Freshers can apply who have Complete Certification or Training in SAS, SQL Skills.
OR
Experience with SAS, SQL Technologies.

Skills Required
1. SAS
2. SQL
3. BFSI Domain :- Risk, Card, Insurance, Finance, Fintech ETC.

Work Location - WFH

Please share profiles at jasneet@supportstar.in || jasneet.sscs@gmail.com OR call@7303249754
Open for Reference