𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

Bornbhukkad hiring Machine Learning Intern

apply - https://www.linkedin.com/jobs/view/3704137999

65 Machine Learning Intern jobs in India

Today’s top 65 Machine Learning Intern jobs in India. Leverage your professional network, and get hired. New Machine Learning Intern jobs added daily.

373 viewsDushyant, 07:05

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

Company Name: Uni Cards

Role: SDE 1 - Backend

Batch eligible: 2022 and 2023 grads

Apply: https://docs.google.com/forms/d/e/1FAIpQLSc90e-pYGZehRCToicgqdzkoZHJXaRb_WOsOAgX9HVv2FNSMA/alreadyresponded

Note: Interview will be on 9th Sep, 2023 at Uni Card office Bangalore.

376 viewsDushyant, 07:06

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

Atlassian Interview Experience ✌🏻

https://medium.com/@ritinema23/atlassian-interview-experience-bee07be0bddf

Medium

Atlassian Interview Experience

Atlassian Corporation Plc is an Australian software company that develops products for software developers, project managers and other…

562 viewsDushyant, 07:18

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』 pinned «Atlassian Interview Experience ✌🏻 https://medium.com/@ritinema23/atlassian-interview-experience-bee07be0bddf»

07:18

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

459 viewsDushyant, 13:01

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

#include <bits/stdc++.h>

using namespace std;

vector<long long> palindromes;

long long cal(string p)
{
    string p1 = p;
    reverse(p1.begin(), p1.end());
    p += p1;
    long long ans = 0;
    for (int i = p.size() - 1; i >= 0; i--)
    {
        if (p[i] == '1')
            ans += (1LL << (p.size() - 1 - i));
    }
    return ans;
}

long long cal1(string p)
{
    string p1 = p;
    reverse(p1.begin(), p1.end());
    p1.erase(p1.begin());
    p += p1;
    long long ans = 0;
    for (int i = p.size() - 1; i >= 0; i--)
    {
        if (p[i] == '1')
            ans += (1LL << (p.size() - 1 - i));
    }
    return ans;
}

void f(int idx, string p, int flag)
{
    if (idx == 16)
    {
        palindromes.push_back(cal(p));
        if (!p.empty())
            palindromes.push_back(cal1(p));
        return;
    }
    if (flag == 0)
    {
        f(idx + 1, p, 0);
        f(idx + 1, p + "1", 1);
    }
    else
    {
        f(idx + 1, p + "0", 1);
        f(idx + 1, p + "1", 1);
    }
}

int main()
{
    int t;
    long long idx, ans, n;
    cin >> t;

    f(0, "", 0);
    sort(palindromes.begin(), palindromes.end());

    while (t--)
    {
        cin >> n;
        idx = lower_bound(palindromes.begin(), palindromes.end(), n) - palindromes.begin();
        ans = palindromes[idx] - n;
        if (idx > 0)
            ans = min(ans, n - palindromes[idx - 1]);
        cout << ans << endl;
    }

    return 0;
}

Binary palindrome number ✅

528 viewsDushyant, edited 13:01

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

461 viewsDushyant, 14:22

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

#include <bits/stdc++.h>

using namespace std;

int findPairs(vector<pair<int, int>>& array, int size) {
    set<pair<int, int>> pairsSet;

    for (int i = 0; i < size; i++) {
        for (int j = 0; j < size; j++) {
            if (i != j && pairsSet.find({i, j}) == pairsSet.end() && pairsSet.find({j, i}) == pairsSet.end()) {
                if ((array[i].second * (array[j].first - array[i].first)) == (array[i].first * (array[j].second - array[i].second))) {
                    pairsSet.insert({i, j});
                }
            }
        }
    }

    return pairsSet.size();
}

int main() {
    int t;
    cin >> t;

    for (int testCase = 1; testCase <= t; testCase++) {
        int size;
        cin >> size;

        vector<pair<int, int>> array(size);
        for (int i = 0; i < size; i++) {
            cin >> array[i].first >> array[i].second;
        }

        int result = findPairs(array, size);
        cout << result << endl;
    }

    return 0;
}

Pair of points ✅

517 viewsDushyant, 14:22

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

345 viewsDushyant, 14:29

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

smart Gardener ✅

530 viewsDushyant, 15:19

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

Forwarded from 𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』 (Dushyant)

After many messages like above, I have created new channel where will update job opportunities only for experienced candidates. (It will be difficult to manage 2 channel but will try my best).

Here is the link:

https://t.me/codingsamurai

#KeepSharingwithseniors

Experience Jobs & Materials

300+ Placement & Competitive Exam Materials
75+ Companies Materials
10+ Weekly Udemy Course Coupons
Daily Off Campus Jobs Updates

India's Biggest Placement Channel!!

➖🍴➖😴➖👩‍💻➖🔁➖

🌈 Share and Support
Buy ads: https://telega.io/c/codingsamurai

443 viewsDushyant, 16:10

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』 pinned «After many messages like above, I have created new channel where will update job opportunities only for experienced candidates. (It will be difficult to manage 2 channel but will try my best). Here is the link: https://t.me/codingsamurai #KeepSharingwithseniors»

16:10

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

#include <iostream>
using namespace std;

int gcd(int a, int b) {
    return (b == 0) ? a : gcd(b, a % b);
    }

    int numberOfSquares(int L, int B) {
        int side = gcd(L, B);
            return (L * B) / (side * side);
            }

            int main() {
                int L, B;
                    cin >> L >> B;
                        cout << numberOfSquares(L, B) << endl;
                            return 0;
                            }

471 viewsDushyant, 03:40

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

#include<iostream>
#include<vector>
#include<thread>
#include<mutex>

std::mutex mtx;

void computeSum(const std::vector<int>& nums, int start, int end, int& result) {
    int sum = 0;
    for(int i = start; i < end; i++) {
        sum += nums[i];
    }
    mtx.lock();
    result += sum;
    mtx.unlock();
}

int parallelSum(std::vector<int> nums, int num_threads) {
    int result = 0;
    std::vector<std::thread> threads;
    int n = nums.size();
    int chunk_size = n / num_threads;
    for(int i = 0; i < num_threads; i++) {
        int start = i * chunk_size;
        int end = (i == num_threads - 1) ? n : start + chunk_size;
        threads.push_back(std::thread(computeSum, std::ref(nums), start, end, std::ref(result)));
    }
    for(auto& th : threads) {
        th.join();
    }
    return result;
}

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int num_threads = 4;
    std::cout << "Sum: " << parallelSum(nums, num_threads) << std::endl;
    return 0;
}

536 viewsDushyant, 03:40