Add files via upload

Author: adityajamwal02

BuyTwoChocolates.cpp

@@ -0,0 +1,30 @@
+/*
+You are given an integer array prices representing the prices of various chocolates in a store. You are also given a single integer money, which represents your initial amount of money.
+You must buy exactly two chocolates in such a way that you still have some non-negative leftover money. You would like to minimize the sum of the prices of the two chocolates you buy.
+Return the amount of money you will have leftover after buying the two chocolates. If there is no way for you to buy two chocolates without ending up in debt, return money. Note that the leftover must be non-negative.
+
+Example 1:
+Input: prices = [1,2,2], money = 3
+Output: 0
+Explanation: Purchase the chocolates priced at 1 and 2 units respectively. You will have 3 - 3 = 0 units of money afterwards. Thus, we return 0.
+
+Example 2:
+Input: prices = [3,2,3], money = 3
+Output: 3
+Explanation: You cannot buy 2 chocolates without going in debt, so we return 3.
+*/
+
+
+class Solution {
+public:
+    int buyChoco(vector<int>& prices, int money) {
+        sort(prices.begin(),prices.end());
+        int l=prices[0], m=prices[1];
+        if(l+m<=money){
+            return (money-(l+m));
+        }else{
+            return money;
+        }
+    return money;
+    }
+};

ExtraCharactersInAString.cpp

@@ -0,0 +1,33 @@
+/*
+You are given a 0-indexed string s and a dictionary of words dictionary. You have to break s into one or more non-overlapping substrings such that each substring is present in dictionary. There may be some extra characters in s which are not present in any of the substrings.
+Return the minimum number of extra characters left over if you break up s optimally.
+
+Example 1:
+Input: s = "leetscode", dictionary = ["leet","code","leetcode"]
+Output: 1
+Explanation: We can break s in two substrings: "leet" from index 0 to 3 and "code" from index 5 to 8. There is only 1 unused character (at index 4), so we return 1.
+
+Example 2:
+Input: s = "sayhelloworld", dictionary = ["hello","world"]
+Output: 3
+Explanation: We can break s in two substrings: "hello" from index 3 to 7 and "world" from index 8 to 12. The characters at indices 0, 1, 2 are not used in any substring and thus are considered as extra characters. Hence, we return 3.
+*/
+
+class Solution {
+public:
+    int minExtraChar(string s, vector<string>& dictionary) {
+        set<string> dict(dictionary.begin(),dictionary.end());
+        int n=s.size();
+        vector<int> dp(n+1,0);
+        for(int i=1;i<=n;i++){
+            dp[i]=dp[i-1]+1;
+            for(int j=i;j>=1;j--){
+                string str=s.substr(j-1,i-j+1);
+                if(dict.find(str)!=dict.end()){
+                    dp[i]=min(dp[i],dp[j-1]);
+                }
+            }
+        }
+    return dp[n];
+    }
+};

FindThePunishmentNumberOfAnInteger.cpp

@@ -0,0 +1,51 @@
+/*
+Given a positive integer n, return the punishment number of n.
+The punishment number of n is defined as the sum of the squares of all integers i such that:
+1 <= i <= n
+The decimal representation of i * i can be partitioned into contiguous substrings such that the sum of the integer values of these substrings equals i.
+
+Example 1:
+Input: n = 10
+Output: 182
+Explanation: There are exactly 3 integers i that satisfy the conditions in the statement:
+- 1 since 1 * 1 = 1
+- 9 since 9 * 9 = 81 and 81 can be partitioned into 8 + 1.
+- 10 since 10 * 10 = 100 and 100 can be partitioned into 10 + 0.
+Hence, the punishment number of 10 is 1 + 81 + 100 = 182
+
+Example 2:
+Input: n = 37
+Output: 1478
+Explanation: There are exactly 4 integers i that satisfy the conditions in the statement:
+- 1 since 1 * 1 = 1.
+- 9 since 9 * 9 = 81 and 81 can be partitioned into 8 + 1.
+- 10 since 10 * 10 = 100 and 100 can be partitioned into 10 + 0.
+- 36 since 36 * 36 = 1296 and 1296 can be partitioned into 1 + 29 + 6.
+Hence, the punishment number of 37 is 1 + 81 + 100 + 1296 = 1478
+*/
+
+
+class Solution {
+public:
+    bool solve(int i, int x, int total, string &str){
+        if(i>=str.size()) return (x==total);
+        bool ans=0;
+        int q=0;
+        for(int j=i;j<str.size();j++){
+            q=10*q+int(str[j])-48;
+            ans|=solve(j+1,x+q,total,str);
+            if(ans) return 1;
+        }
+    return ans;
+    }
+    int punishmentNumber(int n) {
+        long long int result=0;
+        for(int i=1;i<=n;i++){
+            string str=to_string(i*i);
+            if(solve(0,0,i,str)){
+                result+=(i*i);
+            }
+        }
+    return result;
+    }
+};

GreatestCommonDivisorTraversal.cpp

