Next Permutation.py

4Sum.py

@@ -0,0 +1,26 @@
+def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
+        nums.sort()
+        res, quad=[] , []
+        def kSum(k, start, target):
+            if k != 2:
+                for i in range(start, len(nums)-k+1):
+                    if i > start and nums[i]==nums[i - 1]:
+                        continue
+                    quad.append(nums[i])
+                    kSum(k - 1, i + 1, target - nums[i])
+                    quad.pop()
+                return
+            l, r = start, len(nums)-1
+            while l<r:
+                if nums[l]+nums[r]<target:
+                    l+=1
+                elif nums[l] + nums[r]>target:
+                    r -=1
+                else:
+                    res.append(quad + [nums[l],nums[r]])
+                    l+=1
+                    while l<r and nums[l]== nums[l -1]:
+                        l+=1
+
+        kSum(4, 0, target)
+        return res

A Chain adding function.py

@@ -0,0 +1,3 @@
+class add(int):
+    def __call__(self, n):
+        return add(self + n)

A Chain adding function2.py

@@ -0,0 +1,3 @@
+class add(int):
+    def __call__(self, n):
+        return add(self + n)

Beautiful Triplets.py

@@ -0,0 +1,29 @@
+import math
+import os
+import random
+import re
+import sys
+def beautifulTriplets(d, arr):
+     res = 0
+
+     for el in arr:
+            if el + d in arr and el + 2*d in arr:
+                res += 1
+
+     return res
+if __name__ == '__main__':
+    fptr = open(os.environ['OUTPUT_PATH'], 'w')
+
+    first_multiple_input = input().rstrip().split()
+
+    n = int(first_multiple_input[0])
+
+    d = int(first_multiple_input[1])
+
+    arr = list(map(int, input().rstrip().split()))
+
+    result = beautifulTriplets(d, arr)
+
+    fptr.write(str(result) + '\n')
+
+    fptr.close()

Capitalize!.py

@@ -0,0 +1,15 @@
+import math
+import os
+import random
+import re
+import sys
+def solve(s):
+    for x in s[:].split():
+        s = s.replace(x, x.capitalize())
+    return s
+if __name__ == '__main__':
+    fptr = open(os.environ['OUTPUT_PATH'], 'w')
+    s = input()
+    result = solve(s)
+    fptr.write(result + '\n')
+    fptr.close()

ChiefHopper.py

