Merge branch 'smv1999:master' into determine-if-max-heap

Author: aakankshabhende

Arrays/KLargestpairs.py

@@ -0,0 +1,62 @@
+# K Largest Pairs
+
+"""
+You are given two lists of integers nums0, nums1 and an integer k. 
+Find k largest sum pairs where each pair contains one integer in nums0 and another in nums1, 
+and return the sum of all of the pairs.
+
+Constraints
+
+0 ≤ n ≤ 100,000 where n is the length of nums0
+0 ≤ m ≤ 100,000 where m is the length of nums1
+0 ≤ k ≤ 100,000
+0 ≤ k ≤ n * m
+
+
+Example 1:
+
+Input:-
+nums0 = [5, 3, 9]
+nums1 = [1, 2, 4]
+k = 2
+
+Output:-
+24
+
+Explanation:-
+The 2 largest pairs are (9,2) and (9,4)..therefore the sum of the pairs would be 9+2+9+4=24
+"""
+
+
+def solve(nums0, nums1, k):
+    lst=[]
+    tot=0
+    for i in nums0:
+        for j in nums1:
+            sum=0
+            sum=i+j
+            lst.append(sum)
+    lst=sorted(lst,reverse=True)
+    for i in range(0,k):
+        tot=tot+lst[i]
+    return tot
+
+n1=int(input(("Enter no. of elements in num list1: ")))
+n2=int(input(("Enter no. of elements in num list2: ")))
+k=int(input("Enter no. of largest pairs that you need: "))
+list1=[]
+list2=[]
+print("Enter elements of list1 one by one: ")
+for i in range(0,n1):
+    
+    ele1=int(input())
+    list1.append(ele1)
+    
+print("Enter elements of list2 one by one: ")
+for j in range(0,n2):
+    
+    ele2=int(input())
+    list2.append(ele2)
+
+ans=solve(list1,list2,k)
+print("Sum of the largest " + str(k) + " pairs is",ans)

Arrays/Kadane's_Algorithm.cpp

@@ -0,0 +1,64 @@
+
+/* Given an array arr of N integers. Find the contiguous sub-array with maximum sum.
+
+ 
+
+Example 1:
+
+Input:
+N = 5
+arr[] = {1,2,3,-2,5}
+Output:
+9
+Explanation:
+Max subarray sum is 9
+of elements (1, 2, 3, -2, 5) which 
+is a contiguous subarray.*/
+#include<bits/stdc++.h>
+using namespace std;
+
+
+ // } Driver Code Ends
+
+
+// Function to find subarray with maximum sum
+// arr: input array
+// n: size of array
+int maxSubarraySum(int arr[], int n){
+    
+    // Your code here
+    int i,maxCur=arr[0];
+    int totalsum=arr[0];
+    for(i=1;i<n;i++)
+    {
+        maxCur=max(arr[i],arr[i]+maxCur);
+        if(maxCur>totalsum)
+        {
+            totalsum=maxCur;
+        }
+    }
+    return totalsum;
+    
+}
+
+// { Driver Code Starts.
+
+int main()
+{
+    int t,n;
+    
+    cin>>t; //input testcases
+    while(t--) //while testcases exist
+    {
+        
+        cin>>n; //input size of array
+        
+        int a[n];
+        
+        for(int i=0;i<n;i++)
+            cin>>a[i]; //inputting elements of array
+        
+        cout << maxSubarraySum(a, n) << endl;
+    }
+}
+  // } Driver Code Ends

Arrays/ShortestContinuousSubarray.py

@@ -0,0 +1,44 @@
+# Shortest Unsorted Continuous Subarray
+
+"""
+Find one continuous subarray that if you only sort this subarray in ascending order, then the whole array will be sorted in ascending order.
+Return length of the shortest subarray.
+
+Example 1: nums = [2,6,4,8,10,9,15]
+o/p:- 5
+Explanation: You need to sort [6, 4, 8, 10, 9] in ascending order to make the whole array sorted in ascending order.
+
+Example 2: nums = [1,2,3,4]
+o/p:- 0
+"""
+
+def findUnsortedSubarray(nums):
+        res=[]
+        ans=[]
+        final=[]
+        for i in nums:
+            res.append(i)
+       
+        res.sort()
+        for i in range(0,len(nums)):
+            if nums[i]!=res[i]:
+                ans.append(i)
+          
+        if len(ans)==0:
+            return 0
+        else:
+            for i in range(ans[0],ans[len(ans)-1]+1):
+                final.append(nums[i])
+            
+            return len(final)
+
+nums=[]
+n=int(input("Enter the no. of elements: "))
+print("Enter the elements of the array one by one: ")
+for i in range(0,n):
+	
+	ele=int(input())
+	nums.append(ele)
+
+answer=findUnsortedSubarray(nums)
+print("The length of the shortest subarray:",answer)