@@ -0,0 +1,90 @@
+/*
+You are given a 0-indexed integer array nums, and you are allowed to traverse between its indices. You can traverse between index i and index j, i != j, if and only if gcd(nums[i], nums[j]) > 1, where gcd is the greatest common divisor.
+Your task is to determine if for every pair of indices i and j in nums, where i < j, there exists a sequence of traversals that can take us from i to j.
+Return true if it is possible to traverse between all such pairs of indices, or false otherwise.
+
+Example 1:
+Input: nums = [2,3,6]
+Output: true
+Explanation: In this example, there are 3 possible pairs of indices: (0, 1), (0, 2), and (1, 2).
+To go from index 0 to index 1, we can use the sequence of traversals 0 -> 2 -> 1, where we move from index 0 to index 2 because gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, and then move from index 2 to index 1 because gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
+To go from index 0 to index 2, we can just go directly because gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Likewise, to go from index 1 to index 2, we can just go directly because gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.
+
+Example 2:
+Input: nums = [3,9,5]
+Output: false
+Explanation: No sequence of traversals can take us from index 0 to index 2 in this example. So, we return false.
+
+Example 3:
+Input: nums = [4,3,12,8]
+Output: true
+Explanation: There are 6 possible pairs of indices to traverse between: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), and (2, 3). A valid sequence of traversals exists for each pair, so we return true.
+*/
+
+class Solution {
+public:
+    class UnionFind{
+        private:
+            vector<int> parent, rank;
+        public:
+            UnionFind(int n){
+                parent.resize(n);
+                rank.resize(n,1);
+                for(int i=0;i<n;i++){
+                    parent[i]=i;
+                }
+            }
+        int find(int x){
+            if(parent[x]!=x){
+                parent[x]=find(parent[x]);
+            }
+        return parent[x];
+        }
+        void unionByRank(int x, int y){
+            int rx=find(x);
+            int ry=find(y);
+            if(rx!=ry){
+                if(rank[rx]<rank[ry]){
+                    parent[rx]=ry;
+                }else if(rank[rx]>rank[ry]){
+                    parent[ry]=rx;
+                }else{
+                    parent[rx]=ry;
+                    rank[ry]++;
+                }
+            }
+        }
+    };
+
+    bool canTraverseAllPairs(vector<int>& nums) {
+        int n=nums.size();
+        UnionFind u(n);
+        unordered_map<int, vector<int>> mp;
+        for(int i=0;i<n;i++){
+            for(int j=2;j*j<=nums[i];j++){
+                if(nums[i]%j==0){
+                    mp[j].push_back(i);
+                    while(nums[i]%j==0){
+                        nums[i]/=j;
+                    }
+                }
+            }
+            if(nums[i]>1){
+                mp[nums[i]].push_back(i);
+            }
+        }
+        for(auto it : mp){
+            vector<int> &ind=it.second;
+            for(int i=1;i<ind.size();i++){
+                u.unionByRank(ind[i-1],ind[i]);
+            }
+        }
+        int root=u.find(0);
+        for(int i=1;i<n;i++){
+            if(u.find(i)!=root){
+                return false;
+            }
+        }
+    return true;
+    }
+};

MaximumStrengthOfAGroup.cpp

@@ -0,0 +1,68 @@
+/*
+You are given a 0-indexed integer array nums representing the score of students in an exam. The teacher would like to form one non-empty group of students with maximal strength, where the strength of a group of students of indices i0, i1, i2, ... , ik is defined as nums[i0] * nums[i1] * nums[i2] * ... * nums[ik​].
+Return the maximum strength of a group the teacher can create.
+
+Example 1:
+Input: nums = [3,-1,-5,2,5,-9]
+Output: 1350
+Explanation: One way to form a group of maximal strength is to group the students at indices [0,2,3,4,5]. Their strength is 3 * (-5) * 2 * 5 * (-9) = 1350, which we can show is optimal.
+
+Example 2:
+Input: nums = [-4,-5,-4]
+Output: 20
+Explanation: Group the students at indices [0, 1] . Then, we’ll have a resulting strength of 20. We cannot achieve greater strength.
+*/
+
+
+ class Solution {
+public:
+    long long maxStrength(vector<int>& nums) {
+        int n=nums.size();
+        if(n==1) return nums[0];
+        vector<int> less, great;
+        for(int i=0;i<n;i++){
+            if(nums[i]<0){
+                less.push_back(nums[i]);
+            }else if(nums[i]>0){
+                great.push_back(nums[i]);
+            }
+        }
+        long long ans=0;
+        sort(great.begin(),great.end());
+        sort(less.begin(),less.end());
+        for(int i=0;i<less.size();i++){
+            if(i==0){
+                ans=(long long)less[i];
+            }else{
+                if(less.size()%2==0){
+                    long long neg=less[i];
+                    ans*=neg;
+                }else{
+                    if(i<less.size()-1){
+                        long long neg=less[i];
+                        ans*=neg;
+                    }
+                }
+            }
+        }
+        long long ans2=0;
+        for(int i=0;i<great.size();i++){
+            if(ans2==0)
+                ans2=(long long)great[i];
+            else{
+                long long pos=great[i];
+                ans2*=pos;
+            }
+        }
+
+        if(ans>0 and ans2>0){
+            return (long long)(ans*ans2);
+        }else if(ans>0){
+            return ans;
+        }else if(ans2>0){
+            return ans2;
+        }else{
+            return 0;
+        }
+    }
+};