@@ -0,0 +1,42 @@
+n = int(input())
+high = low = 0
+arr = []
+
+for i in input().split():
+    arr.append(int(i))
+    if(int(i) > high):
+        high = int(i)
+    if(int(i) < low):
+        low = int(i)
+
+def tester(x, arr):
+    energy = x
+    answer = True
+    for height in arr:
+        if(height > energy):
+            energy -= (height - energy)
+            if(energy < 0):
+                return(False)
+        else:
+            energy += (energy - height)
+    return(answer)     
+
+cont = True
+i = (high + low) // 2
+dic = {}
+while(cont):
+    if(dic.get(i-1, tester(i-1, arr))):
+        # i is too high
+        high = i
+        i = (high + low) // 2
+    else:
+        if(dic.get(i, tester(i, arr))):
+            cont = False
+        else:
+            # i is too low, double it and set low to current i
+            low = i
+            i = ((i + high + 1) // 2)
+            if(i == 0):
+                i = 1
+
+print(i)

Contacts.py

@@ -0,0 +1,44 @@
+class Trie:
+    def __init__(self):
+        self.count = 1
+        self.children = {}
+
+    def add(self, name):
+        node = self
+        for let in name:
+            if let in node.children.keys():
+                node.children[let].count += 1
+                node = node.children[let]
+            else:
+                node.children[let] = Trie()
+                node = node.children[let]
+
+    def find(self, name):
+        node = self
+        for let in name:
+            if let in node.children.keys():
+                res = node.children[let].count
+                node = node.children[let]
+            else:
+                res = 0
+                break
+
+        return res
+
+    def print(self):
+        print("count = {} keys = {}".format(self.count, self.children.keys()))
+        for key in self.children.keys():
+            self.children[key].print()
+
+if __name__ == "__main__":
+    t = int(input().strip())
+    trie = Trie()
+
+    for _ in range(t):
+        args = input().strip().split()
+
+        if args[0] == 'add':
+            trie.add(args[1])
+        elif args[0] == 'find':
+            print(trie.find(args[1]))
+

Count Inversions.py

@@ -0,0 +1,7 @@
+def getInversions(arr, n) :
+    icount=0
+    for i in range(n):
+        for j in range(i,n):
+            if arr[i]>arr[j]:
+                icount+=1
+    return icount

Count Reverse Pairs.cpp

@@ -0,0 +1,18 @@
+#include<bits/stdc++.h>
+using namespace std;
+ int reversePairs(vector < int > & arr) {
+      int Pairs = 0;
+      for (int i = 0; i < arr.size(); i++) {
+        for (int j = i + 1; j < arr.size(); j++) {
+          if (arr[i] > 2 * arr[j]) Pairs++;
+        }
+      }
+      return Pairs;
+    }
+
+
+int main()
+{
+    vector<int> arr{1,3,2,3,1};
+    cout<<"The Total Reverse Pairs are "<<reversePairs(arr);
+}

Count the number of subarrays with given xor K.cpp

@@ -0,0 +1,23 @@
+#include<bits/stdc++.h>
+using namespace std;
+class Solution{ 
+    public:
+    int solve(vector<int> &A, int B) {
+    long long c=0;
+    for(int i=0;i<A.size();i++){
+        int current_xor = 0;
+        for(int j=i;j<A.size();j++){
+            current_xor^=A[j];
+            if(current_xor==B) c++;
+        }
+    }
+    return c;
+}
+};
+
+int main()
+{   vector<int> A{ 4,2,2,6,4 };
+    Solution obj;
+    int totalCount= obj.solve(A,6);
+    cout<<"The total number of subarrays having a given XOR k is "<<totalCount<<endl;
+}

Counting Valleys1.py

@@ -0,0 +1,30 @@
+import math
+import os
+import random
+import re
+import sys
+
+def countingValleys(steps, path):
+    valleys = 0
+    cur_level = 0
+    for steps in path:
+        if(steps == 'U'):
+            cur_level += 1
+            if(cur_level == 0):
+                valleys += 1
+        elif(steps == 'D'):
+            cur_level -= 1
+    return(valleys)
+
+if __name__ == '__main__':
+    fptr = open(os.environ['OUTPUT_PATH'], 'w')
+
+    steps = int(input().strip())
+
+    path = input()
+
+    result = countingValleys(steps, path)
+
+    fptr.write(str(result) + '\n')
+
+    fptr.close()

Doubly Linked List insertion.py

@@ -0,0 +1,7 @@
+def push(self, new_data):
+    new_node = Node(data = new_data)
+    new_node.next = self.head
+    new_node.prev = None
+    if self.head is not None:
+        self.head.prev = new_node
+    self.head = new_node 

Find The Parity Outlier.py

@@ -0,0 +1,12 @@
+def find_outlier(integers):
+    even=[]
+    odd=[]
+    for i in integers:
+        if i % 2 == 0:
+            even.append(i)
+        else:
+            odd.append(i)
+    if len(even)==1:
+        return even[0]
+    else:
+        return odd[0]

Find duplicate in an array of N+1 Integers.py

@@ -0,0 +1,11 @@
+numRay = [0, 4, 3, 2, 7, 8, 2, 3, 1]
+arr_size = len(numRay)
+for i in range(arr_size):
+
+    x = numRay[i] % arr_size
+    numRay[x] = numRay[x] + arr_size
+
+print("The repeating elements are : ")
+for i in range(arr_size):
+    if (numRay[i] >= arr_size*2):
+        print(i, " ")

Find the Duplicate Number.py

@@ -0,0 +1,14 @@
+def findDuplicate(self, nums: List[int]) -> int:
+        slow, fast =0,0
+        while True:
+            slow = nums[slow]
+            fast=nums[nums[fast]]
+            if slow == fast:
+                break
+
+        slow2=0
+        while True:
+            slow = nums[slow]
+            slow2 = nums[slow2]
+            if slow == slow2:
+                return slow

Find the middle of a given linked list.py

@@ -0,0 +1,42 @@
+class Node:
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+class NodeOperation:
+    def pushNode(self, head_ref, data_val):
+        new_node = Node(data_val)
+        new_node.next = head_ref
+        head_ref = new_node
+        return head_ref
+    def printNode(self, head):
+        while (head != None):
+            print('%d->' % head.data, end="")
+            head = head.next
+        print("NULL")
+    def getLen(self, head):
+        temp = head
+        len = 0
+
+        while (temp != None):
+            len += 1
+            temp = temp.next
+
+        return len
+
+    def printMiddle(self, head):
+        if head != None:
+            len = self.getLen(head)
+            temp = head
+            midIdx = len // 2
+            while midIdx != 0:
+                temp = temp.next
+                midIdx -= 1
+            print('The middle element is [%d]' % temp.data)
+
+head = None
+temp = NodeOperation()
+for i in range(5, 0, -1):
+    head = temp.pushNode(head, i)
+    temp.printNode(head)
+    temp.printMiddle(head)

Find the smallest integer in the array.py

@@ -0,0 +1,4 @@
+def find_smallest_int(arr):
+    arr.sort()
+    a=arr[0:1]
+    return arr[0]