Bit Manipulation/Bit_Difference.cpp

@@ -0,0 +1,51 @@
+ 
+/*
+You are given two numbers A and B. The task is to count the number of bits needed to be flipped to convert A to B.
+
+Example 1:
+
+Input: A = 10, B = 20
+Output: 4
+Explanation:
+A  = 01010
+B  = 10100
+As we can see, the bits of A that need 
+to be flipped are 01010. If we flip 
+these bits, we get 10100, which is B.*/
+//Initial Template for C++
+
+#include<bits/stdc++.h>
+using namespace std;
+ 
+// Function to find number of bits to be flip
+// to convert A to B
+int countBitsFlip(int a, int b){
+    
+    // Your logic here
+    int ans=a^b;
+    int c=0;
+    while(ans>0)
+    {
+        ans &=(ans-1);
+        c++;
+    }
+     return c;   
+    
+}
+
+// { Driver Code Starts.
+
+// Driver Code
+int main()
+{
+	int t;
+	cin>>t;// input the testcases
+	while(t--) //while testcases exist
+	{
+		int a,b;
+		cin>>a>>b; //input a and b
+
+		cout<<countBitsFlip(a, b)<<endl;
+	}
+	return 0;
+}  // } Driver Code Ends

Bit Manipulation/Count_total_set_bits.cpp

@@ -0,0 +1,57 @@
+
+/*
+You are given a number N. Find the total count of set bits for all numbers from 1 to N(both inclusive).
+
+Example 1:
+
+Input: N = 4
+Output: 5
+Explanation:
+For numbers from 1 to 4.
+For 1: 0 0 1 = 1 set bits
+For 2: 0 1 0 = 1 set bits
+For 3: 0 1 1 = 2 set bits
+For 4: 1 0 0 = 1 set bits
+Therefore, the total set bits is 5.*/
+
+#include<bits/stdc++.h>
+using namespace std;
+ 
+// Function to count set bits in the given number x
+// n: input to count the number of set bits
+int largestpowerof2inrange(int n)
+{
+    int x=0;
+    while((1<<x) <=n)
+    {
+        x++;
+    }
+    return x-1;
+}
+int countSetBits(int n)
+{
+    // Your logic 
+    if(n==0) return 0;
+    int x=largestpowerof2inrange(n);
+    int first= x*(1<<(x-1));
+    int second= n-(1<<x)+1;
+    int third=n-(1<<x);
+    int ans=first+second+countSetBits(third);
+    return ans;
+}
+ 
+// Driver code
+int main()
+{
+	 int t;
+	 cin>>t;// input testcases
+	 while(t--) //while testcases exist
+	 {
+	       int n;
+	       cin>>n; //input n
+	       
+	       cout << countSetBits(n) << endl;// print the answer
+	  }
+	  return 0;
+}
+  // } Driver Code Ends

Bit Manipulation/Find_position_of_set_bit.cpp

@@ -0,0 +1,61 @@
+
+/*
+Given a number N having only one ‘1’ and all other ’0’s in its binary representation, find position of the only set bit. If there are 0 or more than 1 set bit the answer should be -1. Position of  set bit '1' should be counted starting with 1 from LSB side in binary representation of the number.
+
+Example 1:
+
+Input:
+N = 2
+Output:
+2
+Explanation:
+2 is represented as "10" in Binary.
+As we see there's only one set bit
+and it's in Position 2 and thus the
+Output 2.*/
+#include <bits/stdc++.h>
+using namespace std;
+ 
+
+class Solution {
+  public:
+  
+  int isPowerOfTwo(unsigned N) 
+    { 
+        return N && (!(N & (N - 1))); 
+    } 
+    int findPosition(int N) {
+        // code here
+        if (!isPowerOfTwo(N)) 
+            return -1; 
+  
+        unsigned i = 1, pos = 1; 
+      
+        
+        while (!(i & N)) { 
+            
+            i = i << 1; 
+      
+            // increment position 
+            ++pos; 
+        } 
+      
+        return pos; 
+        
+        }
+};
+
+// { Driver Code Starts.
+int main() {
+    int t;
+    cin >> t;
+    while (t--) {
+        int N;
+
+        cin>>N;
+
+        Solution ob;
+        cout << ob.findPosition(N) << endl;
+    }
+    return 0;
+}  // } Driver Code Ends