├── .all-contributorsrc
├── Arrays
    ├── ASmallerTeam.cpp
    ├── ASortedTeam.cpp
    ├── ArrayHill.cpp
    ├── ArrayRotation.cpp
    ├── AssigningMicetoHoles.py
    ├── BaruaRankReversal.py
    ├── BlissfulPairs.cpp
    ├── Cashew Conjecture(Prime No Based).c
    ├── CoinFlip.py
    ├── Consecutive Prime Sum.cpp
    ├── GasStations.py
    ├── Greatest Number with the Digits.py
    ├── HappySighting.cpp
    ├── Hourglass Sum.cpp
    ├── Kefa hates coins.cpp
    ├── LargestContiguousSumSubarray.py
    ├── LeftRotation.py
    ├── MinUniqueSum.py
    ├── NewCustomerAtElectronicsStore.cpp
    ├── NextGreaterElement.py
    ├── PuccaAndTheCardGame.cpp
    ├── ReplaceArray.cpp
    ├── ReplaceTheArray.cpp
    ├── Search_in_rotated_Sorted_array.cpp
    ├── SecretSanta.c
    ├── ShortestManOnTheTeam.cpp
    ├── TheElectronicStore.cpp
    ├── TrickOrTreat.cpp
    ├── ValidateSudoku.cpp
    ├── WaveArray.py
    └── matrixoperationusing2d.cpp
├── Backtracking
    └── NQueens.cpp
├── CONTRIBUTING.md
├── Dynamic Programming
    ├── Cut_Ribbon.java
    ├── Kadane_LargestSumContArray.cpp
    ├── LCS.cpp
    ├── LargestContiguousSumSubarray.py
    ├── MaxArraySum_NonAdjacent.py
    ├── MaxSizeSquareSubMatrix.cpp
    ├── MinAvgSubarray.cpp
    ├── NonDecreaseSubarray.py
    └── ZeroOneKnapsack.cpp
├── Greedy Algorithms
    ├── ActivitySelectionProblem.cpp
    ├── AutonomousCar.cpp
    ├── EatLessCupcakes.c
    ├── GreedyFlorist.py
    ├── JumpGame.cpp
    ├── KnapsackUsingArray.cpp
    ├── KnapsackUsingDictionaries.py
    ├── KnapsackUsingStruct.cpp
    ├── LargestNumberGivenDigitsAndSum.py
    └── SmallestNumberGivenDigitsAndSum.py
├── Hash table
    └── Group_anagrams.cpp
├── Linked Lists
    ├── Circular Linked List
    │   ├── CLL - Deletions.c
    │   └── CLL - Insertions.c
    ├── Doubly Linked List
    │   ├── DLL - All_Insertions.c
    │   ├── DLL - Deletions.c
    │   └── DequeLL.c
    └── Singly Linked List
    │   ├── Deletion at Any Position.c
    │   ├── Deletion at Ending.c
    │   ├── Deletion at beginning.c
    │   ├── FindLoopAndMidElement.cpp
    │   ├── Harry Potter and the Half Blood Prince.c
    │   ├── Insertion At Beginning.c
    │   ├── Insertion at any position.c
    │   ├── Linked List Deletions.c
    │   ├── Linked Lists Insertions.c
    │   ├── Linked Lists-Searching.c
    │   ├── LoopCheck.c
    │   ├── PalindromeCheck.c
    │   ├── Printing in reverse.c
    │   └── Reversing and Printing.c
├── Miscellaneous
    ├── 7DivisiblePairs.cpp
    ├── AccrualSystem.py
    ├── ConfusedInteger.cpp
    ├── ConsecutivePrimeSum.cpp
    ├── Counting Valleys.py
    ├── DigitsInFactorial.py
    ├── EsotericChairs.py
    ├── Factors57.py
    ├── HourGlass problem.c
    ├── Jumping on the Clouds.cpp
    ├── Kangaroo.cpp
    ├── NobleInteger.py
    ├── NotExactlyGCD.c
    ├── ParliamentSquare.py
    ├── ResetButtons.cpp
    ├── ResidueArithmetic.cpp
    ├── SquareInACircle.c
    ├── SumOfPairs.py
    ├── SumOfPrimes.cpp
    ├── TrailingZerosOfFactorial.py
    └── XOR.py
├── Patterns
    ├── AlphabetRangoli.py
    ├── BoxPattern.cpp
    ├── DesignerDoorMat.py
    ├── GreatPattern.py
    ├── PascalTriangle.cpp
    ├── Pattern1.py
    ├── Pattern2.py
    ├── Pattern3.py
    ├── Prime pyramid.cpp
    ├── PyramidByNumericals.py
    ├── SpiralMatrix.cpp
    ├── String Repetition.cpp
    └── SubwayRunners.cpp
├── Pointers
    ├── Nested2DPointers.c
    └── PointerArrays2D.c
├── Queue
    ├── DownToZero.cpp
    ├── StackUsingQueues.cpp
    └── The Circular Queue.c
├── README.md
├── Recursion
    ├── Fibonacci.py
    ├── JumpingOnClouds.py
    ├── MinimumNumberFunction.cpp
    ├── RecursiveInsertionSort.py
    ├── SumOfAllDigits.cpp
    ├── SumOfAllDigits.py
    ├── Tower_of_Hanoi.c
    ├── combinationStrings.cpp
    ├── gcd.cpp
    ├── powersum.cpp
    └── rat-in-a-maze-CPP.cpp
├── Sorting Techniques
    ├── AllSortingTechniques.cpp
    ├── DateSorting.cpp
    ├── Quick Sort.cpp
    └── Structures date sorting.cpp
├── Stacks
    ├── BalancedParenthesis.cpp
    ├── Harry Potter and the Sorceror's Stone.c
    ├── Harry Potter and the Sorceror's Stone.cpp
    ├── HistogramArea.cpp
    ├── MaxElementInStackArrays.c
    ├── MaxElementInStackLinkedLists.c
    ├── ParenthesisDepth.cpp
    ├── QueueUsingStacks.cpp
    └── Stacks_Using_LinkedLists.cpp
├── Strings
    ├── AmazingSubarrays.py
    ├── BinaryStringDuplication.py
    ├── CapitalizeFirstLetterName.py
    ├── CharCompression.cpp
    ├── CharCompression.py
    ├── ContactsApplication.py
    ├── DiscoverTheRightCharacter.cpp
    ├── DiscoverTheRightNumber.py
    ├── DiscoverTheSubstring.java
    ├── DiscoverTheSubstring.py
    ├── Lapindrome.py
    ├── MinimizeWasteCells.cpp
    ├── MinimizeWasteCells.py
    ├── Repeated String.py
    ├── ReverseVowels.cpp
    ├── StringConcatenation.cpp
    ├── StringConversion.cpp
    ├── allTrim.c
    ├── leftTrim.c
    └── rightTrim.c
├── Structures
    ├── EmployeeSheetSTL.cpp
    └── Structures date sorting.cpp
└── Trees
    ├── BST Traversals.c
    ├── HeightOfBinaryTree.c
    ├── HuffmanDecoding.cpp
    ├── InOrder.c
    ├── PostOrder.c
    ├── PostOrderFromPreAndInorder.cpp
    ├── PreOrder.c
    └── TraversalsAndHeight.cpp


/Arrays/ASmallerTeam.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |    A Smaller Team
 3 | 
 4 |    The coach from the previous problem has now changed his mind. He only wants to take n-k people into the team. He asks the first person in the line to go find the shortest person and switch places with him. He then asks the second person in line to go find the second shortest person and switch places with him. So on, until the kth person has switched with the Kth shortest person in front of the line.
 5 | 
 6 |    Formally, swap the first element of the array with the smallest element of the array, then second element of the array with the second smallest element in the array and so on. Repeat this process k times.
 7 | 
 8 |    INPUT
 9 | 
10 |    The first line of input is n (1≤n≤100), the number of applicants for the basketball team The second line of input is the heights of the n players (distinct positive numbers) each separated by a space. The third line of input is the number k (1≤k≤n)
11 | 
12 |    OUTPUT
13 | 
14 |    Print the heights of the players in a line after the k switches are complete.
15 | 
16 |    Sample Input 0
17 | 
18 |    7
19 |    4 9 6 3 1 7 5
20 |    4
21 |    Sample Output 0
22 | 
23 |    1 3 4 5 6 7 9
24 |  */
25 | 
26 | #include <stdio.h>
27 | #include <string.h>
28 | #include <math.h>
29 | #include <stdlib.h>
30 | 
31 | int main() {
32 |         int a,m,k;
33 |         cin>>a;
34 |         int b[a];
35 |         for(int i=0; i<a; i++)
36 |                 cin>>b[i];
37 |         int c;
38 |         cin>>c;
39 |         for(int i=0; i<c; i++)
40 |         {
41 |                 m=0;
42 |                 for(int j=0; j<a; j++)
43 |                 {
44 |                         if(b[m]>b[j])
45 |                         {
46 |                                 m=j;
47 |                         }
48 |                 }
49 |                 k=b[m];
50 |                 b[m]=b[i];
51 |                 b[i]=k;
52 |         }
53 |         for(int i=0; i<a; i++)
54 |         {
55 |                 cout<<b[i]<<" ";
56 |         }
57 |         return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/Arrays/ASortedTeam.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |    The number of applicants have now increased and the coach is now tired of trying to eliminate the shorter players. Instead, he just wants everyone to come and stand in ascending order of their heights, following the same routine he tried to use above.
 3 | 
 4 |    Formally, use the selection sort technique to sort the array of player heights.
 5 | 
 6 |    INPUT
 7 | 
 8 |    The first line of input is n (1≤n≤100), the number of applicants for the basketball team The second line of input is the heights of the n players (positive numbers) each separated by a space.
 9 | 
10 |    OUTPUT
11 | 
12 |    Print the heights of the players in a line after the sorting routine.
13 | 
14 |    Sample Input 0
15 | 
16 |    8
17 |    3 4 5 2 4 10 18 1
18 |    Sample Output 0
19 | 
20 |    1 2 3 4 4 5 10 18
21 |  */
22 | 
23 | #include <cmath>
24 | #include <cstdio>
25 | #include <vector>
26 | #include <iostream>
27 | #include <algorithm>
28 | using namespace std;
29 | 
30 | 
31 | int main() {
32 |         int a;
33 |         cin>>a;
34 |         int b[a];
35 |         for(int i=0; i<a; i++)
36 |                 cin>>b[i];
37 |         sort(b,b+a);
38 |         for(int i=0; i<a; i++)
39 |                 cout<<b[i]<<" ";
40 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT */
41 |         return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/Arrays/ArrayHill.cpp:
--------------------------------------------------------------------------------
 1 | // Array as a Hill
 2 | 
 3 | // Array of integers is a mountain, if:
 4 | 
 5 | // it is strictly increasing in the beginning;
 6 | // after that it is constant;
 7 | // after that it is strictly decreasing.
 8 | // The first block (increasing) and the last block (decreasing) may be absent. It is allowed that both of this blocks are absent.
 9 | // For example, the following three arrays are a mountain: [5, 7, 11, 11, 2, 1], [4, 4, 2], [7],
10 | // but the following three are not unimodal: [5, 5, 6, 6, 1], [1, 2, 1, 2], [4, 5, 5, 6].
11 | 
12 | // Write a program that checks if an array is a mountain.
13 | 
14 | // Input Format
15 | 
16 | // The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array.
17 | 
18 | // The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000) — the elements of the array.
19 | 
20 | // Output Format
21 | 
22 | // Print "yes" if the given array is a mountain. Otherwise, print "no".
23 | 
24 | 
25 | 
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     int n,i,max=0,pos,flag=1;
37 |     cin>>n;
38 |     int arr[n];
39 |     for(i=0;i<n;i++)
40 |     {
41 |         cin>>arr[i];
42 |         if(arr[i]>=max)
43 |         {   
44 |             max=arr[i];
45 |             pos=i;
46 |         } 
47 |     }
48 |     for(i=1;i<pos;i++)
49 |     {
50 |         int diff=arr[i]-arr[i-1];
51 |         if(diff==0 && arr[i]!=max)
52 |         {
53 |             flag=0;
54 |             break;
55 |         }
56 |         if(diff<0)
57 |         {
58 |             flag=0;
59 |             break;
60 |         }
61 |     }
62 |     for(i=pos;i<n-1;i++)
63 |     {
64 |         int diff=arr[i]-arr[i+1];
65 |         if(diff==0 && arr[i]!=max)
66 |         {
67 |             flag=0;
68 |             break;
69 |         }
70 |         if(diff<0)
71 |         {
72 |             flag=0;
73 |             break;
74 |         }
75 |     }
76 |     if(flag==0)
77 |         cout<<"no";
78 |     else
79 |         cout<<"yes";
80 |     return 0;
81 | }


--------------------------------------------------------------------------------
/Arrays/AssigningMicetoHoles.py:
--------------------------------------------------------------------------------
 1 | # Assigning mice to Holes
 2 | 
 3 | # There are N Mice and N holes are placed in a straight line.
 4 | 
 5 | # Each hole can accomodate only 1 mouse.
 6 | 
 7 | # A mouse can stay at his position, move one step right from x to x + 1, or move one step left from x to x − 1. Any of these moves consumes 1 minute.
 8 | 
 9 | # Assign mice to holes so that the time when the last mouse gets inside a hole is minimized.
10 | 
11 | # Input Format
12 | 
13 | # First line contains the integer N. Next line contains N integers, the position of the mice.
14 | # Third line contains N integers, the position of the holes.
15 | 
16 | # Constraints
17 | 
18 | # 1 <= N <= 105
19 | 
20 | # Output Format
21 | 
22 | # Output one number corresponding to the minimum number of minutes it will take for the last mice to go into the hole.
23 | 
24 | # Sample Input 0
25 | 
26 | # 3
27 | # 4 -4 2
28 | # 4 0 5
29 | # Sample Output 0
30 | 
31 | # 4
32 | 
33 | n = int(input())
34 | ct=0
35 | m=0
36 | mice = list(map(int, input().split()))
37 | holes = list(map(int, input().split()))
38 | mice.sort()
39 | holes.sort()
40 | for i in range(n):
41 |     ct=abs(holes[i]-mice[i])
42 |     if(ct>m):
43 |         m=ct
44 | print(m)


--------------------------------------------------------------------------------
/Arrays/BaruaRankReversal.py:
--------------------------------------------------------------------------------
 1 | # Barua and his Rank Reversal
 2 | 
 3 | # You've been given a permutation of containing N distinct elements between 1 and N, both included. (1<=N<=10^3)
 4 | # The rank of an element in this array is the number of elements to it's left which are strictly lesser than it.
 5 | # You have been given array,formulate it's rank array.
 6 | # Seems tough right? Let's make the question a bit simpler :P
 7 | 
 8 | # Instead of the actual array, you would be given a rank array. Formulate the initial array from it. It is guaranteed 
 9 | # that the solution would be unique.
10 | 
11 | # Input Format
12 | # In the first line input N(1<=N<=10^3)
13 | # In the next line input rank array 0<=Rank[i]
14 | 
15 | # Output Format
16 | # Print the N integers of the actual array.
17 | 
18 | # NOTE : All elements in the rank array may or may not be distinct
19 | 
20 | # Sample Input 0
21 | 
22 | # 3
23 | # 0 1 2
24 | # Sample Output 0
25 | 
26 | # 1 2 3
27 | # Explanation 0
28 | 
29 | # If the actual array is : 1 2 3
30 | # Rank array will be : 0 1 2 Thus it satisfies the provided input.
31 | # Because there are 0 elements to the left of 1 which are lesser than 1, 1 element to the left of 2 which is lesser than 
32 | # 2 and 2 elements to the left of 3 which are lesser than 3.
33 | 
34 | # Enter your code here. Read input from STDIN. Print output to STDOUT
35 | 
36 | n = int(input())
37 | l = [x for x in range(1,n+1)]
38 | # print(l)
39 | mylist = [x for x in range(1,n+1)]
40 | # print(mylist)
41 | 
42 | res = []
43 | 
44 | for i in range(n):
45 |     pos=ranks[n-i-1]
46 |     res.append(mylist[pos])
47 |     mylist.pop(pos)
48 | for x in range(n-1,-1,-1):
49 |     print(res[x],end=" ")


--------------------------------------------------------------------------------
/Arrays/BlissfulPairs.cpp:
--------------------------------------------------------------------------------
 1 | /*Given a permutation of number from 1 to N. Among all the subarrays, find the number of unique pairs (a,b) such that a≠b and a is maximum and b is second maximum in that subarray.
 2 | 
 3 | Input Format
 4 | 
 5 | First line contains an integer, N.
 6 | Second line contains N space separated distinct integers, Ai, denoting the permutation.
 7 | 
 8 | Constraints
 9 | 
10 | 1≤N≤10^5
11 | 1≤Ai≤N
12 | 
13 | Output Format
14 | 
15 | Print the required answer.
16 | 
17 | Sample Input 0
18 | 
19 | 5
20 | 1 2 3 4 5
21 | 
22 | Sample Output 0
23 | 
24 | 4
25 | 
26 | Explanation 0
27 | 
28 | All possible subarrays are :
29 | 1
30 | 1 2
31 | 1 2 3
32 | 1 2 3 4
33 | 1 2 3 4 5
34 | 2
35 | 2 3
36 | 2 3 4
37 | 2 3 4 5
38 | 3
39 | 3 4
40 | 3 4 5
41 | 4
42 | 4 5
43 | 5
44 | 
45 | The 4 unique pairs are :
46 | (2, 1)
47 | (3, 2)
48 | (4, 3)
49 | (5, 4) */
50 | 
51 | #include <cmath>
52 | #include <cstdio>
53 | #include <vector>
54 | #include <iostream>
55 | #include <algorithm>
56 | using namespace std;
57 | 
58 | 
59 | int main() {
60 | int n; cin>>n;
61 |     int a[n];
62 |     for(int i=0;i<n;i++)
63 |     cin>>a[i];
64 |     
65 |     int count=0;
66 |     
67 |     for(int i=0;i<n;i++)
68 |     {
69 |         int max=0;
70 |         
71 |         for(int j=i+1;j<n;j++)
72 |         {
73 |             if(a[i]<a[j])
74 |             {
75 |                 count++;
76 |                 break;
77 |             }
78 |             
79 |             else if(a[i]>a[j] && a[j]>max)
80 |             {
81 |                 max=a[j];
82 |                 count++;
83 |             }
84 |             else continue;
85 |         }
86 |     }
87 |     
88 |     cout<<count<<endl;
89 |     
90 |     return 0;
91 | }
92 | 
93 | 


--------------------------------------------------------------------------------
/Arrays/Consecutive Prime Sum.cpp:
--------------------------------------------------------------------------------
 1 | // Consecutive Prime Sum
 2 | 
 3 | // Some prime numbers can be expressed as Sum of other consecutive prime numbers.
 4 | 
 5 | // For example
 6 | 
 7 | // 5 = 2 + 3 
 8 | // 17 = 2 + 3 + 5 + 7 
 9 | // 41 = 2 + 3 + 5 + 7 + 11 + 13
10 | 
11 | // Your task is to find out how many prime numbers which satisfy this property are present in the range 3 to N subject to a constraint that summation should always start with number 2.
12 | 
13 | // Write code to find out number of prime numbers that satisfy the above mentioned property in a given range.
14 | 
15 | // Input Format:
16 | // Each test case contains a number N <= 1000000000
17 | 
18 | // Output Format:
19 | // Print the total number of all such prime numbers which are less than or equal to N.
20 | 
21 | #include <cmath>
22 | #include <cstdio>
23 | #include <vector>
24 | #include <iostream>
25 | #include <algorithm>
26 | using namespace std;
27 | 
28 | int isPrime(int n)
29 | {
30 |     for(int i=2;i<=(int)sqrt(n);i++)
31 |     {
32 |         if(n%i==0)
33 |             return 0;
34 |     }
35 |     return 1;
36 | }
37 | 
38 | int main() {
39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
40 |     int i,j,n,ct=0,sum=2;
41 |     cin>>n;
42 |     for(i=3;sum<n;i+=2)
43 |     {
44 |         if(isPrime(i))
45 |         {    
46 |             sum+=i;
47 |             if(isPrime(sum) && sum<=n)
48 |                 ct++;
49 |         }
50 |     }
51 |     cout<<ct;
52 |     return 0;
53 | }


--------------------------------------------------------------------------------
/Arrays/GasStations.py:
--------------------------------------------------------------------------------
 1 | # Gas Stations
 2 | 
 3 | # There are N gas stations along a circular route, where the amount of gas at station i is gas[i].
 4 | 
 5 | # You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.
 6 | 
 7 | # Print the minimum starting gas station’s index if you can travel around the circuit once, otherwise print -1.
 8 | 
 9 | # You can only travel in one direction. i to i+1, i+2, ... n-1, 0, 1, 2.. Completing the circuit means starting at i and ending up at i again.
10 | 
11 | # Input Format
12 | 
13 | # First line contains the number of gas stations N.
14 | # Second line contains N integers, the ith of them denoting gas[i].
15 | # Third line contains N integers, the ith of them denoting cost[i].
16 | 
17 | # Constraints
18 | 
19 | # 1 <= N <= 105
20 | 
21 | # Output Format
22 | 
23 | # Print the minimum starting gas station’s index if you can travel around the circuit once, otherwise print -1.
24 | 
25 | # Sample Input 0
26 | 
27 | # 2
28 | # 1 2
29 | # 2 1
30 | # Sample Output 0
31 | 
32 | # 1
33 | 
34 | n=int(input())
35 | gas = list(map(int, input().split()))
36 | cost = list(map(int, input().split()))
37 | sg=sum(gas)
38 | sc=sum(cost)
39 | if sc>sg:
40 |     print("-1")
41 | else:
42 |     tank=0
43 |     pos=-1
44 |     count=0
45 |     i=0
46 |     while(True):
47 |         if tank==0:
48 |             tank+=gas[i]
49 |         if i!=len(gas)-1:
50 |             if tank-cost[i]>=0:
51 |                 tank=tank-cost[i]+gas[i+1]
52 |                 count=count+1
53 |                 if count==len(gas):
54 |                     pos=i+1
55 |                     break
56 |                 i=i+1
57 |             else:
58 |                 if count==len(gas)-1:
59 |                     break
60 |                 else:
61 |                     tank=0
62 |                     count=0
63 |                     i+=1
64 |         else:
65 |             if tank-cost[i]>=0:
66 |                 tank=tank-cost[i]+gas[0]
67 |                 count+=1
68 |                 i=0
69 |                 if(count==n):
70 |                     pos=i
71 |                     break
72 |             else:
73 |                 break
74 |     print(pos)
75 | 


--------------------------------------------------------------------------------
/Arrays/Greatest Number with the Digits.py:
--------------------------------------------------------------------------------
 1 | #Given a number N, find the largest number that you can form with its digits.
 2 | #You are allowed to rearrange the digits in any way you wish as long as the resultant number does not contain any leading zeroes.
 3 | 
 4 | #Input Format
 5 | 
 6 | #Only one line of input with number N.
 7 | 
 8 | #Constraints
 9 | 
10 | #1 <= N <= 10^9
11 | 
12 | #Output Format
13 | 
14 | #Output one number, which is the largest possible number that can be formed with the digits of N.
15 | 
16 | #Sample Input 0
17 | 
18 | #5318008
19 | 
20 | #Sample Output 0
21 | 
22 | #8853100
23 | 
24 | #code:-
25 | 
26 | n = int(input())
27 | l = []
28 | while(n):
29 |     x = n % 10
30 |     l.append(x)
31 |     n = n // 10
32 | m = l[0]
33 | le = len(l)
34 | l.sort(reverse = True)
35 | 
36 | for i in range(le):
37 |     print(l[i], end ='')
38 | 


--------------------------------------------------------------------------------
/Arrays/HappySighting.cpp:
--------------------------------------------------------------------------------
 1 | /*1. There are n pictures delivered for the new exhibition. The i-th painting has beauty ai. We know that a visitor becomes happy every time he passes from a painting to a more beautiful one.
 2 | 
 3 |    We are allowed to arranged pictures in any order. What is the maximum possible number of times the visitor may become happy while passing all pictures from first to last. In other words, we are allowed to rearrange elements of array a in any order. What is the maximum possible number of indices i (1 <= i <= n - 1), such that ai + 1 > ai.
 4 | 
 5 |    Input Format
 6 | 
 7 |    The first line of the input contains integer n — the number of painting.
 8 | 
 9 |    The second line contains the sequence a1, a2, ..., an, where ai means the beauty of the i-th painting.
10 | 
11 |    Constraints
12 | 
13 |    1 <= n <= 1000
14 |    1 <= ai <= 1000
15 | 
16 |    Output Format
17 | 
18 |    Print one integer — the maximum possible number of neighbouring pairs, such that ai + 1 > ai, after the optimal rearrangement.
19 | 
20 | 
21 |    input
22 |    5
23 |    20 30 10 50 40
24 |    output
25 |    4
26 |    input
27 |    4
28 |    200 100 100 200
29 |    output
30 |    2
31 |  */
32 | 
33 | 
34 | 
35 | 
36 | 
37 | #include <algorithm>
38 | #include <cmath>
39 | #include <cstdio>
40 | #include <cstring>
41 | #include <iostream>
42 | #include <string>
43 | using namespace std;
44 | int main() {
45 |         int a, k;
46 |         cin >> a;
47 |         int b[a];
48 |         for (int i = 0; i < a; i++) {
49 |                 cin >> b[i];
50 |         }
51 |         sort(b, b + a);
52 |         for (int i = 1; i < a; i++) {
53 |                 for (int j = i; j < a; j++) {
54 |                         if (b[i-1] < b[j]) {
55 |                                 k=b[j];
56 |                                 for(int k=j; k>i; k--) {
57 |                                         b[k]=b[k-1];
58 |                                 }
59 |                                 b[i]=k;
60 |                                 break;
61 |                         }
62 |                 }
63 |         }
64 |         k=0;
65 |         for (int i = 1; i < a; i++) {
66 |                 if (b[i]>b[i-1]) {
67 |                         k++;
68 |                 }
69 |         }
70 |         cout<<k;
71 | }
72 | 


--------------------------------------------------------------------------------
/Arrays/Kefa hates coins.cpp:
--------------------------------------------------------------------------------
 1 | /* Kefa hates coins and thinks that coins are a currency of the poor.
 2 | 
 3 | She has N coins with her, ith of them having the value Ai.
 4 | She goes to a shop to buy M gifts, with the price of ith gift being Pi.
 5 | 
 6 | She wants to get rid of as many coins as she can and she buys the gift one by one from the 1st one to the Mth one. She adopts the following strategy while buying any particular gift i : She wants to give the shopkeeper a total of X coins whose value sum up to K such that -
 7 | 
 8 | K = Pi
 9 | X is maximized
10 | K - Pi is minimized
11 | 
12 | She does not consider other gifts while buying a particular gift i.e. while buying every gift she tries her best to satisfy the above conditions for that gift.
13 | 
14 | Your task is, given the array A and the array P, for every gift, find and print the values of X and K, or print -1 -1 if she will not be able to buy the gift at all.
15 | 
16 | INPUT
17 | First line contains two numbers N and M.
18 | Second line contains the array A of size N.
19 | Third line contains the array P of size M.
20 | 
21 | INPUT
22 | Print M lines of output, for every gift two integers on a new line.
23 | The two integers should denote the values of X and K while buying that gift optimally.
24 | If it is not possible to buy a particular gift with available coins, print "-1 -1"
25 | 
26 | CONSTRAINTS
27 | 1 = N, M = 105
28 | 1 = Ai, Pi = 105
29 | 
30 | Sample Input 0
31 | 
32 | 10 5
33 | 1 2 3 4 5 1 2 3 4 5
34 | 6
35 | 6
36 | 6
37 | 6
38 | 6
39 | Sample Output 0
40 | 
41 | 4 6
42 | 2 6
43 | 2 8
44 | 2 10
45 | -1 -1 */
46 | 
47 | 
48 | 
49 | #include <cmath>
50 | #include <cstdio>
51 | #include <vector>
52 | #include <iostream>
53 | #include <algorithm>
54 | using namespace std;
55 | 
56 | 
57 | int main() {
58 |     int n, m;
59 |     cin>>n>>m;
60 |     int a[n], p[m], i, j, count=0;
61 |     for(i = 0;i < n; i++)
62 |     {
63 |         cin>>a[i];
64 |         count = count+a[i];
65 |     }
66 |     for(i = 0;i < m; i++)
67 |         cin>>p[i];
68 |     sort(a, a+n);
69 |     int pos = 0;
70 |     for(i = 0; i < m; i++)
71 |     {
72 |         int x = 0,flag = 0,j = pos,c = 0;
73 |         while(j<n)
74 |         {
75 |             x = x + a[j];
76 |             c++;
77 |             if(x >= p[i])
78 |             {
79 |                 pos = j + 1;
80 |                 flag = 1;
81 |                 break;
82 |             }
83 |             j++;
84 |         }
85 |         if(flag == 1)
86 |         {
87 |             cout<<c<<" "<<x<<endl;
88 |         }
89 |         else
90 |         {
91 |             cout<<"-1 -1"<<endl;
92 |         }
93 |     }
94 |     return 0;
95 | }
96 | 


--------------------------------------------------------------------------------
/Arrays/LargestContiguousSumSubarray.py:
--------------------------------------------------------------------------------
 1 | # Largest Sum Contiguous Subarray
 2 | 
 3 | # Write an efficient program to find the sum of contiguous subarray within a one-dimensional array of numbers which has the largest sum.
 4 | 
 5 | 
 6 | 
 7 | # Sample input:
 8 | 
 9 | # -2 -3 4 -1 -2 1 5 -3
10 | 
11 | 
12 | #Sample output:
13 | 
14 | # 7
15 | 
16 | 
17 | # Explanation:
18 | 
19 | #  4,-1,-2,1,5 has the largest sum
20 | 
21 | 
22 | 
23 | 
24 | # CODE:
25 | 
26 | import sys
27 | 
28 | 
29 | 
30 | arr = list(map(int, input().split()))
31 | 
32 | 
33 | max_so_far = -sys.maxsize-1
34 | 
35 | 
36 | max_ending_here = 0
37 | 
38 | 
39 | size = len(arr)
40 | 
41 | 
42 | 
43 | for i in range(size):
44 | 
45 |     max_ending_here = max_ending_here+arr[i]
46 | 
47 |     
48 | if(max_so_far<max_ending_here):
49 | 
50 |         max_so_far = max_ending_here
51 | 
52 |     if(max_ending_here<0):
53 | 
54 |         max_ending_here=0
55 | 
56 | 
57 | 
58 | 
59 | print(max_so_far)


--------------------------------------------------------------------------------
/Arrays/LeftRotation.py:
--------------------------------------------------------------------------------
 1 | # Given an array, Mister Arr the owner of the array wants to move each element k places
 2 | # to its left. I.E. the array a[0],a[1],a[2],...a[n] becomes a[1],a[2]...a[n],a[0]
 3 | # after moving one place to the left.
 4 | # Note that the first element becomes the last element after each rotation.
 5 | 
 6 | # Input Format
 7 | 
 8 | # The first line contains two space-separated integers denoting the respective values of n
 9 | # (the number of integers) and k (the number of left rotations you must perform).
10 | # The second line contains n space-separated integers describing the respective elements of the array's initial state.
11 | 
12 | # Sample Input
13 | 
14 | # 5 4
15 | # 1 2 3 4 5
16 | # Sample Output
17 | 
18 | # 5 1 2 3 4
19 | 
20 | a, b = map(int, input().split())
21 | li = list(map(int, input().split()))
22 | newl = []
23 | for i in range(a):
24 |     pos = (i + b)
25 |     if pos >= a:
26 |         pos = pos % a
27 |     newl.append(li[pos])
28 | for i in newl:
29 |     print(i, end=' ')
30 | 


--------------------------------------------------------------------------------
/Arrays/MinUniqueSum.py:
--------------------------------------------------------------------------------
 1 | # Minimum Unique Array Sum
 2 | 
 3 | # If any element has a duplicate in the array, increment it by 1 until no 2 elements are the same in the array.
 4 | # Find the sum of all the array elements once all elements are unique.
 5 | 
 6 | # Sample Input: [3,1,3,5,7]
 7 | # Output: 20
 8 | 
 9 | # Explanation:
10 | # arr = [3,1,3,5,7]
11 | # arrunique = [3,1,4,5,7]
12 | # sum = 20
13 | 
14 | 
15 | #!/bin/python3
16 | 
17 | import math
18 | import os
19 | import random
20 | import re
21 | import sys
22 | 
23 | 
24 | 
25 | #
26 | # Complete the 'getMinimumUniqueSum' function below.
27 | #
28 | # The function is expected to return an INTEGER.
29 | # The function accepts INTEGER_ARRAY arr as parameter.
30 | #
31 | 
32 | def getMinimumUniqueSum(arr):
33 |     # Write your code here
34 |     l = []
35 |     s = 0
36 |     for i in arr:
37 |         if i not in l:
38 |             print('appended',i)
39 |             l.append(i)
40 |             s+=i
41 |         else:
42 |             while i in l:
43 |                 i+=1
44 |             l.append(i)
45 |             print('appended',i)
46 |             s+=i
47 |     return s
48 | 
49 | if __name__ == '__main__':
50 |     fptr = open(os.environ['OUTPUT_PATH'], 'w')
51 | 
52 |     arr_count = int(input().strip())
53 | 
54 |     arr = []
55 | 
56 |     for _ in range(arr_count):
57 |         arr_item = int(input().strip())
58 |         arr.append(arr_item)
59 | 
60 |     result = getMinimumUniqueSum(arr)
61 | 
62 |     fptr.write(str(result) + '\n')
63 | 
64 |     fptr.close()
65 | 


--------------------------------------------------------------------------------
/Arrays/NewCustomerAtElectronicsStore.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |    The server is finally happy that he sorted the line and now he gets to sell his portable chargers. But alas, a new person enters with a battery percentage of k comes to the store and stands at the back of the queue. Now he has to fit him in this already ascending ordered queue. He asks for your help.
 3 | 
 4 |    Formally, you are given an array of size n where the first n - 1 elements are sorted in ascending order and the last element can be any value. Sort this array by sliding the last element into its correct position.
 5 | 
 6 |    INPUT
 7 | 
 8 |    The first line of input is n (1≤n≤100), the number of customers in the queue. The second line of input is the battery percentages of the n customers (positive numbers less than 100)
 9 |    the first n - 1 of which are standing in ascending order according to their battery percentage.
10 | 
11 |    OUTPUT
12 | 
13 |    Print the battery percentages of the customers in a line after the new person has been put in his right place in the queue.
14 | 
15 |    Sample Input 0
16 | 
17 |    6
18 |    1 3 5 7 9 4
19 |    Sample Output 0
20 | 
21 |    1 3 4 5 7 9
22 |  */
23 | 
24 | #include <cmath>
25 | #include <cstdio>
26 | #include <vector>
27 | #include <iostream>
28 | #include <algorithm>
29 | using namespace std;
30 | 
31 | 
32 | int main() {
33 |         int a,k;
34 |         cin>>a;
35 |         int b[a];
36 |         for(int i=0; i<a; i++)
37 |                 cin>>b[i];
38 |         for(int i=0; i<a; i++)
39 |         {
40 |                 for(int i=a-1; i>1; i--)
41 |                 {
42 |                         if(b[i]>b[i+1])
43 |                         {
44 |                                 k=b[i];
45 |                                 b[i]=b[i+1];
46 |                                 b[i+1]=k;
47 |                         }
48 |                 }
49 |         }
50 |         for(int i=0; i<a; i++)
51 |                 cout<<b[i]<<" ";
52 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT */
53 |         return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Arrays/NextGreaterElement.py:
--------------------------------------------------------------------------------
 1 | # Next Greater Element
 2 | 
 3 | # Given an array, print the Next Greater Element (NGE) for every element. The Next greater Element for an element x is the first greater element on the right side of x in array. Elements for which no greater element exist, consider next greater element as -1.
 4 | 
 5 | # Examples:
 6 | 
 7 | # For any array, rightmost element always has next greater element as -1.
 8 | # For an array which is sorted in decreasing order, all elements have next greater element as -1.
 9 | # For the input array [4, 5, 2, 25}, the next greater elements for each element are as follows.
10 | # Element       NGE
11 | #    4      -->   5
12 | #    5      -->   25
13 | #    2      -->   25
14 | #    25     -->   -1
15 | # d) For the input array [13, 7, 6, 12}, the next greater elements for each element are as follows.
16 | 
17 | #   Element        NGE
18 | #    13      -->    -1
19 | #    7       -->     12
20 | #    6       -->     12
21 | #    12      -->     -1
22 | 
23 | 
24 | # cook your dish here
25 | arr = list(map(int,input().split()))
26 | 
27 | for i in range(0,len(arr),1): 
28 |     next = -1
29 |     for j in range(i+1,len(arr),1):
30 |         if arr[i]<arr[j]: 
31 |             next = arr[j] 
32 |             break
33 |  
34 |     print(str(arr[i])+str(next))


--------------------------------------------------------------------------------
/Arrays/PuccaAndTheCardGame.cpp:
--------------------------------------------------------------------------------
 1 | // Pucca and The Card Game
 2 | 
 3 | // Pucca and Garu are playing a card game that is explained as follows : 
 4 | // 1. N number of cards are placed in a straight line.
 5 | // 2. Cards are numbered 1 to N from left to right and the ith card has a number Ai written on it.
 6 | // 3. Pucca plays first, then Garu, then Pucca and so on.
 7 | // 4. In each turn a player can choose one card, either the rightmost card or the leftmost card.
 8 | // 5. Whatever card a player chooses, the number on that card is added to the players score and the card is removed from the game.
 9 | // 6. The game ends when there are no other cards to pick.
10 | // 7. At the end of the game, the player with the maxmimum score wins.
11 | // 8. If both players have equal scores, then Pucca wins.
12 | 
13 | // Pucca and Garu are feeling lazy on this sunday afternoon and have asked you to write a program to determine who the winner of the game will be.
14 | 
15 | // INPUT
16 | 
17 | // First line contains the number of cards N. (1 <= N <= 105)
18 | // Second line contains N space separated integers, ith of them denoting Ai. (1 <= Ai <= 106)
19 | 
20 | // OUTPUT
21 | 
22 | // Print "Pucca" (without quotes) if Pucca wins or "Garu" (without quotes) if Garu wins.
23 | 
24 | // Sample Input 0
25 | 
26 | // 5
27 | // 9 3 7 4 8
28 | // Sample Output 0
29 | 
30 | // Pucca
31 | // Explanation 0
32 | 
33 | // Turn 1 : Pucca Takes 9 (Pucca - 9 || Garu - 0 ) 
34 | // Turn 2 : Garu Takes 8 (Pucca - 9 || Garu - 8 ) 
35 | // Turn 3 : Pucca Takes 4 (Pucca - 13 || Garu - 8 ) 
36 | // Turn 4 : Garu Takes 7 (Pucca - 13 || Garu - 15) 
37 | // Turn 5 : Pucca Takes 3 (Pucca - 16 || Garu - 15) 
38 | // Pucca wins
39 | 
40 | #include <cmath>
41 | #include <cstdio>
42 | #include <vector>
43 | #include <iostream>
44 | #include <algorithm>
45 | using namespace std;
46 | 
47 | 
48 | int main() {
49 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
50 |     int n,i,low,high;
51 |     cin>>n;
52 |     int arr[n];
53 |     int pucca=0;
54 |     int garu=0;
55 |     for(i=0;i<n;i++)
56 |         cin>>arr[i];
57 |     low=0;
58 |     high=n-1;
59 |     while(low<high)
60 |     {
61 |         if(arr[low]>=arr[high])
62 |         {
63 |             if((low+high)%2!=0)
64 |                 pucca+=arr[low];
65 |             else
66 |                 garu+=arr[low];
67 |             low++;
68 |         }
69 |         else
70 |         {
71 |             if((low+high)%2!=0)
72 |                 pucca+=arr[high];
73 |             else
74 |                 garu+=arr[high];
75 |             high--;
76 |         }
77 |     }
78 |     // cout<<"Pucca:"<<pucca<<"\nGaru:"<<garu<<endl;
79 |     if(pucca>=garu)
80 |         cout<<"Pucca";
81 |     else
82 |         cout<<"Garu";
83 |     return 0;
84 | }


--------------------------------------------------------------------------------
/Arrays/ReplaceArray.cpp:
--------------------------------------------------------------------------------
 1 | // Replace The Array
 2 | 
 3 | // Given an array of integers, replace every element with the greatest element on the right side in the array. Replace last element with 0 as there no element on the right side of it.
 4 | 
 5 | // Input Format
 6 | 
 7 | // First line contains N , the number of Numbers. Next line contains N integers a[1]..a[n] the numbers
 8 | 
 9 | // Constraints
10 | 
11 | // 1<= N <= 10^5
12 | // 1<= ai <= 10^5
13 | 
14 | // Output Format
15 | 
16 | // Print the array required
17 | 
18 | // Sample Input 0
19 | 
20 | // 6
21 | // 6 7 4 3 5 2
22 | // Sample Output 0
23 | 
24 | // 7 5 5 5 2 0 
25 | 
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     int n,i;
37 |     cin>>n;
38 |     int arr[n];
39 |     for(i=0;i<n;i++)
40 |         cin>>arr[i];
41 |     int max=arr[n-1];
42 |     arr[n-1]=0;
43 |     for(i=n-2;i>=0;i--)
44 |     {
45 |         if(arr[i]>max)
46 |         {
47 |             int temp=arr[i];
48 |             arr[i]=max;
49 |             max=temp;
50 |         }
51 |         else
52 |         {
53 |             arr[i]=max;
54 |         }
55 |     }
56 |     for(i=0;i<n;i++)
57 |         cout<<arr[i]<<" ";
58 |     return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/Arrays/ReplaceTheArray.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |    Given an array of integers, replace every element with the greatest element on the right side in the array. Replace last element with 0 as there no element on the right side of it.
 3 | 
 4 |    Input Format
 5 | 
 6 |    First line contains N , the number of Numbers. Next line contains N integers a[1]..a[n] the numbers
 7 | 
 8 |    Constraints
 9 | 
10 |    1<= N <= 10^5
11 |    1<= ai <= 10^5
12 | 
13 |    Output Format
14 | 
15 |    Print the array required
16 | 
17 |    Sample Input 0
18 | 
19 |    6
20 |    6 7 4 3 5 2
21 |    Sample Output 0
22 | 
23 |    7 5 5 5 2 0
24 |  */
25 | #include <cmath>
26 | #include <cstdio>
27 | #include <vector>
28 | #include <iostream>
29 | #include <algorithm>
30 | using namespace std;
31 | 
32 | 
33 | int main() {
34 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT */
35 |         int n;
36 |         cin>>n;
37 |         int a[n];
38 |         for(int i=0; i<n; i++)
39 |                 cin>>a[i];
40 | 
41 |         int max = a[n-1];
42 |         int b[n];
43 |         b[n-1] = 0;
44 | 
45 |         for(int i=n-2; i>=0; i--)
46 |         {
47 |                 b[i] = max;
48 |                 if(max < a[i])
49 |                         max = a[i];
50 |         }
51 |         for(int i=0; i<n; i++)
52 |                 cout<<b[i]<<" ";
53 |         return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Arrays/Search_in_rotated_Sorted_array.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
 3 | 
 4 | (i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).
 5 | 
 6 | You are given a target value to search. If found in the array return true, otherwise return false.
 7 | 
 8 | Example 1:
 9 | 
10 | Input: nums = [2,5,6,0,0,1,2], target = 0
11 | Output: true
12 | Example 2:
13 | 
14 | Input: nums = [2,5,6,0,0,1,2], target = 3
15 | Output: false
16 | 
17 | */
18 | 
19 | class Solution {
20 | public:
21 |     bool search(vector<int>& nums, int target) 
22 |     {
23 |         while (nums.size()>1 && nums.back()==nums[0])
24 |             nums.pop_back();
25 |         
26 |         int left = 0;
27 |         int right = nums.size()-1;
28 |         
29 |         while (left<right)
30 |         {
31 |             int mid = left+(right-left)/2;
32 |             
33 |             if (nums[mid] == target) return true;
34 |             
35 |             if (nums[mid]>=nums[0] == target>=nums[0])
36 |             {
37 |                 if (nums[mid]<target)
38 |                     left = mid+1;
39 |                 else
40 |                     right = mid-1;
41 |             }
42 |             else if (target>=nums[0])
43 |                 right = mid-1;
44 |             else
45 |                 left = mid+1;
46 |         }
47 |         
48 |         if (left==right && nums[left]==target)
49 |             return true;
50 |         else
51 |             return false;
52 |     }
53 | };


--------------------------------------------------------------------------------
/Arrays/SecretSanta.c:
--------------------------------------------------------------------------------
 1 | // Bug's friends play Secret Santa. He has n friends. Lets number them from 1 to n. 
 2 | // For each friend i he knows pi, the person that i gave a gift to. 
 3 | // Bug needs to find out ri for each friend i, which is the person that i received a gift from.
 4 | 
 5 | // Input Format
 6 | 
 7 | // First line contains one number n. Second line contains n space separated integers.
 8 | 
 9 | // Constraints
10 | 
11 | // 1 <= n <= 100
12 | 
13 | // Output Format
14 | 
15 | // Print n space-separated integers: the i-th number should equal the number of the friend who gave a gift to friend number i.
16 | 
17 | // Sample Input:
18 | 
19 | // 4
20 | // 2 3 4 1
21 | 
22 | // Sample Output:
23 | 
24 | // 4 1 2 3 
25 | 
26 | // Explanation:
27 | // Ouput is
28 | 
29 | // 4 : because 1 received a gift from 4
30 | 
31 | // 1 : because 2 received a gift from 1
32 | 
33 | // 2 : because 3 received a gift from 2
34 | 
35 | // 3 : because 4 received a gift from 3
36 | 
37 | 
38 | #include <stdio.h>
39 | #include <string.h>
40 | #include <math.h>
41 | #include <stdlib.h>
42 | 
43 | int main() {
44 |     int n;
45 |     scanf("%d", &n);
46 |     int arr[n], b[n];
47 |     int count = 0;
48 |     for(int i = 0; i<n; i++)
49 |     {
50 |         scanf("%d", &arr[i]);
51 |     }
52 |     for(int i=0; i<n; i++)
53 |     {
54 |         int x= arr[i];
55 |         b[x-1]= i+1;
56 |     }
57 |     for(int i=0; i<n;i++)
58 |         printf("%d ", b[i]);   
59 |     return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/Arrays/ShortestManOnTheTeam.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |    There are n people who want to apply for the selections of the basketball team. But the coach has decided to take only n-1 people. Irrespective of the skill of the players, the coach believes that the height of the player is the most important factor. Therefore, by default the shortest of the applicants will be removed. From amongst the line of players (who are in random order), the coach finds it difficult to find the shortest person. Fortunately, you, the person in the front of the line knows programming. He asks you to go find the shortest person in the line and switch places with him.
 3 | 
 4 |    Formally, swap the first element of the array with the smallest element of the array.
 5 | 
 6 |    INPUT
 7 | 
 8 |    The first line of input is n (1≤n≤100000), the number of applicants for the basketball team The second line of input is the heights of the n players (positive numbers) each separated by a space.
 9 | 
10 |    OUTPUT
11 | 
12 |    Print the heights of the players in a line after the shortest person has swapped places with the first person.
13 | 
14 |    Sample Input 0
15 | 
16 |    5
17 |    3 8 2 5 9
18 |    Sample Output 0
19 | 
20 |    2 8 3 5 9
21 |  */
22 | 
23 | #include <cmath>
24 | #include <cstdio>
25 | #include <vector>
26 | #include <iostream>
27 | #include <algorithm>
28 | using namespace std;
29 | 
30 | 
31 | int main() {
32 |         int a;
33 |         cin>>a;
34 |         int b[a];
35 |         for(int i=0; i<a; i++)
36 |                 cin>>b[i];
37 |         int m;
38 |         m=0;
39 |         for(int i=0; i<a; i++)
40 |         {
41 |                 if(b[m]>b[i])
42 |                         m=i;
43 |         }
44 |         int k;
45 |         k=b[0];
46 |         b[0]=b[m];
47 |         b[m]=k;
48 |         for(int i=0; i<a; i++)
49 |                 cout<<b[i]<<" ";
50 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT */
51 |         return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Arrays/TheElectronicStore.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |    There is a queue of n people in front of the local electronics store. All of them have their phones at various battery percentages and are looking to buy a portable charger quickly before their battery runs out. The server at the counter understands this and he doesn’t want any of his customers’ phones to run out of charge. He, being an algorithmist, quickly determines that he wants to implement bubble sort technique to sort the customers in the queue, such that, the person whose phone is going to die the quickest, comes to the front of the line and gets a portable charger.
 3 | 
 4 |    The server at the counter is an algorithmist and not a programmer, hence he asks you to do the job for him.
 5 | 
 6 |    Formally, sort an array using bubblesort.
 7 | 
 8 |    INPUT
 9 | 
10 |    The first line of input is n (1≤n≤100), the number of customers in the queue
11 |    The second line of input is the battery percentages of the n customers (positive numbers less than 100) each separated by a space.
12 | 
13 |    OUTPUT
14 | 
15 |    Print the battery percentages of the customers in a line after the sorting is completed.
16 | 
17 |    Sample Input 0
18 | 
19 |    8
20 |    3 4 5 2 4 10 18 1
21 |    Sample Output 0
22 | 
23 |    1 2 3 4 4 5 10 18
24 |  */
25 | 
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |         int a,k;
36 |         cin>>a;
37 |         int b[a];
38 |         for(int i=0; i<a; i++)
39 |                 cin>>b[i];
40 |         for(int i=0; i<a; i++)
41 |         {
42 |                 for(int i=0; i<a-1; i++)
43 |                 {
44 |                         if(b[i]>b[i+1])
45 |                         {
46 |                                 k=b[i];
47 |                                 b[i]=b[i+1];
48 |                                 b[i+1]=k;
49 |                         }
50 |                 }
51 |         }
52 |         for(int i=0; i<a; i++)
53 |                 cout<<b[i]<<" ";
54 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT */
55 |         return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/Arrays/TrickOrTreat.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |    Halloween is around and Ted Mosby ( who loves kids ) wants to give away candies. Ted has N bags of candies, each bag has Candies equal to A[i] stored in an array A[N]. There are M kids and each kid wants a specific amount of candy C[i] stored in an array C[M].
 3 | 
 4 |    For every kid i, you are to print "Happy Halloween!" if C[i] is present in the array A[N]. If C[i] is not present in the array, print "Tricky!".
 5 | 
 6 |    Hint1 : You can use binary search to find out whether an element is present in the array or not.
 7 | 
 8 |    INPUT
 9 | 
10 |    First line contains the number N(1 <= N <= 10^5), size of array A[N]. Second line contains N space separated integers, denoting the elements of the array A. (1 <= A[i] <= 10^9) Third line contains the number M(1 <= M <= 10^5), size of array C[M]. Fourth line contains M space separated integers, denoting the elements of the array C. (1 <= C[i] <= 10^9)
11 | 
12 |    OUTPUT
13 | 
14 |    Print M lines of output. ith line being "Happy Halloween!" if C[i] is present in A[N] and "Tricky!" otherwise.
15 | 
16 |    Sample Input 0
17 | 
18 |    5
19 |    2 4 6 8 10
20 |    5
21 |    5 4 3 2 1
22 |    Sample Output 0
23 | 
24 |    Tricky!
25 |    Happy Halloween!
26 |    Tricky!
27 |    Happy Halloween!
28 |    Tricky!
29 |  */
30 | 
31 | #include <cmath>
32 | #include <cstdio>
33 | #include <vector>
34 | #include <iostream>
35 | #include <algorithm>
36 | using namespace std;
37 | 
38 | 
39 | int main() {
40 |         int a;
41 |         cin>>a;
42 |         int b[a];
43 |         for(int i=0; i<a; i++)
44 |                 cin>>b[i];
45 |         int c;
46 |         cin>>c;
47 |         int d[c];
48 |         for(int i=0; i<c; i++)
49 |                 cin>>d[i];
50 |         for(int i=0; i<c; i++)
51 |         {
52 |                 if(binary_search(b,b+a,d[i]))
53 |                         cout<<"Happy Halloween!"<<endl;
54 |                 else
55 |                         cout<<"Tricky!"<<endl;
56 |         }
57 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT */
58 |         return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/Arrays/WaveArray.py:
--------------------------------------------------------------------------------
 1 | # Wave Array
 2 | # Given an array of integers, sort the array into a wave like array and return it,
 3 | # In other words, arrange the elements into a sequence such that a1 >= a2 <= a3 >= a4 <= a5.....
 4 | 
 5 | # Example
 6 | 
 7 | # Given [1, 2, 3, 4]
 8 | 
 9 | # One possible answer : [2, 1, 4, 3]
10 | # Another possible answer : [4, 1, 3, 2]
11 | #  NOTE : If there are multiple answers possible, return the one thats lexicographically smallest.
12 | # So, in example case, you will return [2, 1, 4, 3]
13 | 
14 | 
15 | class Solution:
16 |     def wave(self, A):
17 |         # Sort
18 |         A = sorted(A)
19 |         i = 0
20 |         size = len(A)
21 |         # Swapping neighbors
22 |         while(i < size - 1):
23 |             A[i], A[i + 1] = A[i + 1], A[i]
24 |             i += 2
25 |         return A
26 | 


--------------------------------------------------------------------------------
/Backtracking/NQueens.cpp:
--------------------------------------------------------------------------------
 1 | /*Problem Name: NQueens
 2 | 
 3 | Problem Description:
 4 | The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.
 5 | Given an integer n, return all distinct solutions to the n-queens puzzle.
 6 | Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.
 7 | There exist two distinct solutions to the 4-queens puzzle as shown above.
 8 | 
 9 | INPUT: 4
10 | 
11 | OUTPUT:
12 | [ #Solution1
13 | [".Q..",
14 | "...Q",
15 | "Q...",
16 | "..Q."],
17 | 
18 | CONSTRAINTS:
19 | 
20 | Sample input: 4
21 | 
22 | Sample output:
23 | ["..Q.",
24 | "Q...", #solution2
25 | "...Q",
26 | ".Q.."]
27 | ]*/
28 | 
29 | 
30 | 
31 | 
32 | 
33 | #include<iostream>
34 | using namespace std;
35 | #define N 4
36 | void printBoard(int board[N][N]) {
37 |    for (int i = 0; i < N; i++) {
38 |       for (int j = 0; j < N; j++)
39 |          cout << board[i][j] << " ";
40 |          cout << endl;
41 |    }
42 | }
43 | bool isValid(int board[N][N], int row, int col) {
44 |    for (int i = 0; i < col; i++) //check whether there is queen in the left or not
45 |       if (board[row][i])
46 |          return false;
47 |    for (int i=row, j=col; i>=0 && j>=0; i--, j--)
48 |       if (board[i][j]) //check whether there is queen in the left upper diagonal or not
49 |          return false;
50 |    for (int i=row, j=col; j>=0 && i<N; i++, j--)
51 |       if (board[i][j]) //check whether there is queen in the left lower diagonal or not
52 |          return false;
53 |    return true;
54 | }
55 | bool solveNQueen(int board[N][N], int col) {
56 |    if (col >= N) //when N queens are placed successfully
57 |       return true;
58 |    for (int i = 0; i < N; i++) { //for each row, check placing of queen is possible or not
59 |       if (isValid(board, i, col) ) {
60 |          board[i][col] = 1; //if validate, place the queen at place (i, col)
61 |          if ( solveNQueen(board, col + 1)) //Go for the other columns recursively
62 |             return true;
63 |          board[i][col] = 0; //When no place is vacant remove that queen
64 |       }
65 |    }
66 |    return false; //when no possible order is found
67 | }
68 | bool checkSolution() {
69 |    int board[N][N];
70 |    for(int i = 0; i<N; i++)
71 |    for(int j = 0; j<N; j++)
72 |    board[i][j] = 0; //set all elements to 0
73 |    if ( solveNQueen(board, 0) == false ) { //starting from 0th column
74 |       cout << "Solution does not exist";
75 |       return false;
76 |    }
77 |    printBoard(board);
78 |    return true;
79 | }
80 | int main() {
81 |    checkSolution();
82 | }
83 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contributing Guidelines:
 2 | 
 3 | 1. Anyone can contribute
 4 | 2. If your problem doesn't fit into one of the existing folders, create a new one. Try not to just dump into the Miscellaneous folder.
 5 | 3. File format:
 6 |   
 7 |   In comments at the top of the file:
 8 |     
 9 |     Problem Name
10 |     
11 |     Problem Description
12 |     
13 |     INPUT:
14 |     
15 |     OUTPUT:
16 |     
17 |     CONSTRAINTS:
18 |     
19 |     Sample input:
20 |     
21 |     Sample output:
22 |      
23 | 4. Try to explain your code using comments. No point having a good solution if no one can make sense of it.
24 | 5. Please don't use spaces in the program name. This may cause some unexpected issues if used via the CLI. Instead, use either CamelCase or use underscore example Zero_One_Knapsack.py.


--------------------------------------------------------------------------------
/Dynamic Programming/Kadane_LargestSumContArray.cpp:
--------------------------------------------------------------------------------
 1 | // Largest Sum Contiguous Subarray
 2 | 
 3 | // Write an efficient program to find the sum of contiguous subarray within a one-dimensional array of numbers which has the largest sum. A contiguous subarray is a subset of the array that includes the elements in a sequenced manner, without skipping any element in between.
 4 | // Example of contiguous subarrays for the array [1,2,3,4,5]
 5 | // [2,3,4]
 6 | // [4,5]
 7 | // [1,2,3,4,5]
 8 | // [1,2,3]
 9 | 
10 | // Sample Input:
11 | // 6
12 | // 1 -2 1 1 -2 1
13 | 
14 | // Output:
15 | // 2
16 | 
17 | // Explanation: 
18 | // The max contiguous sum in the above array will be 2, starting from index 2 and ending at index 3. All other contiguous array sums will be less than 2.
19 | 
20 | #include <iostream>
21 | using namespace std;
22 | 
23 | int kadaneAlgo(int arr[], int n)
24 | {
25 |     int globalMax,maxEndingHere,i;
26 |     globalMax = arr[0];
27 |     maxEndingHere = arr[0];
28 |     for(i=1;i<n;i++)
29 |     {
30 |         maxEndingHere = max(maxEndingHere + arr[i], arr[i]);
31 |         if(maxEndingHere > globalMax)
32 |             globalMax = maxEndingHere;
33 |     }
34 |     return globalMax;
35 | }
36 | 
37 | int main() 
38 | {
39 |     int arr[] = {1, 3, -4, 2, 1, -1, 3, -5};
40 |     int n = sizeof(arr)/sizeof(arr[0]);
41 |     int result = kadaneAlgo(arr, n);
42 |     
43 |     cout<<"Max subarray sum = "<<result<<endl;
44 | }
45 | 


--------------------------------------------------------------------------------
/Dynamic Programming/LCS.cpp:
--------------------------------------------------------------------------------
 1 | // Longest Common Substring | DP-29
 2 | // Given two strings ‘X’ and ‘Y’, find the length of the longest common substring.
 3 | // Examples :
 4 | 
 5 | // Input : X = “GeeksforGeeks”, y = “GeeksQuiz”
 6 | // Output : 5
 7 | // The longest common substring is “Geeks” and is of length 5.
 8 | 
 9 | // Input : X = “abcdxyz”, y = “xyzabcd”
10 | // Output : 4
11 | // The longest common substring is “abcd” and is of length 4.
12 | 
13 | // Input : X = “zxabcdezy”, y = “yzabcdezx”
14 | // Output : 6
15 | // The longest common substring is “abcdez” and is of length 6.
16 | 
17 | 
18 | 
19 | #include <iostream>
20 | using namespace std;
21 | 
22 | int LCS(string s1, string s2)
23 | {
24 |     int i,j,max=-1;
25 |     int l1 = s1.length();
26 |     int l2 = s2.length();
27 |     int res[l1+1][l2+1];
28 |     for(i=0;i<=l1;i++)
29 |     {
30 |         for(j=0;j<=l2;j++)
31 |         {
32 |             if(i==0 || j==0)
33 |             {
34 |                 res[i][j]=0;
35 |             }
36 |             else if(s1[i-1] == s2[j-1])
37 |             {
38 |                 res[i][j] = res[i-1][j-1] + 1;
39 |                 if(res[i][j]>max)
40 |                     max = res[i][j];
41 |             }
42 |             else 
43 |                 res[i][j] = 0;
44 |         }
45 |     }
46 |     return max;
47 | }
48 | 
49 | int main()
50 | {
51 |     string s1 = "welcome to ti9";
52 |     string s2 = "cheers to ti9 tourney";
53 |     cout<<LCS(s1,s2);
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/Dynamic Programming/LargestContiguousSumSubarray.py:
--------------------------------------------------------------------------------
 1 | # Largest Sum Contiguous Subarray
 2 | 
 3 | # Write an efficient program to find the sum of contiguous subarray within a one-dimensional array of numbers which has the largest sum.
 4 | 
 5 | 
 6 | 
 7 | # Sample input:
 8 | 
 9 | # -2 -3 4 -1 -2 1 5 -3
10 | 
11 | 
12 | #Sample output:
13 | 
14 | # 7
15 | 
16 | 
17 | # Explanation:
18 | 
19 | #  4,-1,-2,1,5 has the largest sum
20 | 
21 | 
22 | 
23 | 
24 | # CODE:
25 | 
26 | import sys
27 | 
28 | 
29 | 
30 | arr = list(map(int, input().split()))
31 | 
32 | 
33 | max_so_far = -sys.maxsize-1
34 | 
35 | 
36 | max_ending_here = 0
37 | 
38 | 
39 | size = len(arr)
40 | 
41 | 
42 | 
43 | for i in range(size):
44 | 
45 |     max_ending_here = max_ending_here+arr[i]
46 | 
47 |     
48 | if(max_so_far<max_ending_here):
49 | 
50 |         max_so_far = max_ending_here
51 | 
52 |     if(max_ending_here<0):
53 | 
54 |         max_ending_here=0
55 | 
56 | 
57 | 
58 | 
59 | print(max_so_far)


--------------------------------------------------------------------------------
/Dynamic Programming/MaxArraySum_NonAdjacent.py:
--------------------------------------------------------------------------------
 1 | # QUESTION:
 2 | # https://www.hackerrank.com/challenges/max-array-sum/problem
 3 | # Given an array of integers, find the subset of non-adjacent elements with the maximum sum.
 4 | # Calculate the sum of that subset.
 5 | 
 6 | import os
 7 | # Complete the maxSubsetSum function below.
 8 | 
 9 | 
10 | def maxSubsetSum(arr):
11 |     incl = arr[0]
12 |     excl = 0
13 |     for i in arr[1:]:
14 |         new_excl = max(excl, incl)
15 |         incl = excl + i
16 |         excl = new_excl
17 |     return max(incl, excl)
18 | 
19 | 
20 | if __name__ == '__main__':
21 |     fptr = open(os.environ['OUTPUT_PATH'], 'w')
22 | 
23 |     n = int(input())
24 | 
25 |     arr = list(map(int, input().rstrip().split()))
26 | 
27 |     res = maxSubsetSum(arr)
28 | 
29 |     fptr.write(str(res) + '\n')
30 | 
31 |     fptr.close()
32 | 


--------------------------------------------------------------------------------
/Dynamic Programming/MaxSizeSquareSubMatrix.cpp:
--------------------------------------------------------------------------------
 1 | // Maximum size square sub-matrix with all 1s
 2 | 
 3 | // Given a binary matrix, find out the maximum size square sub-matrix with all 1s.
 4 | 
 5 | // Sample Input:
 6 | 
 7 | // 4 5
 8 | // 0 0 1 1 1
 9 | // 1 0 1 1 1
10 | // 0 1 1 1 1
11 | // 1 0 1 1 1 
12 | 
13 | // Sample Output:
14 | 
15 | // 3
16 | 
17 | 
18 | // Code:
19 | 
20 | #include <iostream>
21 | using namespace std;
22 | 
23 | int main()
24 | {
25 |     int m,n,i,j,max_len=-1;
26 |     cin>>m>>n;
27 |     int arr[m][n];
28 |     for(i=0;i<m;i++)
29 |         for(j=0;j<n;j++)
30 |             cin>>arr[i][j];
31 |     
32 |     // Forming the substructure
33 |     int sub[m+1][n+1];
34 |     for(i=0;i<m+1;i++)
35 |     {
36 |         for(j=0;j<n+1;j++)
37 |         {
38 |             if(i==0 || j==0)
39 |                 sub[i][j] = 0;
40 |             else
41 |                 sub[i][j] = arr[i-1][j-1];
42 |         }
43 |     }
44 |     
45 |     for(i=1;i<m+1;i++)
46 |     {
47 |         for(j=1;j<n+1;j++)
48 |         {
49 |             if(sub[i][j]==1)
50 |                 sub[i][j] = 1 + min(sub[i-1][j], min(sub[i][j-1], sub[i-1][j-1]));
51 |             else
52 |                 sub[i][j]=0;
53 |             max_len = max(sub[i][j], max_len);
54 |         }
55 |     }
56 |     
57 |     // Printing the substructure
58 |     for(i=0;i<m+1;i++)
59 |     {
60 |         for(j=0;j<n+1;j++)
61 |             cout<<sub[i][j]<<" ";
62 |         cout<<endl;
63 |     }
64 |     
65 |     cout<<max_len;
66 | 
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/Dynamic Programming/MinAvgSubarray.cpp:
--------------------------------------------------------------------------------
 1 | // Find the subarray with least average
 2 | 
 3 | // Given an array arr[] of size n and integer k such that k <= n.
 4 | 
 5 | #include <iostream>
 6 | #include <climits>
 7 | using namespace std;
 8 | 
 9 | int minAverage(int arr[], int n, int k)
10 | {
11 |     int i, j, min=INT_MAX;
12 |     for(i=0;i<n-k;i++)
13 |     {
14 |         int sum = 0;
15 |         for(j=0;j<k;j++)
16 |             sum+=arr[i+j];
17 |         cout<<i<<"th iter, sum = "<<sum<<endl;
18 |         if(sum<min)
19 |             min = sum;
20 |     }
21 |     return min/k;
22 | }
23 | 
24 | int main() 
25 | {
26 |     int arr[] = {3, 7, 90, 20, 10, 50, 40};
27 |     int n = sizeof(arr)/sizeof(arr[0]);
28 |     int k = 3;
29 |     int result = minAverage(arr, n, k);
30 |     
31 |     cout<<"Min subarray average = "<<result<<endl;
32 | }


--------------------------------------------------------------------------------
/Dynamic Programming/NonDecreaseSubarray.py:
--------------------------------------------------------------------------------
 1 | # Count Non-Decreasing Subarrays 
 2 | 
 3 | # Given an array A1,A2,...,AN, count the number of subarrays of array A which are non-decreasing.
 4 | # A subarray A[i,j], where 1≤i≤j≤N is a sequence of integers Ai,Ai+1,...,Aj.
 5 | 
 6 | # A subarray A[i,j] is non-decreasing if Ai≤Ai+1≤Ai+2≤...≤Aj. You have to count the total number of such subarrays.
 7 | 
 8 | # Input
 9 | # The first line of input contains an integer T denoting the number of test cases. The description of T test cases follows.
10 | # The first line of each test case contains a single integer N denoting the size of array.
11 | # The second line contains N space-separated integers A1, A2, …, AN denoting the elements of the array.
12 | 
13 | # Output
14 | # For each test case, output in a single line the required answer.
15 | 
16 | # Sample Input:
17 | # 2
18 | # 4
19 | # 1 4 2 3
20 | # 1
21 | # 5
22 | # Sample Output:
23 | # 6
24 | # 1
25 | 
26 | # Explanation
27 | # Example case 1.
28 | # All valid subarrays are A[1,1],A[1,2],A[2,2],A[3,3],A[3,4],A[4,4].
29 | # Note that singleton subarrays are identically non-decreasing.
30 | 
31 | # Example case 2.
32 | # Only single subarray A[1,1] is non-decreasing.
33 | 
34 | # cook your dish here
35 | t = int(input())
36 | for k in range(t):
37 |     n = int(input())
38 |     arr = list(map(int,input().split()))
39 |     psum,tsum = 1,0
40 |     for i in range(1,n):
41 |         if arr[i-1]<=arr[i]:
42 |             tsum += 1
43 |         else:
44 |             tsum = 0
45 |         psum += 1+tsum
46 |     print(psum)


--------------------------------------------------------------------------------
/Dynamic Programming/ZeroOneKnapsack.cpp:
--------------------------------------------------------------------------------
 1 | // 0/1 Knapsack
 2 | 
 3 | // Given weights and values of n items, put these items in a knapsack of capacity W to get the maximum total value in the 
 4 | // knapsack. In other words, given two integer arrays val[0..n-1] and wt[0..n-1] which represent values and weights 
 5 | // associated with n items respectively. Also given an integer W which represents knapsack capacity, find out the maximum 
 6 | // value subset of val[] such that sum of the weights of this subset is smaller than or equal to W. You cannot break an 
 7 | // item, either pick the complete item, or don’t pick it (0-1 property).
 8 | 
 9 | #include <iostream>
10 | using namespace std;
11 | 
12 | int max(int a, int b)
13 | {
14 |     return a>b?a:b;
15 | }
16 | 
17 | int ZeroOneKnapsack(int W, int val[], int wt[], int n)
18 | {
19 |     if(n==0 || W==0)
20 |         return 0;
21 |     int i,j;
22 |     int k[n+1][W+1];
23 |     for(i=0;i<=n;i++)
24 |     {
25 |         for(j=0;j<=W;j++)
26 |         {
27 |             if(i==0 || j==0)
28 |                 k[i][j]=0;
29 |             else if (j>=wt[i-1])
30 |                 k[i][j] = max(val[i]+k[i-1][j-wt[i]], k[i-1][j]);
31 |             else
32 |                 k[i][j] = k[i-1][j];
33 |         }
34 |     }
35 |     return k[n][W];   
36 | }
37 | 
38 | int main()
39 | {
40 |     int val[] = {60, 100, 120}; 
41 |     int wt[] = {10, 20, 30}; 
42 |     int  W = 50; 
43 |     int n = sizeof(val)/sizeof(val[0]); 
44 |     cout << ZeroOneKnapsack(W, val, wt, n); 
45 |     return 0;
46 | }


--------------------------------------------------------------------------------
/Greedy Algorithms/ActivitySelectionProblem.cpp:
--------------------------------------------------------------------------------
 1 | // Activity Selection Problem
 2 | 
 3 | // You are given n activities with their start and finish times. Select the maximum number of activities that can be performed by a single person, assuming that a person can only work on a single activity at a time.
 4 | 
 5 | // Example 1 : Consider the following 3 activities sorted by
 6 | // by finish time.
 7 | //      start[]  =  {10, 12, 20};
 8 | //      finish[] =  {20, 25, 30};
 9 | // A person can perform at most two activities. The 
10 | // maximum set of activities that can be executed 
11 | // is {0, 2} [ These are indexes in start[] and 
12 | // finish[] ]
13 | 
14 | // Example 2 : Consider the following 6 activities 
15 | // sorted by by finish time.
16 | //      start[]  =  {1, 3, 0, 5, 8, 5};
17 | //      finish[] =  {2, 4, 6, 7, 9, 9};
18 | // A person can perform at most four activities. The 
19 | // maximum set of activities that can be executed 
20 | // is {0, 1, 3, 4} [ These are indexes in start[] and 
21 | // finish[] ]
22 | 
23 | #include <iostream>
24 | #include <algorithm>
25 | using namespace std;
26 | 
27 | struct Activity
28 | {
29 |     int start;
30 |     int end;
31 | };
32 | 
33 | bool actComp(Activity a, Activity b)
34 | {
35 |     return (a.end < b.end);
36 | }
37 | 
38 | void printMaxActivities(Activity act[], int n)
39 | {
40 |     sort(act, act+n, actComp);
41 |     int i=0,j=0,k=1;
42 |     cout<<"Activity "<<k++<<" Start:"<<act[0].start<<" Stop:"<<act[0].end<<endl;
43 |     for(i=1;i<n;i++)
44 |     {
45 |         if(act[i].start > act[j].end)
46 |         {
47 |             cout<<"Activity "<<k++<<" Start:"<<act[i].start<<" Stop:"<<act[i].end<<endl;
48 |             j=i;
49 |         }
50 |     }
51 |     cout<<"Total "<<k-1<<" activities";
52 | }
53 | 
54 | int main()
55 | {
56 |     
57 |     cout<<"Hello World"<<endl;
58 |     Activity act[] = {{5, 9}, {1, 2}, {3, 4}, {0, 6}, {5, 7}, {8, 9}}; 
59 |     int n = 6;
60 |     printMaxActivities(act, n);
61 | 
62 |     return 0;
63 | }
64 | 


--------------------------------------------------------------------------------
/Greedy Algorithms/AutonomousCar.cpp:
--------------------------------------------------------------------------------
 1 | // Autonomous Car
 2 | 
 3 | // A futuristic company is building an autonomous car. The scientists at the company are training the car to perform Reverse parking. To park, the car needs to be able to move in backward as well as forward direction. The car is programmed to move backwards B meters and forwards again, say F meters, in a straight line. The car does this repeatedly until it is able to park or collides with other objects. The car covers 1 meter in T units of time. There is a wall after distance D from car's initial position in the backward direction.
 4 | 
 5 | // The car is currently not without defects and hence often hits the wall. The scientists are devising a strategy to prevent this from happening. Your task is to help the scientists by providing them with exact information on amount of time available before the car hits the wall.
 6 | 
 7 | // Input Format:
 8 | 
 9 | // First line contains total number of test cases, denoted by N Next N lines, contain a tuple containing 4 values delimited by space F B T D, where 1. F denotes forward displacement in meters 2. B denotes backward displacement in meters 3. T denotes time taken to cover 1 meter 4. D denotes distance from Car's starting position and the wall in backward direction
10 | 
11 | // Output Format:
12 | 
13 | // For each test case print time taken by the Car to hit the wall
14 | 
15 | // Constraints:
16 | // First move will always be in backward direction
17 | // 1 <= N <= 100
18 | // backward displacement > forward displacement i.e. (B > F)
19 | // forward displacement (F) > 0
20 | // backward displacement (B) > 0
21 | // time (T) > 0 
22 | // distance (D) > 0
23 | // All input values must be positive integers only
24 | 
25 | // Sample Input 0
26 | 
27 | // 2
28 | // 6 9 3 18
29 | // 3 7 5 20
30 | // Sample Output 0
31 | 
32 | // 162
33 | // 220
34 | 
35 | #include <iostream>
36 | using namespace std;
37 | 
38 | int main()
39 | {
40 |     int n;
41 |     cin>>n;
42 |     while(n--)
43 |     {
44 |         
45 |         int f,b,t,d;
46 |         cin>>f>>b>>t>>d;
47 |         long long ans=0;
48 |         int count=0,dist=0;
49 |         while(true)
50 |         {
51 |             if(dist+b<d)
52 |             dist+=b;
53 |             
54 |             else
55 |             {
56 |                 ans+=(d-dist)*t;
57 |                 break;
58 |             }
59 |                 
60 |             dist-=f;
61 |             
62 |             count++;
63 |             
64 |         }
65 |         ans+=(count*t)*(f+b);
66 |         
67 |         cout<<ans<<endl;
68 |         
69 |     }
70 |     
71 |     return 0;
72 | }
73 | 


--------------------------------------------------------------------------------
/Greedy Algorithms/EatLessCupcakes.c:
--------------------------------------------------------------------------------
 1 | // Marc loves cupcakes, but he also likes to stay fit. He eats n cupcakes in one sitting, and each cupcake i has a calorie count c[i] . After eating a cupcake with c calories, he must walk at least 2^j * c (where j is the number cupcakes he has already eaten) miles to maintain his weight.
 2 | // Given the individual calorie counts for each of the cupcakes, find and print a long integer denoting the minimum number of miles Marc must walk to maintain his weight. Note that he can eat the cupcakes in any order.
 3 | 
 4 | // Notes: Has to be done greedily so that you have to burn as less calories as possible
 5 | 
 6 | // Input Format
 7 | // The first line contains an integer, N , denoting the number of cupcakes. The second line contains N space-separated integers describing the respective calorie counts of each cupcake,c[1]...c[n].
 8 | // Constraints
 9 | 
10 | // 1<=n<=40 1<=ci<=1000
11 | 
12 | // Output Format
13 | // Print a long integer denoting the minimum number of miles Marc must walk to maintain his weight.
14 | 
15 | // Sample Input 0
16 | // 3
17 | // 1 3 2
18 | 
19 | // Sample Output 0
20 | // 11
21 | 
22 | #include <stdio.h>
23 | #include <string.h>
24 | #include <math.h>
25 | #include <stdlib.h>
26 | 
27 | int main() {
28 |     int n;
29 |     scanf("%d", &n);
30 |     int a[n];
31 |     for(int i=0; i<n; i++)
32 |     {
33 |         scanf("%d", &a[i]);
34 |     }
35 |     int j;
36 |     //sort, descending
37 |     for (int i = 0; i < n; i++) 
38 |     {
39 |         for (j = i+1; j < n; j++)
40 |         {
41 |             if (a[i] < a[j]) 
42 |             {
43 |                 int x =  a[i];
44 |                 a[i] = a[j];
45 |                 a[j] = x;
46 |             }
47 |         }
48 |     }
49 |     unsigned long long int sum=0;
50 |     for(int i=0; i<n; i++)
51 |     {
52 |         sum+=pow(2, i)*a[i];
53 |     }
54 |     printf("%d", sum);
55 |     
56 |     return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/Greedy Algorithms/GreedyFlorist.py:
--------------------------------------------------------------------------------
 1 | # Very long question, please view here
 2 | # https://www.hackerrank.com/challenges/greedy-florist/problem
 3 | import os
 4 | 
 5 | # Complete the getMinimumCost function below.
 6 | 
 7 | 
 8 | def getMinimumCost(k, c):
 9 |     # Reverse sort
10 |     c = sorted(c, reverse=True)
11 |     cost = 0
12 |     # Adding first k costs directly (1 flower per person)
13 |     cost += sum(c[:k])
14 |     # Changing array to store only next elements
15 |     c = c[k:]
16 |     # Cost multiplication starts at 2
17 |     mult = 2
18 |     # Counting how many flowers bought
19 |     count = 0
20 |     for price in c:
21 |         # Adding that price
22 |         cost += price * mult
23 |         # Increasing count of flowers bought
24 |         count += 1
25 |         # When all group members have bought one each, then cost will get incremented again
26 |         if(count % k == 0):
27 |             mult += 1
28 | 
29 |     return cost
30 | 
31 | 
32 | # generic hackerrank input
33 | if __name__ == '__main__':
34 |     fptr = open(os.environ['OUTPUT_PATH'], 'w')
35 | 
36 |     nk = input().split()
37 | 
38 |     n = int(nk[0])
39 | 
40 |     k = int(nk[1])
41 | 
42 |     c = list(map(int, input().rstrip().split()))
43 | 
44 |     minimumCost = getMinimumCost(k, c)
45 | 
46 |     fptr.write(str(minimumCost) + '\n')
47 | 
48 |     fptr.close()
49 | 


--------------------------------------------------------------------------------
/Greedy Algorithms/JumpGame.cpp:
--------------------------------------------------------------------------------
 1 | /* Given an array of non-negative integers, you are initially positioned at the first index of the array.
 2 | 
 3 | Each element in the array represents your maximum jump length at that position.
 4 | 
 5 | Determine if you are able to reach the last index.
 6 | 
 7 |  
 8 | 
 9 | Example 1:
10 | 
11 | Input: nums = [2,3,1,1,4]
12 | Output: true
13 | Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.
14 | Example 2:
15 | 
16 | Input: nums = [3,2,1,0,4]
17 | Output: false
18 | Explanation: You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.
19 |  
20 | 
21 | Constraints:
22 | 
23 | 1 <= nums.length <= 3 * 10^4
24 | 0 <= nums[i][j] <= 10^5
25 | 
26 | 
27 | 
28 | 
29 | */
30 | 
31 | 
32 | #include <vector>
33 | #include <iostream>
34 | #include <cassert>
35 |  
36 | bool canJump(const std::vector<int> &nums) {
37 |     auto lastPos = nums.size() - 1;
38 |     for (auto i = nums.size() - 1; i >= 0; i--) {
39 |         if (i + nums[i] >= lastPos) {
40 |             lastPos = i;
41 |         }
42 |     }
43 |     return lastPos == 0;
44 | }
45 | 
46 | 
47 | static void test(){
48 |   // Test 1
49 |   std::vector<int> num1={4,3,1,0,5};
50 |   assert(canJump(num1)==true);
51 |   std::cout<<"Input: ";
52 |   for(auto i: num1){
53 |     std::cout<<i<<" ";
54 |   }
55 |   std::cout<<"Output: true"<<std::endl;
56 |   // Test 2
57 |   std::vector<int> num2={3,2,1,0,4};
58 |   assert(canJump(num2)==false);
59 |   std::cout<<"Input: ";
60 |   for(auto i: num2){
61 |     std::cout<<i<<" ";
62 |   }
63 |   std::cout<<"Output: false"<<std::endl;
64 | }
65 | 
66 | 
67 | /**
68 |  * @brief Main function
69 |  * @returns 0 on exit
70 |  */
71 | int main(){
72 |     test();
73 |     return 0;
74 | }


--------------------------------------------------------------------------------
/Greedy Algorithms/KnapsackUsingDictionaries.py:
--------------------------------------------------------------------------------
 1 | # You are given an empty bag that is supposed to be filled with gold, and it can carry at max W kgs of gold in it.
 2 | 
 3 | # You are given N samples of gold, with the ith of them weighing Wi and having value Vi.
 4 | 
 5 | # Your task is to fill the bag with exactly W kgs of gold such that the total value of the gold inside the bag is maximum.
 6 | 
 7 | # You need not take the entire samples of gold, you can break them down and take fractions of those samples as well. For example, if you have two samples, one with weight 10 and value 10 and another with weight 5 and value 10, you can fill a 5 kg capacity bag with 2.5 kg of first sample and 2.5 kg of second sample. The value for such a bag will be the sum of values of all the pieces, i.e. for the first sample 2.5 kg has value 2.5 and for the second sample 2.5 kg has value 5, hence the total value of the bag becomes 7.5
 8 | 
 9 | # INPUT
10 | # First line contains two integers, N and W.
11 | # Second onwards, there are N lines with each of them containing two integers, first one being the weight of the sample and the second one being the value of the sample
12 | 
13 | # OUTPUT
14 | # Print one number, the maximum attainable value when the bag is filled with W kgs of gold. If it is not possible to fill the bag with W kgs of gold, print -1.
15 | 
16 | # CONSTRAINTS
17 | # 1 ≤ N ≤ 105
18 | # 1 ≤ W ≤ 109
19 | # 1 ≤ weights, values ≤ 109
20 | 
21 | # Sample Input 0
22 | # 3 10
23 | # 5 5
24 | # 3 10
25 | # 4 4
26 | 
27 | # Sample Output 0
28 | # 17.000000000000
29 | 
30 | n, w = map(int, input().split())
31 | # array to store ratios
32 | vals = []
33 | 
34 | # to check if total weight of all samples is less than knapsack max weight (print -1 case)
35 | maxw = 0
36 | for i in range(n):
37 |     d = {}
38 |     d['weight'], d['value'] = map(int, input().split())
39 |     maxw += d['weight']
40 |     d['ratio'] = d['value'] / d['weight']
41 |     vals.append(d)
42 | 
43 | # sorting the dictionary based on ratios
44 | vals_s = sorted(vals, key=lambda x: x['ratio'], reverse=True)
45 | 
46 | flag = 0
47 | 
48 | # -1 case:
49 | if(maxw < w):
50 |     print(-1)
51 | else:
52 |     # remaining weight
53 |     remw = w
54 |     i = 0
55 |     # total value
56 |     totval = 0
57 |     while(remw >= 0):
58 |         # if full sample can't be taken
59 |         if(remw - vals_s[i]['weight'] < 0):
60 |             totval += vals_s[i]['value'] * (remw / vals_s[i]['weight'])
61 |         else:
62 |             totval += vals_s[i]['value']
63 |         # reducing remaining weight
64 |         remw -= vals_s[i]['weight']
65 |         # moving to next dictionary
66 |         i += 1
67 | 
68 |     print(float(totval))
69 | 


--------------------------------------------------------------------------------
/Greedy Algorithms/KnapsackUsingStruct.cpp:
--------------------------------------------------------------------------------
 1 | /*You are given an empty bag that is supposed to be filled with gold, and it can carry at max W kgs of gold in it.
 2 | 
 3 | You are given N samples of gold, with the ith of them weighing Wi and having value Vi.
 4 | 
 5 | Your task is to fill the bag with exactly W kgs of gold such that the total value of the gold inside the bag is maximum.
 6 | 
 7 | You need not take the entire samples of gold, you can break them down and take fractions of those samples as well. 
 8 | For example, if you have two samples, one with weight 10 and value 10 and another with weight 5 and value 10, 
 9 | you can fill a 5 kg capacity bag with 2.5 kg of first sample and 2.5 kg of second sample. 
10 | The value for such a bag will be the sum of values of all the pieces, i.e. for the first sample 2.5 kg has value 2.5 
11 | and for the second sample 2.5 kg has value 5, hence the total value of the bag becomes 7.5
12 | 
13 | INPUT
14 | First line contains two integers, N and W. 
15 | Second onwards, there are N lines with each of them containing two integers, 
16 | first one being the weight of the sample and the second one being the value of the sample
17 | 
18 | OUTPUT
19 | Print one number, the maximum attainable value when the bag is filled with W kgs of gold. 
20 | If it is not possible to fill the bag with W kgs of gold, print -1.
21 | 
22 | CONSTRAINTS
23 | 1 ≤ N ≤ 105 
24 | 1 ≤ W ≤ 109 
25 | 1 ≤ weights, values ≤ 109 
26 | 
27 | Sample Input 0
28 | 
29 | 3 10
30 | 5 5
31 | 3 10
32 | 4 4
33 | Sample Output 0
34 | 
35 | 17.000000000000
36 | Explanation 0
37 | 
38 | We can take 3 kgs of sample 2, 4 kgs of sample 1 and 3 kgs of sample 3 to attain the maximum value*/
39 | 
40 | 
41 | 
42 | 
43 | 
44 | #include <cmath>
45 | #include <cstdio>
46 | #include <vector>
47 | #include <iostream>
48 | #include <algorithm>
49 | #include <iomanip>
50 | using namespace std;
51 | 
52 | struct bag
53 | {
54 |     long wgt,val;
55 |     double frac;
56 | };
57 | bool compare(bag a,bag b)
58 | {
59 |     return a.frac>b.frac;
60 | }
61 | 
62 | int main() {
63 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
64 |     long n,w,i;
65 |     cin>>n>>w;
66 |     bag a[n];
67 |     for(i=0;i<n;i++)
68 |     {
69 |         cin>>a[i].wgt>>a[i].val;
70 |         a[i].frac=(double)a[i].val/a[i].wgt;
71 |     }
72 |     sort(a,a+n,compare);
73 |     double tot=0;
74 |     for(i=0;i<n;i++)
75 |     {
76 |         if(a[i].wgt<=w)
77 |         {
78 |             tot+=a[i].val;
79 |             w-=a[i].wgt;
80 |         }
81 |         else if(a[i].wgt>w)
82 |         {
83 |             tot += (double)w * a[i].frac;
84 |             w=0;
85 |         }
86 |     }
87 |     if(w!=0)
88 |         cout<<"-1";
89 |     else 
90 |         cout<<fixed<<setprecision(20)<<tot;
91 |     return 0;
92 |     
93 |     
94 | }
95 | 


--------------------------------------------------------------------------------
/Greedy Algorithms/LargestNumberGivenDigitsAndSum.py:
--------------------------------------------------------------------------------
 1 | # Largest number possible
 2 | # Given two numbers 'N' and 'S' , find the largest number that can be formed with 'N' digits and whose sum of digits should be equals to 'S'.
 3 | 
 4 | 
 5 | # Input
 6 | 
 7 | # The first line of input contains an integer T denoting the number of test cases. Then T test cases follow. The first line of each test case contains two space separated integers N and S, where N is the number of digits and S is the sum.
 8 | 
 9 | 
10 | # Output
11 | 
12 | # Print the largest number that is possible.
13 | # If there is no such number, then print -1
14 | 
15 | 
16 | # Constraints:
17 | 
18 | # 1 <= T <= 30
19 | # 1 <= N <= 50
20 | # 0 <= S <= 500
21 | 
22 | 
23 | # Example
24 | 
25 | # Input
26 | # 2
27 | # 2 9
28 | # 3 20
29 | 
30 | # Output
31 | 
32 | # 90
33 | # 992
34 | 
35 | # Expected Time Complexity: O(n)
36 | 
37 | 
38 | n = int(input())
39 | for i in range(n):
40 | 	# Input
41 |     l, s = map(int, input().split())
42 | 
43 |     # Base cases where not possible
44 |     if(s > l * 9 or s == 0):
45 |         print('-1')
46 |     else:
47 |     	# Making empty array for the number
48 |         num = [0] * l
49 |         for j in range(l):
50 |         	# Maximising
51 |             if(s >= 9):
52 |                 num[j] = 9
53 |                 s -= 9
54 |             else:
55 |                 num[j] = s
56 |                 s = 0
57 |         # Printing
58 |         for j in num:
59 |             print(j, end='')
60 |         print()
61 | 


--------------------------------------------------------------------------------
/Greedy Algorithms/SmallestNumberGivenDigitsAndSum.py:
--------------------------------------------------------------------------------
 1 | # Smallest number
 2 | # The task is to find the smallest number with given sum of digits as s and number of digits as d.
 3 | 
 4 | # Expected Time Complexity: O(d)
 5 | 
 6 | # Input:
 7 | # The first line of input contains a single integer T denoting the number of test cases. Then T test cases follow. Each test case consist of a single line containing two space separated integers s and d, where s is digit sum and d is number of digits.
 8 | 
 9 | # Output:
10 | # Corresponding to each test case, in a new line, print the smallest number if possible, else print -1.
11 | 
12 | # Constraints:
13 | # 1 ≤ T ≤ 100
14 | # 1 ≤ s ≤ 100
15 | # 1 ≤ d ≤ 6
16 | 
17 | # Example:
18 | # Input
19 | # 3
20 | # 9 2
21 | # 20 3
22 | # 63 3
23 | 
24 | # Output
25 | # 18
26 | # 299
27 | # -1
28 | 
29 | n = int(input())
30 | for i in range(n):
31 |         # Sum, number of digits
32 |     a, b = map(int, input().split())
33 |     # first check, example: 3 digit number can't have sum more than 27 (999)
34 |     if(a > b * 9):
35 |         print('-1')
36 |     else:
37 |         # Making empty result array
38 |         res = [0] * b
39 |         # First digit (most sig) must be atleast 1, so reserving that
40 |         a -= 1
41 |         # Starting from behind, putting bigger numbers in the end
42 |         for j in range(b - 1, 0, -1):
43 |                 # Get rid of 9 to reduce overall number
44 |             if(a >= 9):
45 |                 res[j] = 9
46 |                 a -= 9
47 |             else:
48 |                 res[j] = a
49 |                 a = 0
50 |         # Reusing the reserved 1
51 |         res[0] = a + 1
52 | 
53 |         # Printing result
54 |         for e in res:
55 |             print(e, end='')
56 |         print()
57 | 


--------------------------------------------------------------------------------
/Hash table/Group_anagrams.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given an array of strings strs, group the anagrams together. You can return the answer in any order.
 3 | 
 4 | An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
 5 | 
 6 |  
 7 | 
 8 | Example 1:
 9 | 
10 | Input: strs = ["eat","tea","tan","ate","nat","bat"]
11 | Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
12 | Example 2:
13 | 
14 | Input: strs = [""]
15 | Output: [[""]]
16 | Example 3:
17 | 
18 | Input: strs = ["a"]
19 | Output: [["a"]]
20 |  
21 | 
22 | Constraints:
23 | 
24 | 1 <= strs.length <= 104
25 | 0 <= strs[i].length <= 100
26 | strs[i] consists of lower-case English letters.
27 | */
28 | 
29 | 
30 | 
31 | 
32 | 
33 | class Solution {
34 | public:
35 |     vector<vector<string>> groupAnagrams(vector<string>& strs) 
36 |     {
37 |         unordered_map<string,vector<string>>Map;
38 |         
39 |         for (int i=0; i<strs.size(); i++)
40 |         {
41 |             string t = strs[i];
42 |             sort(t.begin(),t.end());
43 |             Map[t].push_back(strs[i]);
44 |         }
45 |         
46 |         vector<vector<string>>results;
47 |         for (auto a:Map)
48 |             results.push_back(a.second);
49 |         
50 |         return results;
51 |         
52 |     }
53 | };


--------------------------------------------------------------------------------
/Linked Lists/Singly Linked List/FindLoopAndMidElement.cpp:
--------------------------------------------------------------------------------
  1 | // Linked List program to:
  2 | // Search for an element in a LL
  3 | // Find the mid element of the LL
  4 | // Detect of any loop is present in the LL
  5 | 
  6 | 
  7 | #include <iostream>
  8 | using namespace std;
  9 | 
 10 | struct Node
 11 | {
 12 |     struct Node* next;
 13 |     int data;
 14 | };
 15 | 
 16 | Node* insert(Node* head, int data)
 17 | {
 18 |     Node* newNode = (Node*)malloc(sizeof(Node));
 19 |     Node* temp = head;
 20 |     newNode->data = data;
 21 |     newNode->next = NULL;
 22 |     if(head==NULL)
 23 |         return newNode;
 24 |     while(head->next!=NULL)
 25 |         head = head->next;
 26 |     head->next = newNode;
 27 |     return temp;
 28 | }
 29 | 
 30 | void display(Node* head)
 31 | {
 32 |     Node* temp = head;
 33 |     while(temp!=NULL)
 34 |     {
 35 |         cout<<temp->data<<endl;
 36 |         temp = temp->next;
 37 |     }
 38 | }
 39 | 
 40 | int count(Node* head)
 41 | {
 42 |     if(head==NULL)
 43 |         return 0;
 44 |     else 
 45 |         return 1+count(head->next);
 46 | }
 47 | 
 48 | bool search(Node* head, int data)
 49 | {
 50 |     if(head==NULL)
 51 |         return false;
 52 |     else
 53 |     {
 54 |         if(head->data==data)
 55 |             return true;
 56 |         else
 57 |             return search(head->next, data);
 58 |     }
 59 | }
 60 | 
 61 | int middle(Node* head)
 62 | {
 63 |     Node *ptr1 = head;
 64 |     Node *ptr2 = head;
 65 |     if(head==NULL)
 66 |         return 0;
 67 |     while(ptr2!=NULL && ptr2->next!=NULL)
 68 |     {
 69 |         ptr2 = ptr2->next->next;
 70 |         ptr1 = ptr1->next;
 71 |     }
 72 |     return ptr1->data;
 73 | }
 74 | 
 75 | bool has_cycle(Node* head) {
 76 |     Node* ptr1 = head;
 77 |     Node* ptr2 = head;
 78 |     if(head==NULL || head->next==NULL)
 79 |         return false;
 80 |         
 81 |     while(ptr1!=NULL && ptr2!=NULL && ptr2->next!=NULL)
 82 |     {
 83 |         ptr1 = ptr1->next;
 84 |         ptr2 = ptr2->next->next;
 85 |         if(ptr2==ptr1)
 86 |             return true;
 87 |     }
 88 |     return false;
 89 | }
 90 | 
 91 | int main()
 92 | {
 93 |    cout << "Hello World" << endl; 
 94 |    cout<<"Creating a list"<<endl;
 95 |    Node* head = NULL;
 96 |    head = insert(head, 1);
 97 |    head = insert(head, 2);
 98 |    head = insert(head, 3);
 99 |    head = insert(head, 4);
100 |    head = insert(head, 5);
101 |    display(head);
102 |    int ct = count(head);
103 |    cout<<"Size of linked list is: "<<ct<<endl;
104 |    bool found = search(head, 177);
105 |    cout<<"Is found: "<<found<<endl;
106 |    int mid = middle(head);
107 |    cout<<"Mid is: "<<mid<<endl;
108 |    bool cycle = has_cycle(head);
109 |    cout<<"Cycle found: "<<cycle<<endl;
110 |    return 0;
111 | }


--------------------------------------------------------------------------------
/Linked Lists/Singly Linked List/Insertion At Beginning.c:
--------------------------------------------------------------------------------
 1 | // Write a program to create a linked list with the given number of elements by inserting every element at the beginning.
 2 | //If there are no elements given then the head of the linked list will be null. 
 3 | //After completing the insertion of all elements print the elements in the linked list at the end. 
 4 | //If no elements are inserted then print null on the standard output.
 5 | 
 6 | // Note: Intially the linked list will be empty
 7 | 
 8 | // Input Format
 9 | 
10 | // First Line contains number of elements(n) to be inserted and followed the n elements
11 | 
12 | // Constraints
13 | 
14 | // 0<=n<=100
15 | 
16 | // 1<=element<=10000
17 | 
18 | // Output Format
19 | 
20 | // Print the elements in the linkedlist
21 | 
22 | // Sample Input 0
23 | 
24 | // 5
25 | // 5
26 | // 4
27 | // 3
28 | // 2
29 | // 1
30 | // Sample Output 0
31 | 
32 | // 1->2->3->4->5
33 | // Explanation 0
34 | 
35 | // Initially the list will be empty and then we will add 5. After that we will add 4 infront of 5. 
36 | //Similarly 3 infront of 4 and so on.
37 | 
38 | 
39 | 
40 | #include <stdio.h>
41 | #include <string.h>
42 | #include <math.h>
43 | #include <stdlib.h>
44 | typedef struct node str;
45 | struct node
46 | {
47 |     int data;
48 |     str *next;
49 | };
50 | 
51 | str* insert(str *head, int item)
52 | {
53 |     if(head==NULL)
54 |     {
55 |         head=(str *)malloc(sizeof(str));
56 |         head->data=item;
57 |         head->next=NULL;
58 |     }
59 |     else
60 |     {
61 |         str *new=(str *)malloc(sizeof(str));
62 |         new->data=item;
63 |         new->next=head;
64 |         head=new;
65 |     }
66 |     return head;
67 | }
68 | 
69 | void printlist(str *head)
70 | {
71 |     str *ptr=head;
72 |     while(ptr->next != NULL)
73 |     {
74 |         printf("%d->",ptr->data);
75 |         ptr=ptr->next;
76 |     }
77 |     printf("%d",ptr->data);
78 | }
79 | int main() {
80 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
81 |     int n,i,ele;
82 |     scanf("%d",&n);
83 |     str *head=NULL;
84 |     for(i=0;i<n;i++)
85 |     {
86 |         scanf("%d",&ele);
87 |         head=insert(head,ele);
88 |     }
89 |     if(head==NULL)
90 |         printf("null");
91 |     else
92 |         printlist(head);
93 |     return 0;
94 | }
95 | 


--------------------------------------------------------------------------------
/Linked Lists/Singly Linked List/Printing in reverse.c:
--------------------------------------------------------------------------------
 1 | // You are given the pointer to the head node of a linked list and you need to print all its elements in reverse order 
 2 | // from tail to head, on one line separated by space. The head pointer may be null meaning that the list 
 3 | // is empty - in that case, do not print anything!
 4 | 
 5 | // Input Format
 6 | 
 7 | // You have to complete the void ReversePrint(LinkedListNode* head) method which takes one argument
 8 | // - the head of the linked list. You should NOT read any input from stdin/console.
 9 | 
10 | // Output Format
11 | 
12 | // Print the elements of the linked list in reverse order to stdout/console (using printf or cout) , separated by a space.
13 | 
14 | #include <math.h>
15 | #include <stdio.h>
16 | #include <string.h>
17 | #include <stdlib.h>
18 | #include <assert.h>
19 | #include <limits.h>
20 | #include <stdbool.h>
21 | typedef struct LinkedListNode LinkedListNode;
22 | 
23 | struct LinkedListNode {
24 |     int val;
25 |     LinkedListNode *next;
26 | };
27 | 
28 | LinkedListNode* _insert_node_into_singlylinkedlist(LinkedListNode *head, LinkedListNode *tail, int val) {
29 |     if(head == NULL) {
30 |         head = (LinkedListNode *) (malloc(sizeof(LinkedListNode)));
31 |         head->val = val;
32 |         head->next = NULL;
33 |         tail = head;
34 |     }
35 |     else {
36 |         LinkedListNode *node = (LinkedListNode *) (malloc(sizeof(LinkedListNode)));
37 |         node->val = val;
38 |         node->next = NULL;
39 |         tail->next = node;
40 |         tail = tail->next;
41 |     }
42 |     return tail;
43 | }
44 | 
45 | //BODY STARTS HERE
46 | 
47 | 
48 | /*
49 |  * Complete the function below.
50 |  */
51 | /*
52 | For your reference:
53 | LinkedListNode {
54 |     int val;
55 |     LinkedListNode *next;
56 | };
57 | */
58 | void ReversePrint(LinkedListNode* head) {
59 | 
60 | }
61 | 
62 | 
63 | //BODY ENDS HERE
64 | 
65 | int main()
66 | {
67 |     int head_size = 0;
68 | 
69 |     LinkedListNode* head = NULL;
70 |     LinkedListNode* head_tail = NULL;
71 | 
72 |     scanf("%d\n", &head_size);
73 |     for(int i = 0; i < head_size; i++) {
74 |         int head_item;
75 |         scanf("%d", &head_item);
76 |         head_tail = _insert_node_into_singlylinkedlist(head, head_tail, head_item);
77 | 
78 |         if(i == 0) {
79 |             head = head_tail;
80 |         }
81 |     }
82 | 
83 | 
84 |     ReversePrint(head);
85 |     
86 |     return 0;
87 | }
88 | 


--------------------------------------------------------------------------------
/Miscellaneous/7DivisiblePairs.cpp:
--------------------------------------------------------------------------------
 1 | /*You are given an array A[N] of size N.
 2 | We define a 7-Divisible Pair as a pair of integers (i,j) such that Ai + Aj is divisible by 7.
 3 | Formally, a pair of integers (i,j) is a 7-Divisible pair if ( Ai + Aj ) % 7 = 0.
 4 | Your task is to find the total number of 7-Divisible pairs from the given array.
 5 | 
 6 | INPUT
 7 | 
 8 | First line contains N the size of the array. (1 ≤ N ≤ 105).
 9 | Second line contains the array elements that all lie between 1 and 105.
10 | 
11 | OUTPUT
12 | 
13 | Output a single integer that denotes the number of pairs divisible by 7.
14 | 
15 | Sample Input 0
16 | 
17 | 5
18 | 9 3 7 4 14
19 | 
20 | Sample Output 0
21 | 
22 | 2
23 | 
24 | */
25 | 
26 | #include <iostream>
27 | using namespace std;
28 | 
29 | 
30 | int main(){
31 |     unsigned int n,count1=0,count2=0,count3=0,count4=0,count5=0,count6=0,count7=0;
32 |     cin>>n;
33 |     int a[n];
34 |     for(int i=0;i<n;i++)
35 |         cin>>a[i];
36 |     
37 |     for(int i=0;i<n;i++){
38 |         if(a[i]%7==0)
39 |             count1++;
40 |         else if(a[i]%7==1)
41 |             count2++;
42 |         else if(a[i]%7==2)
43 |             count3++;
44 |         else if(a[i]%7==3)
45 |             count4++;
46 |         else if(a[i]%7==4)
47 |             count5++;
48 |         else if(a[i]%7==5)
49 |             count6++;
50 |         else if(a[i]%7==6)
51 |             count7++;
52 |             
53 |         }
54 |    // cout<<count6<<" "<<count7<<" "<<count5<<" "<<count4<<" "<<count3<<" "<<count2<<" ";
55 |     unsigned int sum = count2*count7 + count3*count6 + count4*count5 + (count1*(count1-1))/2;
56 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
57 |     cout<<sum;
58 |     return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/Miscellaneous/ConfusedInteger.cpp:
--------------------------------------------------------------------------------
 1 | // Confused Integer
 2 | 
 3 | // Our beloved integer X is confused. He was told that he is a positive integer which fits in a 32 bit signed integer that can be expressed as A^P where P > 1 and A > 0 where A and P both should be integers. Now he wonders, there is a possibility that he does not exist at all because he does not satisfy the A^P expressibility condition. Given the values of A and P, find out if X exists or not.
 4 | 
 5 | // Input Format
 6 | 
 7 | // Input contains the value of integer X.
 8 | 
 9 | // Constraints
10 | 
11 | // 0 < X < 2x10^9
12 | 
13 | // Output Format
14 | 
15 | // Output "yes" if X can be expressed as A^P and "no" otherwise.
16 | 
17 | // Sample Input 0
18 | 
19 | // 4
20 | // Sample Output 0
21 | 
22 | // yes
23 | // Explanation 0
24 | 
25 | // Yes as 2^2 = 4
26 | 
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | using namespace std;
33 | 
34 |   int check(unsigned int n)
35 |   {
36 |       if(n<=1)
37 |           return 1;
38 |       for(int x=2;x<=sqrt(n);x++)
39 |       {
40 |           unsigned p=x;
41 |           while(p<=n)
42 |           {
43 |               p*=x;
44 |               if(p==n)
45 |                   return 1;
46 |           }
47 |       }
48 |       return 0;
49 |   }
50 | 
51 | int main() {
52 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
53 |     int n;
54 |     cin>>n;
55 |     int flag=check(n);
56 |     if(flag==1)
57 |     {
58 |         cout<<"yes";
59 |     }
60 |     else
61 |         cout<<"no";
62 |     return 0;
63 | }


--------------------------------------------------------------------------------
/Miscellaneous/ConsecutivePrimeSum.cpp:
--------------------------------------------------------------------------------
 1 | // Consecutive Prime Sum
 2 | 
 3 | // Some prime numbers can be expressed as Sum of other consecutive prime numbers.
 4 | 
 5 | // For example
 6 | 
 7 | // 5 = 2 + 3 
 8 | // 17 = 2 + 3 + 5 + 7 
 9 | // 41 = 2 + 3 + 5 + 7 + 11 + 13
10 | 
11 | // Your task is to find out how many prime numbers which satisfy this property are present in the range 3 to N subject to a constraint that summation should always start with number 2.
12 | 
13 | // Write code to find out number of prime numbers that satisfy the above mentioned property in a given range.
14 | 
15 | // Input Format:
16 | // Each test case contains a number N <= 1000000000
17 | 
18 | // Output Format:
19 | // Print the total number of all such prime numbers which are less than or equal to N.
20 | 
21 | #include <cmath>
22 | #include <cstdio>
23 | #include <vector>
24 | #include <iostream>
25 | #include <algorithm>
26 | using namespace std;
27 | 
28 | int isPrime(int n)
29 | {
30 |     for(int i=2;i<=(int)sqrt(n);i++)
31 |     {
32 |         if(n%i==0)
33 |             return 0;
34 |     }
35 |     return 1;
36 | }
37 | 
38 | int main() {
39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
40 |     int i,j,n,ct=0,sum=2;
41 |     cin>>n;
42 |     for(i=3;sum<n;i+=2)
43 |     {
44 |         if(isPrime(i))
45 |         {    
46 |             sum+=i;
47 |             if(isPrime(sum) && sum<=n)
48 |                 ct++;
49 |         }
50 |     }
51 |     cout<<ct;
52 |     return 0;
53 | }


--------------------------------------------------------------------------------
/Miscellaneous/Counting Valleys.py:
--------------------------------------------------------------------------------
 1 | # Counting Valleys
 2 | 
 3 | # Gary is an avid hiker. He tracks his hikes meticulously, paying close attention to small details like topography. During his last hike he took exactly  steps. For every step he took, he noted if it was an uphill, , or a downhill,  step. Gary's hikes start and end at sea level and each step up or down represents a  unit change in altitude. We define the following terms:
 4 | 
 5 | # A mountain is a sequence of consecutive steps above sea level, starting with a step up from sea level and ending with a step down to sea level.
 6 | # A valley is a sequence of consecutive steps below sea level, starting with a step down from sea level and ending with a step up to sea level.
 7 | # Given Gary's sequence of up and down steps during his last hike, find and print the number of valleys he walked through.
 8 | 
 9 | # For example, if Gary's path is , he first enters a valley  units deep. Then he climbs out an up onto a mountain  units high. Finally, he returns to sea level and ends his hike.
10 | 
11 | # Function Description
12 | 
13 | # Complete the countingValleys function in the editor below. It must return an integer that denotes the number of valleys Gary traversed.
14 | 
15 | # countingValleys has the following parameter(s):
16 | 
17 | # n: the number of steps Gary takes
18 | # s: a string describing his path
19 | # Input Format
20 | 
21 | # The first line contains an integer , the number of steps in Gary's hike. 
22 | # The second line contains a single string , of  characters that describe his path.
23 | 
24 | # Constraints
25 | 
26 | # Output Format
27 | 
28 | # Print a single integer that denotes the number of valleys Gary walked through during his hike.
29 | 
30 | # Sample Input
31 | 
32 | # 8
33 | # UDDDUDUU
34 | # Sample Output
35 | 
36 | # 1
37 | # Explanation
38 | 
39 | # If we represent _ as sea level, a step up as /, and a step down as \, Gary's hike can be drawn as:
40 | 
41 | # _/\      _
42 | #    \    /
43 | #     \/\/
44 | # He enters and leaves one valley.
45 | 
46 | 
47 | 
48 | #!/bin/python3
49 | 
50 | import math
51 | import os
52 | import random
53 | import re
54 | import sys
55 | 
56 | # Complete the countingValleys function below.
57 | def countingValleys(n, s):
58 |     sum1=0
59 |     m=0
60 |     v=0
61 |     l=[0]
62 |     for t in s:
63 |         if(t=='U'):
64 |             sum1+=1
65 |         else:
66 |             sum1+=-1
67 |         l.append(sum1)
68 |     for i in range(len(l)-1):
69 |         if(l[i]==0 and l[i+1]>0):
70 |             m+=1
71 |         elif(l[i]==0 and l[i+1]<0):
72 |             v+=1
73 |     return v
74 | 
75 | if __name__ == '__main__':
76 |     fptr = open(os.environ['OUTPUT_PATH'], 'w')
77 | 
78 |     n = int(input())
79 | 
80 |     s = input()
81 | 
82 |     result = countingValleys(n, s)
83 | 
84 |     fptr.write(str(result) + '\n')
85 | 
86 |     fptr.close()
87 | 


--------------------------------------------------------------------------------
/Miscellaneous/DigitsInFactorial.py:
--------------------------------------------------------------------------------
 1 | # As simple as the title, given a number N, print the number of digits in N!
 2 | 
 3 | # N! is defined as : N! = 1*2*3...(N-1)*N
 4 | 
 5 | # 0! = 0 and 1! = 1.
 6 | 
 7 | # No number ever contains any leading zeros.
 8 | 
 9 | # Input Format
10 | # Input contains only one number, N.
11 | # Constraints
12 | # 1 <= N <= 1000
13 | 
14 | # Output Format
15 | # Output one number that is equal to the number of digits in N!
16 | 
17 | # Sample Input 0
18 | # 6
19 | 
20 | # Sample Output 0
21 | # 3
22 | 
23 | # Explanation 0
24 | 
25 | # 6! = 1x2x3x4x5x6 = 720 which has 3 digits. So the answer is 3.
26 | 
27 | 
28 | import math
29 | 
30 | x = int(input())
31 | count = 0
32 | if x > 0:
33 |     for i in range(2, x + 1):
34 |         count += math.log10(i)
35 | 
36 |     print(math.floor(count) + 1)
37 | else:
38 |     print(0)
39 | 
40 | # Explanation: Take log on both sides. log(1*2*3*4*5*6) = log(1)+log(2)+log(3)... = log(720)
41 | # floor(log(720))+1 = number of digits in the factorial
42 | 


--------------------------------------------------------------------------------
/Miscellaneous/EsotericChairs.py:
--------------------------------------------------------------------------------
 1 | # You invited n guests to dinner! 
 2 | # You plan to arrange one or more circles of chairs. 
 3 | # Each chair is going to be either occupied by one guest, or be empty. 
 4 | # You can make any number of circles.
 5 | 
 6 | # Your guests happen to be a little bit shy, so the i-th guest wants to have a least li free chairs to the left of his chair, and at least ri free chairs to the right. 
 7 | # The "left" and "right" directions are chosen assuming all guests are going to be seated towards the center of the circle. 
 8 | # Note that when a guest is the only one in his circle, the li chairs to his left and ri chairs to his right may overlap.
 9 | 
10 | # What is smallest total number of chairs you have to use?
11 | 
12 | # Input Format
13 | # First line contains one integer  n— number of guests.
14 | 
15 | # Next n lines contain n pairs of space-separated integers li and ri.
16 | 
17 | # Sample Input 0
18 | # 4
19 | # 1 2
20 | # 2 1
21 | # 3 5
22 | # 5 3
23 | 
24 | # Sample Output 0
25 | # 15
26 | 
27 | # Explanation 0
28 | # In the second sample the only optimal answer is to use two circles: a circle with 5 chairs accomodating guests 1 and 2, 
29 | # and another one with 10 chairs accomodating guests 3 and 4.
30 | 
31 | n = int(input())
32 | a = []
33 | b = []
34 | # input
35 | for i in range(n):
36 |     x, y = map(int, input().split())
37 |     a.append(x)
38 |     b.append(y)
39 | 
40 | 
41 | # sorting because then distances between two most similar people (by difference of chairs) will be lowest possible
42 | a = sorted(a)
43 | b = sorted(b)
44 | 
45 | # counting total chairs in between people
46 | tot = 0
47 | for i in range(n):
48 |     tot += max(a[i], b[i])
49 | 
50 | # adding num of people
51 | print(tot+n)
52 | 


--------------------------------------------------------------------------------
/Miscellaneous/Factors57.py:
--------------------------------------------------------------------------------
 1 | # Factor57
 2 | 
 3 | # Develop a Python method change(amount) that for any integer amount in the range from 24 to 1000 
 4 | # returns a list consisting of numbers 5 and 7 only, such that their sum is equal to amount.
 5 | # For example, change(28) may return [7, 7, 7, 7], while change(49) may return [7, 7, 7, 7, 7, 7, 7] 
 6 | # or [5, 5, 5, 5, 5, 5, 5, 7, 7] or [7, 5, 5, 5, 5, 5, 5, 5, 7].
 7 | 
 8 | def change(amount):
 9 |     if not (24 <= amount <= 1000):
10 |         return [0]
11 |     k = int(3 * amount / 7)
12 |     return [5] * (3*amount-7*k) + [7] * (5*k-2*amount)
13 |     
14 | # print(change (24))
15 | # print(change (28))
16 | # print(change (49))
17 | # print(change (55))
18 | n = int(input())
19 | print(change(n))
20 | 
21 | 
22 | # Explanation:
23 | # If we call our target number n, count the number of 5s in the solution list and call it r, and count the number of 7s and call it s, we can restate the problem as finding nonnegative integers r, s for which
24 | 
25 | # 5 * r + 7 * s = n
26 | # We first want to solve that equation for n=1 and allow r or s to be negative. I quickly used continued fractions to solve that, a technique similar to the extended Euclidean algorithm. I'll skip the details, but I quickly came up with
27 | 
28 | # 5 * 3 + 7 * -2 = 1
29 | # We now multiply both sides of that equation by n and get
30 | 
31 | # 5 * (3*n) + 7 * (-2*n) = n
32 | # Since we found one solution, number theory tells us there are actually infinitely many solutions, all of them in the form
33 | 
34 | # 5 * (3*n - 7*k) + 7 * (-2*n + 5*k) = n
35 | # where k is an arbitrary integer. We are almost done, but we need to find k so that those multipliers are nonnegative. We also want to make our solution list as short as possible, so we want as many 7s and as few 5s as possible. So we require the multiplier of 5 to be nonnegative and desire it to be small which means we want k to be large. So we require
36 | 
37 | # 3 * n - 7 * k >= 0
38 | # Solve that for k and we get
39 | 
40 | # k <= 3 * n / 7
41 | # The largest integer that satisfies that is
42 | 
43 | # k = int(3 * n / 7)
44 | # which explains the next-to-last line in my code. So we want 3*n-7*k number of 5s in our list and -2*n+5*k which is 5*k-2*n number of 7s in our result list. We finally use Python's list multiplier syntax, which means that if mylist is a list value, then mylist * t is a list containing t copies of mylist concatenated to each other. Therefore I used that notation twice to return a list with the desired number of 5s followed by the desired number of 7s.
45 | 
46 | # Finally, number theory tells us that we get nonnegative values for those list multipliers for any value of  n that is at least (5-1) * (7-1) which is 24. That explains the lower bound in the problem. There is no upper bound in the mathematical problem--I assume the computing problem gives an upper bound of 1000 to allow for quick checking.


--------------------------------------------------------------------------------
/Miscellaneous/NobleInteger.py:
--------------------------------------------------------------------------------
 1 | # Noble Integer
 2 | 
 3 | # Given an integer array, find if an integer p exists in the array
 4 | # such that the number of integers greater than p in the array equals to p
 5 | 
 6 | # If such an integer is found return 1 else return -1.
 7 | 
 8 | 
 9 | class Solution:
10 |     # @param A : list of integers
11 |     # @return an integer
12 |     def solve(self, A):
13 |         A = sorted(A)
14 |         size = len(A)
15 |         i = 0
16 |         while i < size:
17 |             temp = A[i]
18 |             # Checking for the same number being repeated multiple times
19 |             # Example: 0,0,2,2,3 should be -1 (as 2 isn't greater than 2)
20 |             while(i < size - 1 and A[i + 1] == temp):
21 |                 i += 1
22 |             if(temp == size - i - 1):
23 |                 return 1
24 |             i += 1
25 |         return -1
26 | 
27 | 
28 | """
29 | Testing Code for this problem
30 | """
31 | 
32 | s = Solution()
33 | a = [0, 0, 2, 2, 3]
34 | print(s.solve(a))
35 | 
36 | # output == [1,2,3,5]
37 | 


--------------------------------------------------------------------------------
/Miscellaneous/NotExactlyGCD.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | GCD, not exactly
 3 | 
 4 | In math, GCD, the greatest common divisor is an easy task to calculate for 2 positive numbers.
 5 | 
 6 | A common divisor of two positive numbers is a number which divides both numbers.
 7 | 
 8 | However your teacher decides to give you a more difficult task, in this task you need to find the largest divisor d between two integers a and b that is in a given range from low to high (inclusive), i.e. low ≤ d ≤ high. It is possible that there is no common divisor in the given range.
 9 | 
10 | You will be given the two integers a and b, then n queries. Each query is a range from low to high and you have to answer each query.
11 | 
12 | Input Format
13 | 
14 | The first line has a and b, the two integers as described above.
15 | 
16 | The second line contains one integer n, representing the number of queries.
17 | 
18 | In the n lines that follow, each line contains one query consisting of two integers, low and high.
19 | 
20 | Output Format
21 | 
22 | Print n lines.
23 | 
24 | The i-th of them should have the result of the i-th query in the input.
25 | 
26 | If there is no common divisor in the given range for any query, print -1.
27 | 
28 | Sample Input 0
29 | 
30 | 9 27
31 | 3
32 | 1 5
33 | 10 11
34 | 9 11
35 | Sample Output 0
36 | 
37 | 3
38 | -1
39 | 9  
40 | */
41 | 
42 | #include <stdio.h>
43 | #include <string.h>
44 | #include <math.h>
45 | #include <stdlib.h>
46 | 
47 | int gcd_max(long int n1, long int n2, long int lo, long int hi)
48 | {
49 |     long int i,gcd=-1;
50 |     if(lo>hi)
51 |         return -1;
52 |     for(i=hi;i>=lo;i--)
53 |     {
54 |         if(n1%i==0 && n2%i==0)
55 |             return i;
56 |     }
57 |     return gcd;
58 | }
59 | 
60 | int main() {
61 | 
62 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
63 |     long int n1,n2,n,i,lo,hi;
64 |     scanf("%ld",&n1);
65 |     scanf("%ld",&n2);
66 |     scanf("%ld",&n);
67 |     for(i=0;i<n;i++)
68 |     {
69 |         scanf("%ld",&lo);
70 |         scanf("%ld",&hi);
71 |         int res = gcd_max(n1,n2,lo,hi);
72 |         printf("%d\n",res);
73 |     }
74 |     return 0;
75 | }
76 | notGCDexactly.cpp
77 | Displaying notGCDexactly.cpp.


--------------------------------------------------------------------------------
/Miscellaneous/ParliamentSquare.py:
--------------------------------------------------------------------------------
 1 | # Parliament Square
 2 | 
 3 | # Parliament in the capital city of Delhi has a rectangular shape with the size n × m meters. On the occasion of the city's anniversary, a decision was taken to pave the Square with square granite flagstones. Each flagstone is of the size a × a.
 4 | 
 5 | # What is the least number of flagstones needed to pave the Square? It's allowed to cover the surface larger than the Parliament Square, but the Square has to be covered. It's not allowed to break the flagstones. The sides of flagstones should be parallel to the sides of the Square.
 6 | 
 7 | # Input Format
 8 | 
 9 | # The input contains three positive integer numbers in the first line: n,  m and a.
10 | 
11 | # Constraints
12 | 
13 | # 1 ≤  n, m, a ≤ 10^9
14 | 
15 | # Output Format
16 | 
17 | # Write the needed number of flagstones.
18 | 
19 | # Sample Input 0
20 | 
21 | # 6 6 4
22 | # Sample Output 0
23 | 
24 | # 4
25 | 
26 | 
27 | def main():
28 |     t=1
29 |     for i in range(t):
30 |         i=raw_input().split()
31 |         n=int(i[0])
32 |         m=int(i[1])
33 |         a=int(i[2])
34 |         st=0
35 |         if n%a==0:
36 |             nst=n/a
37 |         else:
38 |             nst=int(n/a)+1
39 |         if m%a==0:
40 |             mst=m/a
41 |         else:
42 |             mst=int(m/a)+1
43 |         st=nst*mst
44 |         print st
45 | main()


--------------------------------------------------------------------------------
/Miscellaneous/ResetButtons.cpp:
--------------------------------------------------------------------------------
 1 | // Reset Buttons
 2 | 
 3 | // Kushal is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.
 4 | 
 5 | // Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.
 6 | 
 7 | // Kushal doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.
 8 | 
 9 | // Input Format
10 | 
11 | // A single line contains integer n (1 ≤ n ≤ 2000) — the number of buttons the lock has.
12 | 
13 | // Constraints
14 | 
15 | // 1<=n<=2000
16 | 
17 | // Output Format
18 | 
19 | // In a single line print the number of times Kushal has to push a button in the worst-case scenario.
20 | 
21 | // Sample Input 0
22 | 
23 | // 2
24 | // Sample Output 0
25 | 
26 | // 3
27 | // Explanation 0
28 | 
29 | // Consider the test sample. Kushal can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.
30 | 
31 | #include <cmath>
32 | #include <cstdio>
33 | #include <vector>
34 | #include <iostream>
35 | #include <algorithm>
36 | using namespace std;
37 | 
38 | 
39 | int main() {
40 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
41 |     int n,i,ans=0;
42 |     cin>>n;
43 |     for(i=1;i<=n;i++)
44 |     {
45 |         // cout<<"Adding "<<i<<" * "<<n-1<<endl;
46 |         ans+=i*(n-i+1);
47 |     }
48 |     for(i=1;i<=n-1;i++)
49 |     {
50 |         // cout<<"Subtracting "<<i<<endl;
51 |         ans-=i;
52 |     }
53 |     cout<<ans;
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/Miscellaneous/ResidueArithmetic.cpp:
--------------------------------------------------------------------------------
 1 | // Residue Arithmetic
 2 | 
 3 | // For operators with large integers, residue arithmetic is used. A residue of a number n modulo a prime p is defined as the remainder obtained when we divide a by p. FOr example, if residue of 100 modulo 3 is 1. Two large primes are chosen and all numbers are expressed as modulo those primes.
 4 | 
 5 | // For example, if 7 and 3 were chosen as the primes, 25 would be represented as 4,12 in this representation, 3 would be represented as 3,3, and 30 would be represented as 2,4. Now if we do 25 * 3 - 30 in this model, we do the operation and compute the residue of the result with each of the primes in turn. SO with respect to the prime 7, the result is 4 * 3 - 2 or 10 which has a residue of 3 modulo 7. With respect to 13, the operation is 12 * 3 - 4 = 32 whose residue is 6 modulo 13. Hence the result is 3,6 in the residue notation. There is only one number less than 91 which has this representation, and that is 45, which is what we expect.
 6 | 
 7 | // In this problem we will be given 3 numbers a,b and c in residue notation for two primes p and q, and we need to find the value of 2a + b - c in normal notation. It may be assumed that the result is less than p * q and is non-negative. (c <= 2a + b)
 8 | 
 9 | // Input
10 | // First line consists of two primes 
11 | // Next 3 lines contains the three input numbers modulo those primes
12 | 
13 | // Output
14 | // Print the value of 2a + b - c in normal notation
15 | 
16 | // Sample Input 0
17 | 
18 | // 23 29
19 | // 7 1
20 | // 2 25
21 | // 4 21
22 | // Sample Output 0
23 | 
24 | // 35
25 | // Explanation 0
26 | 
27 | // Values of a, b and c are 30, 25 and 50. 2a + b - c is hence 35.
28 | 
29 | #include <stdio.h>
30 | #include <string.h>
31 | #include <math.h>
32 | #include <stdlib.h>
33 | #include<iostream>
34 | using namespace std;
35 | int modulo_prime(int x,int y,int m,int n)
36 | {
37 |     while(x!=y)
38 |     {
39 |         if(x>y)
40 |             y+=n;
41 |         else
42 |             x+=m;
43 |     }
44 |     return x;
45 | }
46 | int main() {
47 | 
48 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
49 |     int m,n,x,y,x1,x2,y1,y2,a,b,c,temp;
50 |     cin>>m>>n;
51 |     cin>>x>>y>>x1>>y1>>x2>>y2;
52 |     a=modulo_prime(x,y,m,n);
53 |     b=modulo_prime(x1,y1,m,n);
54 |     c=modulo_prime(x2,y2,m,n);
55 |     cout<<2*a+b-c;
56 |     return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/Miscellaneous/SquareInACircle.c:
--------------------------------------------------------------------------------
 1 | // Square in a Circle
 2 | 
 3 | // A square is kept inside a circle. It keeps expanding untill all four of its vertices touch the circumfernce of the circle. Another smaller circle is kept inside the square now and it keeps expanding untill its circumference touches all four sides of the square. The outer and the inner circle form a ring. Find the area of this ring.
 4 | 
 5 | // Input
 6 | // Input consists of multiple test cases. 
 7 | // Each test case contains one integer a denoting the side-length of the square between the two circles.
 8 | 
 9 | // Output
10 | // Print the area of the ring.
11 | 
12 | // Sample Input 0
13 | 
14 | // 3
15 | // 3
16 | // 4
17 | // 5
18 | // Sample Output 0
19 | 
20 | // 7.068583
21 | // 12.566371
22 | // 19.634954
23 | 
24 | 
25 | #include <stdio.h>
26 | #include <string.h>
27 | #include <math.h>
28 | #include <stdlib.h>
29 | 
30 | int main() {
31 | 
32 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
33 |      int t;
34 |     double a;
35 |     scanf("%d",&t);
36 |     for(int i=1;i<=t;++i)
37 |     {
38 |         scanf("%lf",&a);
39 |         double r1=a/2;
40 |         double c=sqrt(2*a*a);
41 |         double r2=c/2;
42 |         double a=(3.14159265358979323846)*(r2*r2-r1*r1);
43 |         printf("%0.6lf\n",a);
44 |     }
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/Miscellaneous/SumOfPairs.py:
--------------------------------------------------------------------------------
 1 | # Count the number of pairs in an array having the given sum
 2 | 
 3 | # Given an array of integers, and a number ‘sum’, chef wants to find the number of pairs of integers in the array whose sum is equal to ‘sum’.
 4 | 
 5 | # Examples:
 6 | 
 7 | # Input  :  arr[] = {1, 5, 7, -1}, 
 8 | #           sum = 6
 9 | # Output :  2
10 | # Pairs with sum 6 are (1, 5) and (7, -1)
11 | 
12 | # Input  :  arr[] = {1, 5, 7, -1, 5}, 
13 | #           sum = 6
14 | # Output :  3
15 | # Pairs with sum 6 are (1, 5), (7, -1) &
16 | #                      (1, 5)         
17 | 
18 | # Input  :  arr[] = {1, 1, 1, 1}, 
19 | #           sum = 2
20 | # Output :  6
21 | # There are 3! pairs with sum 2.
22 | 
23 | # Input  :  arr[] = {10, 12, 10, 15, -1, 7, 6, 
24 | #                    5, 4, 2, 1, 1, 1}, 
25 | #           sum = 11
26 | # Output :  9
27 | 
28 | 
29 | # cook your dish here
30 | # Brute Force Method [O(n^2)]
31 | n = int(input())
32 | arr = list(map(int,input().split()))
33 | sum = int(input())
34 | count = 0
35 | 
36 | for i in range(0, n):
37 |     for j in range(i+1, n): 
38 |         if arr[i]+arr[j]==sum: 
39 |             count+=1
40 | print(count)
41 | 
42 | 
43 | # Map Approach [O(n)] : 
44 | # Idea is to create a hashmap to store freq of the elements, and lookup those elements while traversing the array to check if their sum is equal to the given sum or not
45 | # GeeksforGeeks Explanation: https://youtu.be/bvKMZXc0jQU
46 | 
47 | def getPairsCount(arr, n, sum): 
48 | 	
49 | 	m = [0] * 1000
50 | 	
51 | 	# Store counts of all elements in map m 
52 | 	for i in range(0, n): 
53 | 		m[arr[i]]           # Stores the frequency of the number in the array
54 | 		m[arr[i]] += 1
55 | 
56 | 	twice_count = 0
57 | 
58 | 	# Iterate through each element and increment the count (Every pair is counted twice) 
59 | 	for i in range(0, n): 
60 | 	
61 | 		twice_count += m[sum - arr[i]] 
62 | 
63 | 		# if (arr[i], arr[i]) pair satisfies the condition, then we need to ensure that the count is decreased by one such that the (arr[i], arr[i]) pair is not considered 
64 | 		if (sum - arr[i] == arr[i]): 
65 | 			twice_count -= 1
66 | 	
67 | 	# return the half of twice_count 
68 | 	return int(twice_count / 2) 
69 | 
70 | n = int(input())
71 | arr = list(map(int,input().split()))
72 | sum = int(input())
73 | 
74 | print(getPairsCount(arr, n, sum))


--------------------------------------------------------------------------------
/Miscellaneous/SumOfPrimes.cpp:
--------------------------------------------------------------------------------
 1 | // N as Sum of Primes
 2 | 
 3 | // Given a number N, print "YES" if N can be expressed as a sum of 2 prime numbers and "NO" otherwise.
 4 | 
 5 | // Input Format
 6 | 
 7 | // One number, N.
 8 | 
 9 | // Constraints
10 | 
11 | // 1 <= N <= 10^5.
12 | 
13 | // Output Format
14 | 
15 | // "YES" or "NO"
16 | 
17 | // Sample Input 0
18 | 
19 | // 5
20 | // Sample Output 0
21 | 
22 | // YES
23 | // Explanation 0
24 | 
25 | // 5 = 2 + 3
26 | 
27 | // Sample Input 1
28 | 
29 | // 11
30 | // Sample Output 1
31 | 
32 | // NO
33 | 
34 | #include <cmath>
35 | #include <cstdio>
36 | #include <vector>
37 | #include <iostream>
38 | #include <algorithm>
39 | using namespace std;
40 | int check(int n)
41 | {  
42 |     int flag=0;
43 |     for(int i=2;i<=n/2;i++)
44 |     {
45 |         if(n%i==0)
46 |         {
47 |             flag=1;
48 |             break;
49 |         } 
50 |     }
51 |     if(flag==0||n==1)
52 |         return 1;
53 |     else
54 |         return 0;
55 | }
56 | 
57 | int main() {
58 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
59 |     int n;
60 |     cin>>n;
61 |     int temp=n;
62 |     int flag=0;
63 |     for(int i=2;i<=n/2;i++)
64 |     {
65 |         if(check(i)==1&&check(n-i)==1)
66 |         {
67 |             flag=1;
68 |             break;
69 |         }
70 |     }
71 |     if(flag==1)
72 |         cout<<"YES";
73 |     else
74 |         cout<<"NO";
75 |     return 0;
76 | }
77 | 


--------------------------------------------------------------------------------
/Miscellaneous/TrailingZerosOfFactorial.py:
--------------------------------------------------------------------------------
 1 | # Trailing Zeros of Factorial
 2 | 
 3 | # The most important part of a GSM network is so called Base Transceiver Station (BTS). These transceivers form the areas called cells (this term gave the name to the cellular phone) and every phone connects to the BTS with the strongest signal (in a little simplified view). Of course, BTSes need some attention and technicians need to check their function periodically.
 4 | 
 5 | # The technicians faced a very interesting problem recently. Given a set of BTSes to visit, they needed to find the shortest path to visit all of the given points and return back to the central company building. Programmers have spent several months studying this problem but with no results. They were unable to find the solution fast enough. After a long time, one of the programmers found this problem in a conference article. Unfortunately, he found that the problem is so called "Traveling Salesman Problem" and it is very hard to solve. If we have N BTSes to be visited, we can visit them in any order, giving us N! possibilities to examine. The function expressing that number is called factorial and can be computed as a product
 6 | 
 7 | # 1.2.3.4....N. The number is very high even for a relatively small N.
 8 | 
 9 | # The programmers understood they had no chance to solve the problem. But because they have already received the research grant from the government, they needed to continue with their studies and produce at least some results. So they started to study behavior of the factorial function.
10 | 
11 | # For example, they defined the function Z. For any positive integer N, Z(N) is the number of zeros at the end of the decimal form of number N!. They noticed that this function never decreases. If we have two numbers N1<N2, then Z(N1) <= Z(N2). It is because we can never "lose" any trailing zero by multiplying by any positive number. We can only get new and new zeros. The function Z is very interesting, so we need a computer program that can determine its value efficiently.
12 | 
13 | # Input
14 | # There is a single positive integer T on the first line of input (equal to about 100000). It stands for the number of numbers to follow. Then there are T lines, each containing exactly one positive integer number N, 1 <= N <= 1000000000.
15 | 
16 | # Output
17 | # For every number N, output a single line containing the single non-negative integer Z(N).
18 | 
19 | # Example
20 | # Sample Input:
21 | 
22 | # 6
23 | # 3
24 | # 60
25 | # 100
26 | # 1024
27 | # 23456
28 | # 8735373
29 | # Sample Output:
30 | 
31 | # 0
32 | # 14
33 | # 24
34 | # 253
35 | # 5861
36 | # 2183837
37 | 
38 | t = int(input())
39 | for i in range(t):
40 |     num = int(input())
41 |     count=0
42 |     j=5
43 |     while(num//j!=0):
44 |         count += int(num/j)
45 |         j*=5
46 |     print(count)


--------------------------------------------------------------------------------
/Miscellaneous/XOR.py:
--------------------------------------------------------------------------------
 1 | # Exclusive OR
 2 | 
 3 | # Find the XOR of two numbers and print it.
 4 | 
 5 | # Hint : Input the numbers as strings.
 6 | 
 7 | # Input Format
 8 | 
 9 | # First line contains first number X and second line contains second number Y.
10 | # The numbers will be given to you in binary form.
11 | 
12 | # Constraints
13 | 
14 | # 0 <= X <= 2^1000
15 | # 0 <= Y <= 2^1000
16 | 
17 | # Output Format
18 | 
19 | # Output one number in binary format, the XOR of two numbers.
20 | 
21 | # Sample Input 0
22 | 
23 | # 11011
24 | # 10101
25 | # Sample Output 0
26 | 
27 | # 01110
28 | 
29 | # Enter your code here. Read input from STDIN. Print output to STDOUT
30 | a = input()
31 | b = input()
32 | ab = int(a,2)
33 | bc = int(b,2)
34 | x = len(a)
35 | y = len(b)
36 | if x>y:
37 |     m=x
38 | else:
39 |     m=y
40 | ans = ab^bc
41 | print("{0:b}".format(ans).zfill(m))


--------------------------------------------------------------------------------
/Patterns/AlphabetRangoli.py:
--------------------------------------------------------------------------------
 1 | # You are given an integer, X.
 2 | # Your task is to print an alphabet rangoli of size X.
 3 | # (Rangoli is a form of Indian folk art based on creation of patterns.)
 4 | 
 5 | # Different sizes of alphabet rangoli are shown below:
 6 | 
 7 | # #size 3
 8 | 
 9 | # ----c----
10 | # --c-b-c--
11 | # c-b-a-b-c
12 | # --c-b-c--
13 | # ----c----
14 | 
15 | # The center of the rangoli has the first alphabet letter a, and the boundary has the Xth alphabet letter (in alphabetical order).
16 | 
17 | # Input Format
18 | # Only one line of input containing , the size of the rangoli.
19 | 
20 | # Constraints
21 | # 0<N<27
22 | 
23 | # Output Format
24 | # Print the alphabet rangoli in the format explained above.
25 | 
26 | # Sample Input
27 | # 5
28 | 
29 | # Sample Output
30 | 
31 | # --------e--------
32 | # ------e-d-e------
33 | # ----e-d-c-d-e----
34 | # --e-d-c-b-c-d-e--
35 | # e-d-c-b-a-b-c-d-e
36 | # --e-d-c-b-c-d-e--
37 | # ----e-d-c-d-e----
38 | # ------e-d-e------
39 | # --------e-------
40 | 
41 | 
42 | def print_rangoli(size):
43 |     # i forgot what i was doing i'm not sure why this works
44 |     for i in range(1, (2 * size) // 2 + 1):
45 |         for j in range((2 * size) - (2 * i)):
46 |             print('-', end='')
47 | 
48 |         for j in range(i - 1):
49 |             print(chr(97 + size - j - 1), end='')
50 |             print('-', end='')
51 | 
52 |         for j in range(0, i):
53 |             print(chr(97 + size - i + j), end='')
54 |             if(j < size - 1):
55 |                 print('-', end='')
56 | 
57 |         for j in range((2 * size) - (2 * i) - 1):
58 |             print('-', end='')
59 |         print()
60 | 
61 |     for i in range(1, (2 * size) // 2):
62 |         for j in range(2 * i):
63 |             print('-', end='')
64 | 
65 |         for j in range(0, size - i - 1):
66 |             print(chr(97 + size - j - 1), end='')
67 |             print('-', end='')
68 | 
69 |         for j in range(0, size - i):
70 |             print(chr(97 + j + i), end='')
71 |             if(j < size - 1):
72 |                 print('-', end='')
73 | 
74 |         for j in range(2 * i - 1):
75 |             print('-', end='')
76 |         print()
77 | 
78 | 
79 | if __name__ == '__main__':
80 |     n = int(input())
81 |     print_rangoli(n)
82 | 


--------------------------------------------------------------------------------
/Patterns/BoxPattern.cpp:
--------------------------------------------------------------------------------
  1 | // Forming Numericals
  2 | 
  3 | // Print the following pattern :
  4 | 
  5 | // N = 1
  6 | // 1
  7 | 
  8 | // N = 2
  9 | // 2 2 2
 10 | // 2 1 2
 11 | // 2 2 2
 12 | 
 13 | // N = 3
 14 | 
 15 | // 3 3 3 3 3
 16 | // 3 2 2 2 3
 17 | // 3 2 1 2 3
 18 | // 3 2 2 2 3
 19 | // 3 3 3 3 3
 20 | 
 21 | // and so on.
 22 | // Input Format
 23 | 
 24 | // One number N
 25 | 
 26 | // Constraints
 27 | 
 28 | // 1 <= N <= 10
 29 | 
 30 | // Output Format
 31 | 
 32 | // The pattern
 33 | 
 34 | // Sample Input 0
 35 | 
 36 | // 2
 37 | // Sample Output 0
 38 | 
 39 | // 2 2 2
 40 | // 2 1 2
 41 | // 2 2 2
 42 | 
 43 | #include <cmath>
 44 | #include <cstdio>
 45 | #include <vector>
 46 | #include <iostream>
 47 | #include <algorithm>
 48 | using namespace std;
 49 | 
 50 | 
 51 | int main() {
 52 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
 53 |     int n;
 54 |     cin>>n;
 55 |     int i,j,k,x,g,z,u,a,e,b,ct=0,q;
 56 |     u=n;
 57 |     int s=n;
 58 |     int l=n;
 59 |     z=1;
 60 |     for(i=1;i<=n;i++)
 61 |     {
 62 |         s=n;
 63 |         for(j=1;j<=i;j++)
 64 |         {
 65 |             cout<<s--<<" ";
 66 |         }
 67 |         for(j=u-1;j>0;j--)
 68 |         {
 69 |             cout<<u<<" ";
 70 |         }
 71 |         u--;
 72 |         for(j=n-1;j>i;j--)
 73 |             cout<<l<<" ";
 74 |         l--;
 75 |         
 76 |         a=n-i+1;
 77 |         for(j=0;j<i;j++){
 78 |             if(a==1){
 79 |                 for(q=2;q<=n;q++)
 80 |                     cout<<q<<" ";
 81 |                 break;
 82 |             }
 83 |             else
 84 |                 cout<<a++<<" ";
 85 |         }
 86 |         cout<<endl;
 87 |     }
 88 |     for(i=1;i<=n;i++)
 89 |     {
 90 |         for(j=n;j>i;j--)
 91 |         {
 92 |             cout<<j<<" ";
 93 |         }
 94 |         
 95 |         z++;
 96 |         for(g=1;g<=i*2-1;g++){
 97 |             if(i==n)
 98 |                 break;
 99 |             cout<<z<<" ";
100 |         }
101 |         
102 |         for(j=i+1;j<=n;j++)
103 |         {
104 |             cout<<j<<" ";
105 |         }
106 |         cout<<endl;
107 |     }
108 |     
109 |         
110 |     return 0;
111 | }


--------------------------------------------------------------------------------
/Patterns/DesignerDoorMat.py:
--------------------------------------------------------------------------------
  1 | # Mr. Vincent works in a door mat manufacturing company.
  2 | # One day, he designed a new door mat with the following specifications:
  3 | 
  4 | # Mat size must be NxM. (N is an odd natural number, and M is 3 times N.)
  5 | # The design should have 'WELCOME' written in the center.
  6 | # The design pattern should only use '|', '.' and '-' characters.
  7 | 
  8 | # Sample Designs
  9 | 
 10 | #     Size: 7 x 21
 11 | #     ---------.|.---------
 12 | #     ------.|..|..|.------
 13 | #     ---.|..|..|..|..|.---
 14 | #     -------WELCOME-------
 15 | #     ---.|..|..|..|..|.---
 16 | #     ------.|..|..|.------
 17 | #     ---------.|.---------
 18 | 
 19 | #     Size: 11 x 33
 20 | #     ---------------.|.---------------
 21 | #     ------------.|..|..|.------------
 22 | #     ---------.|..|..|..|..|.---------
 23 | #     ------.|..|..|..|..|..|..|.------
 24 | #     ---.|..|..|..|..|..|..|..|..|.---
 25 | #     -------------WELCOME-------------
 26 | #     ---.|..|..|..|..|..|..|..|..|.---
 27 | #     ------.|..|..|..|..|..|..|.------
 28 | #     ---------.|..|..|..|..|.---------
 29 | #     ------------.|..|..|.------------
 30 | #     ---------------.|.---------------
 31 | 
 32 | # Input Format
 33 | 
 34 | # A single line containing the space separated values of N and M.
 35 | 
 36 | # Constraints
 37 | # 5<N<101
 38 | # 15<M<303
 39 | 
 40 | # Sample Input
 41 | 
 42 | # 9 27
 43 | # Sample Output
 44 | 
 45 | # ------------.|.------------
 46 | # ---------.|..|..|.---------
 47 | # ------.|..|..|..|..|.------
 48 | # ---.|..|..|..|..|..|..|.---
 49 | # ----------WELCOME----------
 50 | # ---.|..|..|..|..|..|..|.---
 51 | # ------.|..|..|..|..|.------
 52 | # ---------.|..|..|.---------
 53 | # ------------.|.------------
 54 | 
 55 | # CODE:
 56 | 
 57 | # Taking input
 58 | x, y = map(int, input().split())
 59 | 
 60 | # des2 for printing '.|.'
 61 | des2 = 1
 62 | dashes = (y - (3 * des2)) // 2
 63 | 
 64 | # top half
 65 | for j in range(1, (x // 2) + 1):
 66 |     # dashes
 67 |     for i in range(dashes):
 68 |         print('-', end='')
 69 |     # .|. pattern
 70 |     for i in range(des2):
 71 |         print('.|.', end='')
 72 |     # dashes on right side
 73 |     for i in range(dashes):
 74 |         print('-', end='')
 75 |     des2 = (j * 2) + 1
 76 |     dashes = (y - (3 * des2)) // 2
 77 |     print()
 78 | 
 79 | # middle line (WELCOME)
 80 | dashes = (y - 7) // 2
 81 | for i in range(dashes):
 82 |     print('-', end='')
 83 | print("WELCOME", end='')
 84 | for i in range(dashes):
 85 |     print('-', end='')
 86 | print()
 87 | 
 88 | # Bottom half
 89 | dashes = 3
 90 | 
 91 | for j in range((x // 2) - 1, -1, -1):
 92 |     des2 = (j * 2) + 1
 93 |     for i in range(dashes):
 94 |         print('-', end='')
 95 |     for i in range(des2):
 96 |         print('.|.', end='')
 97 |     for i in range(dashes):
 98 |         print('-', end='')
 99 |     dashes = dashes + 3
100 |     print()
101 | 


--------------------------------------------------------------------------------
/Patterns/GreatPattern.py:
--------------------------------------------------------------------------------
 1 | # Great Pattern
 2 | 
 3 | # Your task is simple, write a program in Java to print the following pattern :
 4 | 
 5 | # N = 1
 6 | # 1
 7 | 
 8 | # N = 2
 9 | #   1
10 | # 1 2 1
11 | #   1
12 |   
13 | # N = 3
14 | #     1
15 | #   1 2 1
16 | # 1 2 3 2 1
17 | #   1 2 1
18 | #     1
19 |     
20 | # and so on..
21 | # INPUT
22 | # Input consists of many test cases. 
23 | # First line contains the number of test case T. 
24 | # Each of the test case lines consists of one number N for that test case.
25 | 
26 | # OUTPUT
27 | # Print the pattern corresponding to the N value of each test case. 
28 | # Print a blank line between two test case outputs.
29 | 
30 | # CONSTRAINTS
31 | # 1 ≤ T, N ≤ 10
32 | 
33 | # Sample Input 0
34 | 
35 | # 3
36 | # 1
37 | # 2
38 | # 3
39 | # Sample Output 0
40 | 
41 | # 1
42 | 
43 | #   1
44 | # 1 2 1
45 | #   1
46 |   
47 | #     1
48 | #   1 2 1
49 | # 1 2 3 2 1
50 | #   1 2 1
51 | #     1
52 | 
53 | testcase=int(input())
54 | if testcase==0:
55 |     print("0")
56 | else:
57 |     for i in range(testcase):
58 |         n=int(input())
59 |         if(n==0):
60 |             print()
61 |             continue
62 |         t=1
63 |         for i in range(n,1,-1):
64 |             for j in range(1,i):
65 |                 print(" ",end=' ')
66 |             for k in range(1,t+1):
67 |                 print(k,end=' ')
68 |             for k in range(t-1,0,-1):
69 |                 print(k,end=' ')
70 |             '''for s in range(1,i):
71 |                 print(" ",end=' ')'''
72 |             t+=1
73 |             print()
74 |         a=0
75 |         for i in range(n,0,-1):
76 |             for k in range(0,a):
77 |                 print(" ",end=' ')
78 |             a+=1
79 |             for j in range(1,i+1):
80 |                 print(j,end=' ')
81 |             for l in range(i-1,0,-1):
82 |                 print(l,end=' ')
83 |             print()
84 |         print()


--------------------------------------------------------------------------------
/Patterns/PascalTriangle.cpp:
--------------------------------------------------------------------------------
 1 | // Pascal and His Triangle
 2 | 
 3 | // Pascal's Triangle in Mathematics is the following pattern :
 4 | 
 5 | // 1
 6 | // 1 1
 7 | // 1 2 1
 8 | // 1 3 3 1
 9 | // and so on
10 | // For Cth element in row R, it is equal to the sum of elements C and C-1 in row R-1.
11 | // The first and the last elements of every row are always 1.
12 | 
13 | // Your task is given a number K, print the first K rows of the pascals triangle.
14 | 
15 | // Input Format
16 | 
17 | // Only one integer, the value of K.
18 | 
19 | // Constraints
20 | 
21 | // 1 <= K <= 50
22 | 
23 | // Output Format
24 | 
25 | // Output K lines, the first K rows of the pascal's triangle.
26 | 
27 | // Sample Input 0
28 | 
29 | // 4
30 | // Sample Output 0
31 | 
32 | // 1
33 | // 1 1
34 | // 1 2 1
35 | // 1 3 3 1
36 | 
37 | #include <iostream>
38 | using namespace std;
39 | int main() {
40 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
41 |     int n,i,j;
42 |     cin>>n;
43 |     long long int a[n+1][n+1];
44 |     for(i=1;i<=n;i++)
45 |     {
46 |         for(j=1;j<=i;j++)
47 |         {
48 |             if(j==1||j==i)
49 |             {
50 |                 a[i][j]=1;
51 |                 cout<<a[i][j]<<" ";
52 |             }
53 |             else
54 |             {
55 |                 a[i][j]=a[i-1][j-1]+a[i-1][j];
56 |                 cout<<a[i][j]<<" ";
57 |             }
58 |         }
59 |         cout<<endl;
60 |     }
61 |     return 0;
62 | }


--------------------------------------------------------------------------------
/Patterns/Pattern1.py:
--------------------------------------------------------------------------------
 1 | # Sample Input
 2 | # 5
 3 | # Sample Output
 4 | 
 5 | # 1
 6 | # 01
 7 | # 101
 8 | # 0101
 9 | # 10101
10 | 
11 | n = int(input())
12 | temp = 1
13 | for i in range(1, n + 1):
14 |     for j in range(0, i):
15 |         print(temp, end='')
16 |         temp = abs(temp - 1)
17 |     if(i % 2 == 0):
18 |         temp = abs(temp - 1)
19 |     print()
20 | 


--------------------------------------------------------------------------------
/Patterns/Pattern2.py:
--------------------------------------------------------------------------------
 1 | # Sample Input
 2 | # 5
 3 | # Sample Output
 4 | #     1
 5 | #    12
 6 | #   123
 7 | #  1234
 8 | # 12345
 9 | 
10 | n = int(input())
11 | for i in range(1, n + 1):
12 |     print(' ' * (n - i), end='')
13 |     for j in range(1, i + 1):
14 |         print(j, end='')
15 |     print()
16 | 


--------------------------------------------------------------------------------
/Patterns/Pattern3.py:
--------------------------------------------------------------------------------
 1 | # Input can only be odd
 2 | # Input
 3 | 
 4 | # 11
 5 | # Output
 6 | 
 7 | # 1         11
 8 | #  2       10
 9 | #   3     9
10 | #    4   8
11 | #     5 7
12 | #      6
13 | 
14 | n = int(input())
15 | num_lines = (n // 2) + 1
16 | 
17 | for i in range(1, num_lines + 1):
18 |     print(' ' * (i - 1), end='')
19 |     print(i, end='')
20 |     print(' ' * ((num_lines - i) * 2 - 1), end='')
21 |     if i != num_lines:
22 |         print(n - i + 1)
23 | 


--------------------------------------------------------------------------------
/Patterns/Prime pyramid.cpp:
--------------------------------------------------------------------------------
 1 | // Prime Series
 2 | 
 3 | // Identify and print the following pattern generated by prime numbers for a given N.
 4 | 
 5 | // N = 1
 6 | // 2
 7 | 
 8 | // N = 2
 9 | // 2
10 | // 3 5
11 | 
12 | // N = 3
13 | // 2
14 | // 3 5
15 | // 7 11 13
16 | // Input
17 | // Input consists of a single integer N
18 | 
19 | // Output
20 | // Output must consists of the pattern as shown above.
21 | 
22 | // Sample Input 0
23 | 
24 | // 3
25 | // Sample Output 0
26 | 
27 | // 2
28 | // 3 5
29 | // 7 11 13
30 | 
31 | #include <cmath>
32 | #include <cstdio>
33 | #include <vector>
34 | #include <iostream>
35 | #include <algorithm>
36 | using namespace std;
37 | 
38 | 
39 | int main() {
40 |     int n,i=0,prime=2,j,flag;
41 |     cin>>n;
42 |     int total=(n*(n+1))/2;
43 |     int arr[total];
44 |     arr[i++]=2;
45 |     while(i!=total)
46 |     {
47 |         prime++;
48 |         flag=1;
49 |         for(j=2;j<=sqrt(prime);j++)
50 |         {
51 |             if(prime%j==0)
52 |             {
53 |                 flag=0;
54 |                 break;
55 |             }
56 |         }
57 |         if(flag==1)
58 |         {
59 |             arr[i++]=prime;
60 |             continue;
61 |         }
62 |     }
63 |     int k=0;
64 |     for(i=1;i<=n;i++)
65 |     {
66 |         for(j=1;j<=i;j++)
67 |             cout<<arr[k++]<<" ";
68 |         cout<<endl;
69 |     }
70 |     return 0;
71 | }
72 | 
73 | 


--------------------------------------------------------------------------------
/Patterns/PyramidByNumericals.py:
--------------------------------------------------------------------------------
 1 | # Pyramid by Numericals
 2 | 
 3 | # Identify the logic behind the series
 4 | 
 5 | # 6 28 66 120 190 276....
 6 | 
 7 | # The numbers in the series should be used to create a Pyramid. The base of the Pyramid will be the widest and will start converging towards the top where there will only be one element. Each successive layer will have one number less than that on the layer below it. The width of the Pyramid is specified by an input parameter N. In other words there will be N numbers on the bottom layer of the pyramid.
 8 | 
 9 | # The Pyramid construction rules are as follows
10 | # 1. First number in the series should be at the top of the Pyramid
11 | # 2. Last N number of the series should be on the bottom-most layer of the Pyramid, with Nth number being the right-most number of this layer.
12 | # 3. Numbers less than 5-digits must be padded with zeroes to maintain the sanctity of a Pyramid when printed. Have a look at the examples below to get a pictorial understanding of what this rule actually means.
13 | 
14 | # Example
15 | 
16 | # If input is 2, output will be
17 | 
18 | #  00006
19 | # 00028 00066
20 | 
21 | # If input is 3, output will be
22 | 
23 | #   00006
24 | #  00028 00066
25 | # 00120 00190 00276
26 | # Input Format
27 | 
28 | # First line of input will contain number N that corresponds to the width of the bottom-most layer of the Pyramid
29 | 
30 | # Constraints
31 | 
32 | # 0 < N <= 14
33 | 
34 | # Output Format
35 | 
36 | # The Pyramid constructed out of numbers in the series as per stated construction rules
37 | 
38 | # Sample Input 0
39 | 
40 | # 2
41 | # Sample Output 0
42 | 
43 | #  00006
44 | # 00028 00066
45 | # Sample Input 1
46 | 
47 | # 3
48 | # Sample Output 1
49 | 
50 | #   00006
51 | #  00028 00066
52 | # 00120 00190 00276
53 | 
54 | # Enter your code here. Read input from STDIN. Print output to STDOUT
55 | n=int(input())
56 | sum=0
57 | for i in range(n+1):
58 |     sum+=i
59 | l=[]
60 | l.append(6)
61 | for i in range(1,sum):
62 |     a=6+l[i-1]+16*(i)
63 |     l.append(a)
64 | # print(l)
65 | # print("{:05d}".format(x))
66 | t=0
67 | for i in range(n+1):
68 |     for j in range(n,i+1,-1):
69 |         print(" ",end='')
70 |     for k in range(i+1):
71 |         print("{:05d}".format(l[t]),end=' ')
72 |         t+=1
73 |     print()


--------------------------------------------------------------------------------
/Patterns/String Repetition.cpp:
--------------------------------------------------------------------------------
 1 | // String Repetition
 2 | 
 3 | // Given a string, find the smallest string that can generate the original string by concatenation. See example case for clarity.
 4 | 
 5 | // Input Format
 6 | 
 7 | // One string. String is guaranteed to contain lowercase letters only.
 8 | 
 9 | // Constraints
10 | 
11 | // 1 <= length of string <= 5000
12 | 
13 | // Output Format
14 | 
15 | // Print the smallest string that can be repeated to get the original string.
16 | 
17 | // Sample Input 0
18 | 
19 | // abababab
20 | // Sample Output 0
21 | 
22 | // ab
23 | 
24 | #include <cmath>
25 | #include <cstdio>
26 | #include <string>
27 | #include <cstring>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     string str,s1="",s2="";
37 |     int i,j;
38 |     cin>>str;
39 |     int len=str.length();
40 |     for(i=1;i<=len;i++)
41 |     {
42 |         s2="";
43 |         s1+=str[i-1];
44 |         for(j=0;j<len/i;j++)
45 |         {
46 |             s2+=s1;
47 |         }
48 |         if(s2==str)
49 |             break;
50 |     }
51 |     cout<<s1;
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/Patterns/SubwayRunners.cpp:
--------------------------------------------------------------------------------
 1 | // Subway Runners
 2 | 
 3 | // Arrnie is playing the new famous game Subway Runners.
 4 | // In this game there are three lanes and one starts from any one of the three lanes.
 5 | // Arrnie plays the game in the following manner :
 6 | // Switch(1,2)
 7 | // Switch(2,3)
 8 | // Switch(1,2)
 9 | // Switch(2,3).. and so on..
10 | 
11 | // Switch(x,y) is defined as follows :
12 | // if Arrnie is on lane x, he switches to lane y.
13 | // if Arrnie is on lany y, he switches to lane x.
14 | // if he is neither on lane x nor on y, he stays on the current lane.
15 | 
16 | // Given the current lane of Arrnie and the number of moves he has made, Print the number of the lane Arrnie started the game in.
17 | 
18 | // Input Format
19 | 
20 | // First line contains two integers n and x
21 | 
22 | // Constraints
23 | 
24 | // 1 <= n <= 2e9
25 | // 1 <= x <= 3
26 | 
27 | // Output Format
28 | 
29 | // Output the lane number thar Arrnie started the game in.
30 | 
31 | // Sample Input 0
32 | 
33 | // 4 3
34 | // Sample Output 0
35 | 
36 | // 2
37 | 
38 | #include <cmath>
39 | #include <cstdio>
40 | #include <vector>
41 | #include <iostream>
42 | #include <algorithm>
43 | using namespace std;
44 | 
45 | 
46 | int main() {
47 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
48 |     int n,c;
49 |     cin>>n>>c;
50 |     while(n>0)
51 |     {
52 |         if(n%2==0)
53 |         {
54 |             if(c==2)
55 |                 c=3;
56 |             else if(c==3)
57 |                 c=2;
58 |         }
59 |         else
60 |         {
61 |             if(c==1)
62 |                 c=2;
63 |             else if(c==2)
64 |                 c=1;
65 |         }
66 |         n--;
67 |     }
68 |     cout<<c;
69 |     return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/Pointers/Nested2DPointers.c:
--------------------------------------------------------------------------------
 1 | // 2D Array Using Pointer to Pointers
 2 | 
 3 | 
 4 | // In the last task we saw how to make a 2D array using an array of pointers.
 5 | 
 6 | // If we can make an array using pointers, we can also make this array of pointers using pointers. A pointer to a pointer thus formed is known as a double pointer.
 7 | 
 8 | // For example : to create a 2d array of dimensions 5x10 :
 9 | 
10 | // int **arr = (int**) malloc(sizeof(int*) * 5);
11 | // for (i = 0; i < 5; i++) arr[i] = (int*) malloc(sizeof(int) * 10);
12 | // We create an array of pointers by allocating memory equal to 5 pointers to a double pointer and then we allocate memory to each row.
13 | 
14 | // Note : A double pointer stores the location of a pointer which in turn stores a memory location of some data. To access this data the double pointer has to be dereferenced twice '**'
15 | 
16 | // For this task, write a program to create an array of strings using pointer of pointers.
17 | 
18 | // Take as input 5 strings in an array, concatenate all of them and print the resultant string.
19 | 
20 | // Hint : You can use a char** double pointer to create a 2d array of characters and use it as an array of strings.
21 | 
22 | // Sample Input 0
23 | 
24 | // Agumon
25 | // Gabumon
26 | // Gomamon
27 | // Patamon
28 | // Biyomon
29 | // Sample Output 0
30 | 
31 | // AgumonGabumonGomamonPatamonBiyomon
32 | 
33 | 
34 | #include<stdio.h>
35 | #include<string.h>
36 | #include<stdlib.h>
37 | int main()
38 | {
39 | 	char** str_arr;
40 | 	char* result; //don't forget to allocate sufficient memory to result string
41 | 	int i;
42 | 	//your code here
43 |     str_arr = (char**)malloc(sizeof(char*)*5);
44 |     result = (char*)malloc(sizeof(char)*200);
45 |     for(i=0;i<5;i++)
46 |         str_arr[i] = (char*)malloc(sizeof(char)*10);
47 |     for(i=0;i<5;i++)
48 |     {
49 |         gets(str_arr[i]); //,10,stdin);
50 |     }
51 | 	for (i = 0; i < 5; i++)
52 | 		strcat(result, str_arr[i]);
53 | 	puts(result);
54 | 	return 0;
55 | }


--------------------------------------------------------------------------------
/Pointers/PointerArrays2D.c:
--------------------------------------------------------------------------------
 1 | // 2D Array Using Pointers
 2 | 
 3 | // So far we saw how to use pointers to declare an array, but can we use pointers to declare a 2D array? The answer is yes.
 4 | 
 5 | // Recall that by allocating more memory to a pointer we created a linear array.
 6 | 
 7 | // What would happen if we created an array of pointers and allocated linear memory to each pointer in the array?
 8 | 
 9 | // int *arr[10];
10 | // for (i = 0; i < 10; i++) arr[i] = (int*) malloc(sizeof(int) * 10);
11 | // The above code would result in the creation of a 2D array of dimensions 10x10 since each pointer points to a row of size 10 and there are 10 such pointers.
12 | 
13 | // Similarly, to create an NxM matrix, we use :
14 | 
15 | // int *arr[N];
16 | // for (i = 0; i < N; i++) arr[i] = (int*) malloc(sizeof(int) * M);
17 | // To complete this task, write a program to take as input a square matrix of size NxN and print yes if the matrix is a diagonal matrix and no otherwise.
18 | 
19 | // A diagonal matrix is one all of whose elements except that lie on the diagonals are zero.
20 | 
21 | // Sample Input 0
22 | 
23 | // 3
24 | // 1 0 1
25 | // 0 2 0
26 | // 1 0 1
27 | // Sample Output 0
28 | 
29 | // yes
30 | // Sample Input 1
31 | 
32 | // 3
33 | // -1 0 1
34 | // 0 2 0
35 | // 1 0 1
36 | // Sample Output 1
37 | 
38 | // yes
39 | 
40 | 
41 | #include<stdio.h>
42 | #include<string.h>
43 | #include<stdlib.h> //this library contains the function malloc.
44 | int main()
45 | {
46 |     int i, j, N, flag=1;
47 |     scanf("%d", &N);
48 |     int *matrix[N];
49 |     for (i = 0; i < N; i++) matrix[i] = (int*) malloc(sizeof(int) * N);
50 |     for (i = 0; i < N; i++)
51 |     {
52 |         for (j = 0; j < N; j++)
53 |             scanf("%d", &matrix[i][j]);
54 |     }
55 |     //your code here
56 |     for(i=0;i<N;i++)
57 |     {
58 |         // flag=1;
59 |         for(j=0;j<N;j++)
60 |         {
61 |             if((i!=j) && (i+j!=N-1))
62 |             {
63 |                 // printf("checking if %d == 0 \n",matrix[i][j]);
64 |                 if(matrix[i][j]!=0)
65 |                 {
66 |                     // printf("nonzero element is %d \n",matrix[i][j]);
67 |                     printf("no");
68 |                     return 0;
69 |                 }
70 |             }
71 |         }
72 |     }
73 |     printf("yes");
74 |     return 0;
75 | }


--------------------------------------------------------------------------------
/Queue/DownToZero.cpp:
--------------------------------------------------------------------------------
 1 | // Down to Zero
 2 | 
 3 | // You are given Q queries. Each query consists of a single number N. You can perform any of the 2 operations on N in each move:
 4 | 
 5 | // 1: If we take 2 integers a and b where N = a x b (a!=1, b!=1), then we can change N = max(a,b)
 6 | 
 7 | // 2: Decrease the value of N by 1.
 8 | 
 9 | // Determine the minimum number of moves required to reduce the value of N to 0.
10 | 
11 | // Sample Input
12 | // 2
13 | // 3
14 | // 4
15 | 
16 | // Sample Output
17 | // 3
18 | // 3
19 | 
20 | // For test case 1, We only have one option that gives the minimum number of moves.
21 | // Follow 3 -> 2 -> 1 -> 0. Hence, 3 moves.
22 | 
23 | // For the case 2, we can either go 4 -> 3 -> 2 -> 1 -> 0 or 4 -> 2 -> 1 -> 0. The 2nd option is more optimal. Hence, 3 moves.
24 | 
25 | int main() 
26 | {
27 |     int max=1000001;
28 |     int i, j, nums[max];
29 |     
30 |     //Initializing the array
31 |     for(i=0;i<max;i++) 
32 |         nums[i] = -1;
33 |     nums[0] = 0;
34 |     nums[1] = 1;
35 |     nums[2] = 2;
36 |     nums[3] = 3;
37 |     
38 |     for(i=0;i<max;i++)
39 |     {
40 |         if(nums[i]==-1 || nums[i]>(nums[i-1]+1))
41 |             nums[i]=nums[i-1]+1;
42 |         for(j=1; j<=i && j*i<max; j++)
43 |             if(nums[j*i]==-1 || (nums[i]+1)<nums[j*i])
44 |                 nums[j*i]=nums[i]+1;
45 |     }
46 |     
47 |     int q;
48 |     cin>>q;
49 |     for(i=0; i<q; i++)
50 |     {
51 |         int n;
52 |         cin>>n;
53 |         cout<<nums[n]<< endl;
54 |     }
55 |     return 0;
56 | }


--------------------------------------------------------------------------------
/Queue/StackUsingQueues.cpp:
--------------------------------------------------------------------------------
 1 | // Implement Stack using Queues
 2 | // The problem is opposite of this post. We are given a Queue data structure that supports standard operations like enqueue() and dequeue(). We need to implement a Stack data structure using only instances of Queue and queue operations allowed on the instances.
 3 | 
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | #include <queue>
 7 | using namespace std;
 8 | 
 9 | struct Stack
10 | {
11 |     queue<int> q1;
12 |     queue<int> q2;
13 |     
14 |     void enque(int x)
15 |     {
16 |         q2.push(x);
17 |         while(!q1.empty())
18 |         {
19 |             q2.push(q1.front());
20 |             q1.pop();
21 |         }
22 |         queue<int> temp = q1;
23 |         q1 = q2;
24 |         q2 = temp;
25 |     }
26 |     
27 |     int dequeue()
28 |     {
29 |         // int x;
30 |         // while(!q1.empty())
31 |         // {
32 |         //     x = q1.front();
33 |         //     q1.pop();
34 |         // }
35 |         // return x;
36 |         return q1.back();
37 |     }
38 | };
39 | 
40 | int main()
41 | {
42 |     struct Stack s;
43 |     s.enque(1);
44 |     s.enque(2);
45 |     s.enque(3);
46 |     s.enque(4);
47 |     s.enque(5);
48 |     
49 |     cout<<"\nElement removed is: "<<s.dequeue();
50 |     cout<<"\nElement removed is: "<<s.dequeue();
51 |     cout<<"\nElement removed is: "<<s.dequeue();
52 |     
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Recursion/Fibonacci.py:
--------------------------------------------------------------------------------
 1 | # Fibonacci Series is the sequence where every term is the sum of 2 previous terms.
 2 | # Formally, Fn = Fn-1 + Fn-2
 3 | # with F0 = 0 and F1 = 1.
 4 | 
 5 | # Your task is for a given number N print the Nth Fibonacci number.
 6 | # You must use recursion to find the fibonacci number.
 7 | 
 8 | # Input Format
 9 | 
10 | # One number N.
11 | 
12 | # Constraints
13 | 
14 | # 0 <= N <= 12
15 | 
16 | # Output Format
17 | 
18 | # One number Fn.
19 | 
20 | # Sample Input
21 | # 0
22 | 
23 | # Sample Output
24 | # 0
25 | 
26 | 
27 | fibl = [0, 1]
28 | 
29 | 
30 | def fib(a, b, n):
31 |     if(len(fibl) < n + 1):
32 |         fibl.append(a + b)
33 |         fib(fibl[-1], fibl[-2], n)
34 | 
35 | 
36 | n = int(input())
37 | fib(fibl[-1], fibl[-2], n)
38 | print(fibl[n])
39 | 


--------------------------------------------------------------------------------
/Recursion/JumpingOnClouds.py:
--------------------------------------------------------------------------------
 1 | # Jumping on the Clouds
 2 | 
 3 | # https://www.hackerrank.com/challenges/jumping-on-the-clouds/problem
 4 | 
 5 | # Emma is playing a new mobile game that starts with consecutively numbered clouds.
 6 | # Some of the clouds are thunderheads and others are cumulus.
 7 | # She can jump on any cumulus cloud having a number that is equal to the number of the current cloud plus 1 or 2. She must avoid the thunderheads. Determine the minimum number of jumps it will take Emma to jump from her starting postion to the last cloud. It is always possible to win the game.
 8 | 
 9 | # For each game, Emma will get an array of clouds numbered 0 if they are safe or 1 if they must be avoided.
10 | # For example, c = [0,1,0,0,0,1,0] indexed from 0..6. The number on each cloud is its index in the list so she must avoid the clouds at indexes 1 and 5. The first path takes 3 jumps while the second takes 4.
11 | 
12 | # Function Description
13 | 
14 | # Complete the jumpingOnClouds function in the editor below.
15 | # It should return the minimum number of jumps required, as an integer.
16 | 
17 | # jumpingOnClouds has the following parameter(s):
18 | 
19 | # c: an array of binary integers
20 | # Input Format
21 | 
22 | # The first line contains an integer n, the total number of clouds.
23 | # The second line contains n space-separated binary integers describing clouds c[i] where 0<=i<n.
24 | 
25 | # Output Format
26 | 
27 | # Print the minimum number of jumps needed to win the game.
28 | 
29 | # Sample Input 0
30 | 
31 | # 7
32 | # 0 0 1 0 0 1 0
33 | # Sample Output 0
34 | 
35 | # 4
36 | 
37 | import os
38 | 
39 | 
40 | def jumpingOnClouds(c):
41 |     if(len(c) == 2):
42 |         return 1
43 |     if(len(c) == 1):
44 |         return 0
45 |     if(c[2] == 0):
46 |         return 1 + jumpingOnClouds(c[2:])
47 |     else:
48 |         return 1 + jumpingOnClouds(c[1:])
49 | 
50 | 
51 | 
52 | if __name__ == '__main__':
53 |     fptr = open(os.environ['OUTPUT_PATH'], 'w')
54 | 
55 |     n = int(input())
56 | 
57 |     c = list(map(int, input().rstrip().split()))
58 | 
59 |     result = jumpingOnClouds(c)
60 | 
61 |     fptr.write(str(result) + '\n')
62 | 
63 |     fptr.close()
64 | 


--------------------------------------------------------------------------------
/Recursion/MinimumNumberFunction.cpp:
--------------------------------------------------------------------------------
 1 | // Minimum Number Function
 2 | 
 3 | // Input Format
 4 | 
 5 | // The input contains a single integer n (the number of integers to be compared).
 6 | 
 7 | // Constraints
 8 | 
 9 | // 2 <= n <= 50
10 | 
11 | // Output Format
12 | 
13 | // Print the string on a single line. Each integer in the string should be written as 'int' and the string must accurately show how min functions can be called to find the smallest of n integers.
14 | 
15 | // Sample Input 0
16 | // 2
17 | 
18 | // Sample Output 0
19 | // min(int, int)
20 | 
21 | 
22 | // Sample Input 1
23 | // 4
24 | 
25 | // Sample Output 1
26 | // min(int, min(int, min(int, int)))
27 | 
28 | #include <cmath>
29 | #include <cstdio>
30 | #include <vector>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | string min(int n)
36 | {
37 |     if(n==1)
38 |         return "int";
39 |     else
40 |         return "min(int, " + min(n-1) + ")"; 
41 | }
42 | 
43 | int main() {
44 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
45 |     int n,i;
46 |     cin>>n;
47 |     cout<<min(n);
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/Recursion/RecursiveInsertionSort.py:
--------------------------------------------------------------------------------
 1 | #Problem Name
 2 | ## Sorting array using recursion
 3 | 
 4 | #Problem Description
 5 | ## The problem is sorting an array using recursion.
 6 | 
 7 | #INPUT:
 8 | ## an unsorted array.
 9 | 
10 | #OUTPUT:
11 | ## Sorted array
12 | 
13 | #CONSTRAINTS:
14 | ## Recursive inseration sort gives complexity of O(n^2) which is not efficient as compared to merge sort 0(nlogn)
15 | 
16 | #Sample input:
17 | ## [12,11,13,5,6]
18 | #Sample output:
19 | ## [6,5,11,12,13]
20 | 
21 | arr = [12,11,13,5,6]
22 | n = len(arr)
23 | insertionSortRecursive(arr, n)
24 | printArray(arr, n)
25 | 
26 | def insertionSortRecursive(arr,n):
27 |     if n<=1:
28 |         return
29 |     # Sort first n-1 elements 
30 |     insertionSortRecursive(arr,n-1)
31 |     last = arr[n-1]
32 |     j = n-2
33 |     
34 |     # Move elements of arr[0..i-1], that are 
35 |     # greater than key, to one position ahead 
36 |     # of their current position  
37 |     while (j>=0 and arr[j]>last):
38 |         arr[j+1] = arr[j]
39 |         j = j-1
40 |     arr[j+1]=last
41 |      
42 | # a function that prints array of certain size
43 | def printArray(arr,n):
44 |     for i in range(n):
45 |         print arr[i],
46 | 


--------------------------------------------------------------------------------
/Recursion/SumOfAllDigits.cpp:
--------------------------------------------------------------------------------
 1 | // Sum of all Digits
 2 | 
 3 | // You are given an integer I in the following format : 
 4 | // You are given two integers P and Q. 
 5 | // Integer I can be obtained by appending Q instances of P together. 
 6 | // For example, if P = 619 and Q = 4, then I = 619619619619.
 7 | 
 8 | // Your task is, given P and Q find the sum of all the digits of I.
 9 | // That sounds too simple, so lets take it up a notch.
10 | // Lets say the sum of all digits is S, then run the following pseudocode : 
11 | 
12 | // int SumOfDigits(S) :
13 | // 	K <- Sum of Digits of S
14 | //     if K is a single digit number, return K
15 | //     else return SumOfDigits(K)
16 | // INPUT
17 | // Input consist of two numbers P and Q separated by a space.
18 | 
19 | // OUTPUT
20 | // Print a single digit, the final digit when the numbers of I are continuously added.
21 | 
22 | // CONSTRAINTS
23 | // 1 ≤ P ≤ 10100000 
24 | // **1 ≤ Q ≤ **105 
25 | 
26 | // Sample Input 0
27 | 
28 | // 148 3
29 | // Sample Output 0
30 | 
31 | // 3
32 | 
33 | #include <cmath>
34 | #include <cstdio>
35 | #include <vector>
36 | #include <iostream>
37 | #include <algorithm>
38 | using namespace std;
39 | 
40 | long int sumofdigits(long int n)
41 | {
42 |     int d;
43 |     d=n%10;
44 |     if(n<10)
45 |         return d;
46 |     else
47 |         return d+sumofdigits(n/10); 
48 | }
49 | 
50 | long int sumuptosingledigit(long int n)
51 | {
52 |     int k=sumofdigits(n);
53 |     if(k<10)
54 |         return k;
55 |     else
56 |         return sumofdigits(k);
57 | }
58 | 
59 | int main() {
60 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
61 |     long int m,n;
62 |     cin>>n;
63 |     cin>>m;
64 |     int sum1=sumofdigits(n);
65 |     cout<<sumuptosingledigit(sum1*m);
66 |     return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/Recursion/SumOfAllDigits.py:
--------------------------------------------------------------------------------
 1 | # You are given an integer I in the following format :
 2 | # You are given two integers P and Q.
 3 | # Integer I can be obtained by appending Q instances of P together.
 4 | # For example, if P = 619 and Q = 4, then I = 619619619619.
 5 | 
 6 | # Your task is, given P and Q find the sum of all the digits of I.
 7 | # That sounds too simple, so lets take it up a notch.
 8 | # Lets say the sum of all digits is S, then run the following pseudocode :
 9 | 
10 | # int SumOfDigits(S) :
11 | #     K <- Sum of Digits of S
12 | #     if K is a single digit number, return K
13 | #     else return SumOfDigits(K)
14 | 
15 | # INPUT
16 | # Input consist of two numbers P and Q separated by a space.
17 | 
18 | # OUTPUT
19 | # Print a single digit, the final digit when the numbers of I are continuously added.
20 | 
21 | # CONSTRAINTS
22 | # 1 ≤ P ≤ 10^100000
23 | # **1 ≤ Q ≤ **10^5
24 | 
25 | # Sample Input
26 | # 148 3
27 | 
28 | # Sample Output
29 | # 3
30 | 
31 | 
32 | a, b = map(int, input().split())
33 | 
34 | 
35 | def sumDigits(n):
36 |     tot = 0
37 |     while(n > 0):
38 |         tot += n % 10
39 |         n //= 10
40 |     return tot
41 | 
42 | 
43 | def sumOfDigits(n):
44 |     k = sumDigits(n)
45 |     if k > 9:
46 |         return sumOfDigits(k)
47 |     else:
48 |         return k
49 | 
50 | 
51 | num = sumDigits(a) * b
52 | print(sumOfDigits(num))
53 | 


--------------------------------------------------------------------------------
/Recursion/Tower_of_Hanoi.c:
--------------------------------------------------------------------------------
 1 | /* Tower of Hanoi is a mathematical puzzle whit three rods and n number of disks.
 2 | 
 3 |  The objective of this puzzle is to move the entire stack from one rod to another rod 
 4 |  with the help of the third rod. 
 5 |  
 6 |  These are the following simple rules of the puzzle:
 7 | 
 8 | 1. We can only move one disk at a time.
 9 | 
10 | 2. We can only move the upper most disk from one of the stacks and placing it on top of another stack.
11 | 
12 | 3. Disks should be placed in ascending order i.e. uppermost most disk should be the smallest and 
13 | the lowermost should be the largest disk.
14 | 
15 | OUTPUT:
16 | 
17 | (If we take number of disks 3 then the output of the program will be following: )
18 | 
19 | Enter the number of disk:3 
20 | A to C
21 | A to B
22 | C to B
23 | A to C
24 | B to A
25 | B to C
26 | A to C
27 | 
28 | (If we take number of disks 2 then the output of the program will be following: )
29 | 
30 | Enter the number of disk:2
31 | A to B
32 | A to C
33 | B to C
34 | */
35 | 
36 | #include <stdio.h>
37 | #include <stdlib.h>
38 | void TOH(int n,char A,char B,char C)
39 | {
40 | 	if(n==1)
41 | 	{
42 | 		printf("%c to %c\n",A,C); //if the number of disk is one in that case we can directly move the disk from A to C
43 | 	}
44 | 	else
45 |     /* if the number of disks is greater than one in that case, we will 1st move the (n-1) Disks from rod A to rod B with
46 |             the help of the Rod C then we will move the remaining one disk from rod A to rod C then finally we will move 
47 |             (n-1) disks from rod B to rod C */
48 | 	{
49 | 
50 | 		TOH(n-1,A,C,B); //recursive call
51 | 		TOH(1,A,B,C);
52 | 		TOH(n-1,B,A,C);
53 | 	}
54 | }
55 | int main(void)
56 | {
57 | 	int n;
58 | 	char c1 = 'A', c2 ='B', c3 = 'C';
59 | 	printf("Enter the number of disk:");
60 | 	scanf("%d",&n);
61 | 	TOH(n,c1,c2,c3);
62 | 	return 0;
63 | }


--------------------------------------------------------------------------------
/Recursion/combinationStrings.cpp:
--------------------------------------------------------------------------------
 1 | //Given an input string of numbers, find all combinations of numbers that can be formed using digits in the same order.
 2 | 
 3 | 
 4 | //Sample input:
 5 | // '1214'
 6 | // Output:
 7 | // 1214
 8 | //121 4
 9 | //12 14
10 | //12 1 4
11 | //1 214
12 | //1 21 4
13 | //1 2 14
14 | //1 2 1 4
15 | 
16 | 
17 | //Sample Input:
18 | //'123'
19 | //Output:
20 | //123
21 | //12 3
22 | //1 23
23 | //1 2 3
24 | 
25 | 
26 | 
27 | 
28 | 
29 | #include<iostream>
30 | #include<string>
31 | using namespace std;
32 | 
33 | void comb(string input,int i,string output)
34 | {
35 | 	if(i==input.length())
36 | 	{
37 | 		cout<<output<<"\n";
38 | 		return;
39 | 	}
40 | 	output+=input[i];
41 | 	comb(input,i+1,output);
42 | 	if(i+1!=input.length())
43 | 	{
44 | 		output+=' ';
45 | 		comb(input,i+1,output);
46 | 	}
47 | }
48 | 
49 | int main()
50 | {
51 | 	string input,output;
52 | 	cout<<"Enter the string"<<" ";
53 | 	cin>>input;
54 | 	cout<<"\n";
55 | 	output="";
56 | 	int len = 0;
57 | 	comb(input,0,output);
58 | }


--------------------------------------------------------------------------------
/Recursion/gcd.cpp:
--------------------------------------------------------------------------------
 1 | //Finding the Greatest Common Divisor using C++
 2 | 
 3 | #include<iostream>
 4 | using namespace std;
 5 | 
 6 | int gcd(int a, int b) {
 7 |    if (b == 0){
 8 |    	return a;
 9 |    } 
10 |    return gcd(b, a % b);
11 | }
12 | 
13 | int main() {
14 |    int a = 92, b = 36;
15 |    cout<<"GCD of "<< a <<" and "<< b <<" is "<< gcd(a, b) << endl;
16 |    return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/Recursion/powersum.cpp:
--------------------------------------------------------------------------------
 1 | //Find the number of ways that a given integer,x, can be expressed as the sum of the nth powers of unique, natural numbers.
 2 | //For example, if x=13 and n=2, we have to find all combinations of unique squares adding up to 13. The only solution is 2^2+3^2.
 3 | //Problem link:- https://www.hackerrank.com/challenges/the-power-sum/problem
 4 | 
 5 | 
 6 | // Sample Input:
 7 | // x=10, n=2
 8 | // Output:
 9 | // 1 (1^2+3^2)
10 | 
11 | // Sample Input:
12 | // x=100, n=3
13 | // Output
14 | // 1 (1^3+2^3+3^3+4^3)
15 | 
16 | 
17 | 
18 | 
19 | 
20 | 
21 | #include<bits/stdc++.h>
22 | using namespace std;
23 | 
24 | int ps(int x,int n,int index)
25 | {
26 | 	//Return value of "pow" function is float and subtracting a float from an integer will not guarantee correct value. 
27 | 	//That is why the value after subtracting is stored inside an int variable. 
28 | 	//If you write '(x - pow(index, n))' in place of 'value' while calling the function, it will give you an error
29 | 	//because subtract will start getting float values.
30 | 	int value = (x - pow(index, n));
31 | 	if(value<0)
32 |     	return 0;
33 | 	else if(value==0)
34 |     	return 1;
35 |     //At each value, you have two options. 1. Choose that value 2. Skip that value.
36 |     //If you choose it then call the function after subtracting pow(index,n) from x
37 |     //if you don't choose it, then call the funtion with same x value but incrementing x.
38 |     else 
39 |     	return ps(x,n,index+1) + ps(value,n,index+1);
40 | }
41 | 
42 | int main()
43 | {
44 | 	int x,n;
45 | 	cin>>x;
46 | 	cin>>n;
47 | 	int c=ps(x,n,1);
48 | 	cout<<c<<"\n";
49 | 	return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/Recursion/rat-in-a-maze-CPP.cpp:
--------------------------------------------------------------------------------
 1 | /*Solution to the Rat in a maze problem by recursion in CPP.
 2 | 
 3 | Problem- In this problem, there is a given maze . The source and the destination location is top-left cell and bottom right cell respectively.
 4 | Some cells are valid to move and some cells are blocked. If one rat starts moving from start vertex to destination vertex, we have to find 
 5 | that is there any way to complete the path, if it is possible then mark the correct path for the rat.
 6 | The maze is given using a matrix, where it is marked with 0, it is a valid path, otherwise X for a blocked cell.
 7 | NOTE: The rat can only move in two directions, either to the right or to the down.
 8 | */
 9 | 
10 | //Solution:
11 | 
12 | #include<iostream>
13 | using namespace std;
14 | 
15 | bool RatInMaze(char maze[][100],int sol[100][100],int i,int j,int n,int m){
16 |     // Base case
17 |     if(i==n-1 && j==m-1){
18 |         // Print the path
19 |         sol[i][j] = 1;
20 |         for(int i=0;i<n;i++){
21 |             for(int j=0;j<m;j++){
22 |                 cout<<sol[i][j]<<' ';
23 |             }
24 |             cout<<endl;
25 |         }
26 |         cout<<endl;
27 |         return false;
28 |     }
29 | 
30 |     sol[i][j] = 1;
31 | 
32 |     // Check right
33 |     if(j+1<m && maze[i][j+1]!='X'){
34 |         bool right = RatInMaze(maze,sol,i,j+1,n,m);
35 |         if(right == true){
36 |             return true;
37 |         }
38 |     }
39 | 
40 |     // Check down
41 |     if(i+1<n && maze[i+1][j]!='X'){
42 |         bool down = RatInMaze(maze,sol,i+1,j,n,m);
43 |         if(down){
44 |             return true;
45 |         }
46 |     }
47 | 
48 |     sol[i][j] = 0;
49 |     return false;
50 | }
51 | 
52 | 
53 | char maze[100][100];
54 | int sol[100][100]={0};
55 | int main(){
56 |        int n,m;
57 |        string str;
58 |        cout << "Enter maze length: ";
59 |        cin >> m;
60 |        cout << "Enter maze breadth: ";
61 |        cin >> n;
62 |        for(int i=0;i<n;i++){
63 | 	       cout << "Enter maze row(Should be equal to maze-breadth): ";
64 | 	       cin >> str;
65 |            for(int j=0;j<str.length();j++){
66 |                maze[i][j] = str[j];
67 |            }
68 |        }
69 |    
70 |     /* char maze[5][5]={
71 |         "0000",
72 |         "00XX",
73 |         "0000",
74 |         "XX00"
75 |     };
76 |     */
77 |     
78 |     RatInMaze(maze,sol,0,0,n,m);
79 | 
80 | 
81 |     return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/Sorting Techniques/DateSorting.cpp:
--------------------------------------------------------------------------------
  1 | // Date Sorting 
  2 | 
  3 | // Sort the given dates of the format
  4 | // DD MM YYYY 
  5 | // in ascending order
  6 | 
  7 | #include <map>
  8 | #include <set>
  9 | #include <list>
 10 | #include <cmath>
 11 | #include <ctime>
 12 | #include <deque>
 13 | #include <queue>
 14 | #include <stack>
 15 | #include <string>
 16 | #include <bitset>
 17 | #include <cstdio>
 18 | #include <limits>
 19 | #include <vector>
 20 | #include <climits>
 21 | #include <cstring>
 22 | #include <cstdlib>
 23 | #include <fstream>
 24 | #include <numeric>
 25 | #include <sstream>
 26 | #include <iostream>
 27 | #include <algorithm>
 28 | #include <unordered_map>
 29 | 
 30 | void swap(int *x, int *y)
 31 | {
 32 |     int temp = *x;
 33 |     *x = *y;
 34 |     *y = temp;
 35 | }
 36 | 
 37 | using namespace std;
 38 | int main() {
 39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
 40 |     int n,i,j;
 41 |     cin>>n;
 42 |     int d[n],m[n],y[n];
 43 |     for(i=0;i<n;i++)
 44 |         cin>>d[i]>>m[i]>>y[i];
 45 |     for(i=0;i<n-1;i++)
 46 |     {
 47 |         for(j=0;j<n-i-1;j++)
 48 |         {
 49 |             if(y[j]>y[j+1])
 50 |             {
 51 |                 swap(y[j],y[j+1]);
 52 |                 swap(m[j],m[j+1]);
 53 |                 swap(d[j],d[j+1]);
 54 |             }
 55 |         }
 56 |     }
 57 |     for(i=0;i<n;i++)
 58 |     {
 59 |         for(j=0;j<n;j++)
 60 |         {
 61 |             if(y[i]==y[j] && m[j]>m[i])
 62 |             {
 63 |                 swap(m[i],m[j]);
 64 |                 swap(d[i],d[j]);
 65 |             }
 66 |         }
 67 |     }
 68 |     for(i=0;i<n;i++)
 69 |     {
 70 |         for(j=0;j<n;j++)
 71 |         {
 72 |             if(y[i]==y[j] && m[j]==m[i] && d[j]>d[i])
 73 |             {
 74 |                 swap(d[i],d[j]);
 75 |             }
 76 |         }
 77 |     }
 78 |     // for(i=0;i<n-1;i++)
 79 |     // {
 80 |     //     if(y[i]==y[i+1])
 81 |     //     {
 82 |     //         swap(m[i],m[i+1]);
 83 |     //         swap(d[i],d[i+1]);
 84 |     //     }
 85 |     // }
 86 |     // for(i=0;i<n-1;i++)
 87 |     // {
 88 |     //     for(j=0;j<n;j++)
 89 |     //     {
 90 |     //         if(y[i]==y[i+1] && m[i]==m[i+1])
 91 |     //         {
 92 |     //             swap(d[i],d[i+1]);
 93 |     //         }
 94 |     //     }
 95 |     // }
 96 |     for(i=0;i<n;i++)
 97 |         cout<<d[i]<<" "<<m[i]<<" "<<y[i]<<endl;    
 98 |     
 99 |     return 0;
100 | }
101 | 
102 | 


--------------------------------------------------------------------------------
/Sorting Techniques/Structures date sorting.cpp:
--------------------------------------------------------------------------------
 1 | // Given a number of dates, sort them in such a way that the date that corresponds to the earliest day comes first and the date that corresponds to the latest day comes last.
 2 | 
 3 | // Input Format
 4 | 
 5 | // First line contains N, the number of dates. 
 6 | // Next N lines contain one date each in the following format : 
 7 | // DD MM YYYY.
 8 | // The date will be three integers separated by a space where the first integer is the day, the second integer is the month and the third is the year.
 9 | 
10 | // Constraints
11 | 
12 | // 1 <= N <= 100 
13 | // It is guaranteed that the date will be a valid date. 
14 | 
15 | // Output Format
16 | 
17 | // Output N lines. Each line must contain one date. The dates must appear in a sorted format.
18 | 
19 | // Sample Input 0
20 | 
21 | // 4
22 | // 9 8 1996
23 | // 31 4 1995
24 | // 30 4 1996
25 | // 25 12 1997
26 | // Sample Output 0
27 | 
28 | // 31 4 1995
29 | // 30 4 1996
30 | // 9 8 1996
31 | // 25 12 1997
32 | 
33 | 
34 | #include <stdio.h>
35 | #include <string.h>
36 | #include <math.h>
37 | #include <stdlib.h>
38 | typedef struct date date;
39 | struct date
40 | {
41 |     int day;
42 |     int month;
43 |     int year;
44 | };
45 | int main() {
46 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
47 |     int n,i,j;
48 |     scanf("%d",&n);
49 |     date arr[n],temp;
50 |     for(i=0;i<n;i++)
51 |         scanf("%d %d %d",&arr[i].day,&arr[i].month,&arr[i].year);
52 |     for(i=0;i<n-1;i++)
53 |     {
54 |         for(j=0;j<n-i-1;j++)
55 |         {
56 |             if(arr[j].year > arr[j+1].year)
57 |             {
58 |                 temp = arr[j];
59 |                 arr[j]=arr[j+1];
60 |                 arr[j+1]=temp;
61 |             }
62 |             else if((arr[j].year == arr[j+1].year) && (arr[j].month > arr[j+1].month))
63 |             {
64 |                 temp = arr[j];
65 |                 arr[j]=arr[j+1];
66 |                 arr[j+1]=temp;
67 |             }
68 |             else if((arr[j].month == arr[j+1].month) && (arr[j].day > arr[j+1].day))
69 |             {
70 |                 temp = arr[j];
71 |                 arr[j]=arr[j+1];
72 |                 arr[j+1]=temp;
73 |             }
74 |         }
75 |     }
76 |     for(i=0;i<n;i++)
77 |     {
78 |         printf("%d %d %d",arr[i].day,arr[i].month,arr[i].year);
79 |         printf("\n");
80 |     }
81 |     return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/Stacks/BalancedParenthesis.cpp:
--------------------------------------------------------------------------------
 1 | // Check for balanced parentheses in an expression
 2 | 
 3 | // Given an expression string exp , write a program to examine whether the pairs and the orders of “{“,”}”,”(“,”)”,”[“,”]” are correct in exp.
 4 | 
 5 | // Example:
 6 | 
 7 | // Input: exp = “[()]{}{[()()]()}”
 8 | // Output: Balanced
 9 | 
10 | // Input: exp = “[(])”
11 | // Output: Not Balanced
12 | 
13 | 
14 | #include <iostream>
15 | #include <string>
16 | #include <stack>
17 | using namespace std;
18 | 
19 | int parenthesis(string s)
20 | {
21 |     stack<char> st;
22 |     int l = s.length();
23 |     int i;
24 |     char ch;
25 |     for(i=0;i<l;i++)
26 |     {
27 |         if(s[i]=='(' || s[i]=='{' || s[i]=='[')
28 |         {    
29 |             st.push(s[i]);
30 |             continue;
31 |         }
32 |         
33 |         if(st.empty())
34 |             return 0;
35 |         
36 |         switch(s[i])
37 |         {
38 |             case ')':   ch = st.top();
39 |                         st.pop();
40 |                         if(ch!='(')
41 |                         {
42 |                             return 0;
43 |                         }
44 |                         break;
45 |             
46 |             case '}':   ch = st.top();
47 |                         st.pop();
48 |                         if(ch!='{')
49 |                         {
50 |                             return 0;
51 |                         }
52 |                         break;
53 |             
54 |             case ']':   ch = st.top();
55 |                         st.pop();
56 |                         if(ch!='[')
57 |                         {
58 |                             return 0;
59 |                         }
60 |                         break;
61 |                         
62 |         }
63 |     }
64 |     if(st.empty())
65 |         return 1;
66 |     else
67 |         return 0;
68 | }
69 | 
70 | int main()
71 | {
72 |     cout<<"Hello World"<<endl;
73 |     string expr = "(){}[]";
74 |     cout<<parenthesis(expr)<<endl;
75 |     string expression = "({)}[]";
76 |     cout<<parenthesis(expression)<<endl;    
77 |     return 0;
78 | }
79 | 


--------------------------------------------------------------------------------
/Stacks/HistogramArea.cpp:
--------------------------------------------------------------------------------
 1 | // Largest Rectangular Area in a Histogram
 2 | 
 3 | // Find the largest rectangular area possible in a given histogram where the largest rectangle can be made of a number of contiguous bars.
 4 | 
 5 | #include <iostream>
 6 | #include <algorithm>
 7 | #include <vector>
 8 | #include <stack>
 9 | using namespace std;
10 | 
11 | int maxHistogram(vector<int> v)
12 | {
13 |     int maxArea = 0;
14 |     int area = 0;
15 |     int i;
16 |     int top;
17 |     stack<int> s;
18 |     
19 |     for(i=0;i<v.size();)
20 |     {
21 |         if(s.empty() || v[i]>=v[s.top()])
22 |         {
23 |             s.push(i++);
24 |         }
25 |         else
26 |         {
27 |             top = s.top();
28 |             s.pop();
29 |             
30 |             if(s.empty())
31 |                 area=v[top]*i;
32 |             else
33 |                 area=v[top]*(i-s.top()-1);
34 |             
35 |             if(area>maxArea)
36 |                 maxArea = area;
37 |         }
38 |     }
39 |     while(s.empty() == false)
40 |     {
41 |         top = s.top();
42 |         s.pop();
43 |         if(s.empty())
44 |             area=v[top]*i;
45 |         else
46 |             area=v[top]*(i-s.top()-1);
47 |         
48 |         if(area>maxArea)
49 |             maxArea = area;
50 |     }
51 |     return maxArea;
52 | }
53 | 
54 | int main() 
55 | { 
56 |     vector<int> v = {6, 2, 5, 4, 5, 1, 6}; 
57 |     cout << "Maximum area is " << maxHistogram(v); 
58 |     return 0; 
59 | }


--------------------------------------------------------------------------------
/Stacks/MaxElementInStackArrays.c:
--------------------------------------------------------------------------------
 1 | // You are given N queries:-
 2 | // 1. X- Push the element X at top of the stack
 3 | // 2. Delete the element at top of the stack
 4 | // 3. Print the maximum element of the stack
 5 | 
 6 | // Input Format:- 
 7 | // N, N lines  follows each query
 8 | 
 9 | // Output format:- 
10 | // Print max element for each query of type 3
11 | 
12 | // Sample Input 0
13 | 
14 | // 10
15 | // 1 97
16 | // 2
17 | // 1 20
18 | // 2
19 | // 1 26
20 | // 1 20
21 | // 2
22 | // 3
23 | // 1 91
24 | // 3
25 | // Sample Output 0
26 | 
27 | // 26
28 | // 91
29 | 
30 | #include <stdio.h>
31 | #include <string.h>
32 | #include <math.h>
33 | #include <stdlib.h>
34 | 
35 | int main() {
36 |     int n,x,r;
37 |     int a[100000],at=-1,b[100000],bt=-1;
38 |     scanf("%d",&n);
39 |     
40 |     while(n--)
41 |     {
42 |       scanf("%d",&x);
43 |         
44 |         switch(x)
45 |         {
46 |             case 1: scanf("%d",&a[++at]);
47 |                 if(bt==-1 || b[bt]<=a[at])
48 |                     b[++bt]=a[at];
49 |                 break;
50 |             case 2:
51 |                 if(a[at--]==b[bt]) bt--;
52 |                 break;
53 |             case 3:
54 |                 printf("%d\n",b[bt]);
55 |         }
56 |     }
57 |     return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/Stacks/MaxElementInStackLinkedLists.c:
--------------------------------------------------------------------------------
  1 | // You are given N queries:-
  2 | // 1. X- Push the element X at top of the stack
  3 | // 2. Delete the element at top of the stack
  4 | // 3. Print the maximum element of the stack
  5 | 
  6 | // Input Format:- 
  7 | // N, N lines  follows each query
  8 | 
  9 | // Output format:- 
 10 | // Print max element for each query of type 3
 11 | 
 12 | // Sample Input 0
 13 | 
 14 | // 10
 15 | // 1 97
 16 | // 2
 17 | // 1 20
 18 | // 2
 19 | // 1 26
 20 | // 1 20
 21 | // 2
 22 | // 3
 23 | // 1 91
 24 | // 3
 25 | // Sample Output 0
 26 | 
 27 | // 26
 28 | // 91
 29 | 
 30 | #include <stdio.h>
 31 | #include <string.h>
 32 | #include <math.h>
 33 | #include <stdlib.h>
 34 | typedef struct node stack;
 35 | struct node
 36 | {
 37 |     int data;
 38 |     stack *next;
 39 | }*top,*top1;
 40 | int max;
 41 | void insert(int val)
 42 | {
 43 |     stack *new=(stack *)malloc(sizeof(stack));
 44 |     new->data = val;
 45 |     if(top==NULL)
 46 |     {
 47 |         new->next=NULL;
 48 |         top=new;
 49 |         stack *new1=(stack *)malloc(sizeof(stack));
 50 |         new1->data=val;
 51 |         new1->next=NULL;
 52 |         top1=new1;
 53 |         max=new1->data;
 54 |     }
 55 |     else
 56 |     {
 57 |         new->next=top;
 58 |         top=new;
 59 |         if(top->data >= max)
 60 |         {
 61 |             stack *new1=(stack *)malloc(sizeof(stack));
 62 |             new1->data = top->data;
 63 |             new1->next=top1;
 64 |             top1=new1;
 65 |         }
 66 |     }
 67 | }
 68 | 
 69 | void pop()
 70 | {
 71 |     stack *ptr=top;
 72 |     top=top->next;
 73 |     if(ptr->data == top1->data)
 74 |     {
 75 |         stack *ptr1=top1;
 76 |         top1=top1->next;
 77 |         free(ptr1);
 78 |     }
 79 |     free(ptr);
 80 | }
 81 | 
 82 | int findmax()
 83 | {
 84 |     return top1->data;
 85 | }
 86 | int main() {
 87 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
 88 |     int n;
 89 |     scanf("%d",&n);
 90 |     int choice,val;
 91 |     while(n--)
 92 |     {
 93 |         scanf("%d",&choice);
 94 |         if(choice==1)
 95 |         {
 96 |             scanf("%d",&val);
 97 |             insert(val);
 98 |         }
 99 |         else if(choice==2)
100 |         {
101 |             pop();
102 |         }
103 |         else if(choice==3)
104 |         {
105 |             max=findmax();
106 |             printf("%d\n",max);
107 |         }
108 |     }
109 |     return 0;
110 | }
111 | 


--------------------------------------------------------------------------------
/Stacks/ParenthesisDepth.cpp:
--------------------------------------------------------------------------------
 1 | // Find maximum depth of nested parenthesis in a string
 2 | 
 3 | // We are given a string having parenthesis like below
 4 | //     “( ((X)) (((Y))) )”
 5 | // We need to find the maximum depth of balanced parenthesis, like 4 in above example. Since ‘Y’ is surrounded by 4 balanced parenthesis.
 6 | // If parenthesis are unbalanced then return -1.
 7 | 
 8 | #include <iostream>
 9 | #include <string>
10 | #include <stack>
11 | using namespace std;
12 | 
13 | int parenthesis(string ex)
14 | {
15 |     int l = ex.length();
16 |     int i,ct=0,maxct=0;
17 |     stack<char> s;
18 |     char ch;
19 |     for(i=0;i<l;i++)
20 |     {
21 |         if(ex[i]=='(')
22 |         {    
23 |             s.push(ex[i]);
24 |             ct++;
25 |         }
26 |         
27 |         if(s.empty())
28 |             return 0;
29 |             
30 |         if(ex[i]==')')
31 |         {
32 |             ch = s.top();
33 |             s.pop();
34 |             ct--;
35 |         }
36 |         if(ct>maxct)
37 |             maxct = ct;
38 |     }
39 |     if(s.empty())
40 |         return maxct;
41 |     else
42 |         return -1;
43 | }
44 | 
45 | int main()
46 | {
47 |     string expr = "( p((q)) ((s)t) )";
48 |     cout<<parenthesis(expr)<<endl;
49 |     string expression = "({)}[]";
50 |     cout<<parenthesis(expression)<<endl;    
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Stacks/QueueUsingStacks.cpp:
--------------------------------------------------------------------------------
 1 | // Queue using Stacks
 2 | 
 3 | // We are given a stack data structure with push and pop operations, the task is to implement a queue using instances of stack data structure and operations on them.
 4 | 
 5 | 
 6 | #include <iostream>
 7 | #include <algorithm>
 8 | #include <stack>
 9 | using namespace std;
10 | 
11 | struct Queue
12 | {
13 |     stack<int> s1;
14 |     stack<int> s2;
15 |     
16 |     void enque(int x)
17 |     {
18 |         s1.push(x);
19 |     }
20 |     
21 |     int dequeue()
22 |     {
23 |         if(s1.empty())
24 |             return 0;
25 |         else
26 |         {
27 |             while(!s1.empty())
28 |             {
29 |                 s2.push(s1.top());
30 |                 s1.pop();
31 |             }
32 |         }
33 |         int x = s2.top();
34 |         s2.pop();
35 |         return x;
36 |     }
37 | };
38 | 
39 | int main()
40 | {
41 |     struct Queue q;
42 |     q.enque(1);
43 |     q.enque(2);
44 |     q.enque(3);
45 |     q.enque(4);
46 |     q.enque(5);
47 |     
48 |     cout<<"\nElement removed is: "<<q.dequeue();
49 |     cout<<"\nElement removed is: "<<q.dequeue();
50 |     cout<<"\nElement removed is: "<<q.dequeue();
51 |     
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/Strings/AmazingSubarrays.py:
--------------------------------------------------------------------------------
 1 | # You are given a string S, and you have to find all the amazing substrings of S.
 2 | 
 3 | # Amazing Substring is one that starts with a vowel (a, e, i, o, u, A, E, I, O, U).
 4 | 
 5 | # Input
 6 | 
 7 | # Only argument given is string S.
 8 | # Output
 9 | 
10 | # Return a single integer X mod 10003, here X is number of Amazing Substrings in given string.
11 | 
12 | # Constraints
13 | 
14 | # 1 <= length(S) <= 1e6
15 | # S can have special characters
16 | 
17 | # Example
18 | 
19 | # Input
20 | #     ABEC
21 | 
22 | # Output
23 | #     6
24 | 
25 | # Explanation
26 | # 	Amazing substrings of given string are :
27 | # 	1. A
28 | # 	2. AB
29 | # 	3. ABE
30 | # 	4. ABEC
31 | # 	5. E
32 | # 	6. EC
33 | # 	here number of substrings are 6 and 6 % 10003 = 6.
34 | 
35 | 
36 | class Solution:
37 |     def solve(self, A):
38 |         count = 0
39 |         size = len(A)
40 |         A = A.lower()
41 |         vowels = ['a', 'e', 'i', 'o', 'u']
42 |         for i in range(size):
43 |             if A[i] in vowels:
44 |                 # No need to run permutations
45 |                 count += size - i
46 | 
47 |         return count % 10003
48 | 


--------------------------------------------------------------------------------
/Strings/BinaryStringDuplication.py:
--------------------------------------------------------------------------------
 1 | # http://codesfiction.com/hackerrank-week-of-code-32-duplication/
 2 | 
 3 | # Consider a binary string, s, with an initial value of "0". We expand s by performing the following steps:
 4 | 
 5 | # Create a string, t, where each character ti is equal to 1 - si. For example, if s = "01", then t = "10".
 6 | # Note that s and t always have the same length because t is the complement of s.
 7 | # Append t to the end of s so that s(new) = s + t. In the example above, "01" becomes "0110".
 8 | # We keep on expanding s using steps 1 and 2 infinitely.
 9 | # When we repeat the expansion operation, string s grows like this:
10 | 
11 | # Example: String on step 4: 0110100110010110
12 | 
13 | # Given queries in the form of a zero-based index, , solve each query by printing the character at index in on a new line.
14 | 
15 | # Input Format
16 | 
17 | # The first line contains an integer denoting q (number of queries).
18 | # Each of the q subsequent lines contains an integer describing the value of x for a query.
19 | 
20 | # Constraints
21 | 
22 | # 0 <= x, q <= 1000
23 | 
24 | # Output Format
25 | 
26 | # For each query, print the value of s[x] (i.e., either 1 or 0) on a new line.
27 | 
28 | # Sample Input
29 | 
30 | # 3
31 | # 2
32 | # 5
33 | # 7
34 | # Sample Output
35 | 
36 | # 1
37 | # 0
38 | # 1
39 | 
40 | n = int(input())
41 | li = []
42 | for i in range(n):
43 |     li.append(int(input()))
44 | 
45 | s = '0'
46 | lastc = 1
47 | while(len(s) <= max(li)):
48 |     news = ''
49 |     for i in range(0, lastc):
50 |         news += str(abs(int(s[i]) - 1))
51 |     s += news
52 |     lastc *= 2
53 | 
54 | for i in li:
55 |     print(s[i])
56 | 


--------------------------------------------------------------------------------
/Strings/CapitalizeFirstLetterName.py:
--------------------------------------------------------------------------------
 1 | # You are asked to ensure that the first and last names of people begin with a capital letter in their passports. For example, alison heck should be capitalised correctly as Alison Heck.
 2 | 
 3 | 
 4 | # Given a full name, your task is to capitalize the name appropriately.
 5 | 
 6 | # Input Format
 7 | 
 8 | # A single line of input containing the full name, .
 9 | 
10 | # Constraints
11 | # 0<len(s)<1000
12 | # The string consists of alphanumeric characters and spaces.
13 | # Note: in a word only the first character is capitalized.
14 | # Example 12abc when capitalized remains 12abc.
15 | 
16 | # Output Format
17 | 
18 | # Print the capitalized string, .
19 | 
20 | # Sample Input
21 | # chris alan
22 | 
23 | # Sample Output
24 | # Chris Alan
25 | 
26 | 
27 | import os
28 | 
29 | # Complete the solve function below.
30 | 
31 | 
32 | def solve(s):
33 |     caps = ''
34 |     # First character to upper
35 |     caps += (s[0].upper())
36 |     pos = 1
37 |     while pos < len(s):
38 |         # If space is found
39 |         if s[pos] == ' ':
40 |             # If there aren't multiple spaces
41 |             if s[pos + 1] != ' ':
42 |                 # Adding the space
43 |                 caps += ' '
44 |                 # Adding character after the space after capitalizing
45 |                 caps += s[pos + 1].upper()
46 |                 pos += 1
47 |             # If there are multiple spaces, just appending the spaces
48 |             else:
49 |                 caps += s[pos]
50 |         else:
51 |             caps += s[pos]
52 | 
53 |         pos += 1
54 |     return caps
55 | 
56 | 
57 | if __name__ == '__main__':
58 |     fptr = open(os.environ['OUTPUT_PATH'], 'w')
59 | 
60 |     s = input()
61 | 
62 |     result = solve(s)
63 | 
64 |     fptr.write(result + '\n')
65 | 
66 |     fptr.close()
67 | 


--------------------------------------------------------------------------------
/Strings/CharCompression.cpp:
--------------------------------------------------------------------------------
 1 | // All Char Compression
 2 | 
 3 | // Here is a new proposed method of compressing strings : 
 4 | // "Anywhere in the string if a character c occurs k number of times consecutively, it can be written as c"
 5 | 
 6 | // Using this algorithm, your task is to compress the string such that its final length is minimum.
 7 | 
 8 | // Note that it is not compulsory for you to compress every single character. You may choose to compress whatever characters you want. Only the length of the final string must be minimum.
 9 | 
10 | // INPUT
11 | // The input is one string that needs to be compressed.
12 | 
13 | // OUTPUT
14 | // Print the final compressed string of minimum length
15 | 
16 | // CONSTRAINTS
17 | // Length of input string will not be more than 1000.
18 | // Input string will consist of lowercase english alphabets only.
19 | 
20 | // Sample Input 0
21 | 
22 | // bbaannaannaa
23 | // Sample Output 0
24 | 
25 | // banana
26 | // Explanation 0
27 | 
28 | // string "bbaannaannaa" can be compressed to "banana" by compressing every pair of adjacent equal characters.
29 | 
30 | #include <cmath>
31 | #include <cstdio>
32 | #include <string>
33 | #include <vector>
34 | #include <iostream>
35 | #include <algorithm>
36 | using namespace std;
37 | 
38 | 
39 | int main() {
40 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
41 |     string str;
42 |     cin>>str;
43 |     int i;
44 |     int len=str.length();
45 |     // cout<<len;
46 |     for(i=0;i<len;i++)
47 |     {
48 |         if(str[i]!=str[i+1])
49 |             cout<<str[i];
50 |     }
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Strings/CharCompression.py:
--------------------------------------------------------------------------------
 1 | # Here is a new proposed method of compressing strings :
 2 | # "Anywhere in the string if a character c occurs k number of times consecutively, it can be written as c"
 3 | 
 4 | # Using this algorithm, your task is to compress the string such that its final length is minimum.
 5 | 
 6 | # Note that it is not compulsory for you to compress every single character.
 7 | # You may choose to compress whatever characters you want. Only the length of the final string must be minimum.
 8 | 
 9 | # INPUT
10 | # The input is one string that needs to be compressed.
11 | 
12 | # OUTPUT
13 | # Print the final compressed string of minimum length
14 | 
15 | # CONSTRAINTS
16 | # Length of input string will not be more than 1000.
17 | # Input string will consist of lowercase english alphabets only.
18 | 
19 | # Sample Input 0
20 | 
21 | # bbaannaannaa
22 | # Sample Output 0
23 | 
24 | # banana
25 | # Explanation 0
26 | 
27 | # string "bbaannaannaa" can be compressed to "banana" by compressing every pair of adjacent equal characters.
28 | 
29 | 
30 | s = input()
31 | news = ""
32 | 
33 | for ch in range(len(s) - 1):
34 |     if s[ch] == s[ch + 1]:
35 |         pass
36 |     else:
37 |         news += s[ch]
38 | news += s[-1]
39 | print(news)
40 | 


--------------------------------------------------------------------------------
/Strings/ContactsApplication.py:
--------------------------------------------------------------------------------
 1 | # Contacts Application
 2 | 
 3 | # Your task is to design a contacts application that supports two features :
 4 | 
 5 | # add name where name is a string that denotes the name of the contact. This operation must store a new contact by the name name.
 6 | 
 7 | # find partial where partial is a string denoting a part of the name to search for in the directory. It must count the number of contacts that start with partial and print the count.
 8 | 
 9 | # You are given n sequential operations of either type 1 or type 2. You are expected to perform them in the order given.
10 | 
11 | # Input Format
12 | 
13 | # The first line contains a single integer, n , denoting the number of operations to perform. Each line i of the n subsequent lines contains an operation in one of the two forms defined above.
14 | 
15 | # Constraints
16 | 
17 | # 1 <= n <= 105
18 | # 1 <= |name|, |partial| <= 21
19 | # It is guaranteed that name and partial contain lowercase english letters only.
20 | # Output Format
21 | 
22 | # For each find partial operation, print the number of contact names starting with partial on a new line.
23 | 
24 | # Sample Input 0
25 | 
26 | # 4
27 | # add hack
28 | # add hackerrank
29 | # find hac
30 | # find hak
31 | # Sample Output 0
32 | 
33 | # 2
34 | # 0
35 | 
36 | # Enter your code here. Read input from STDIN. Print output to STDOUT
37 | def check(string, sub_str): 
38 |     if (string.find(sub_str) == -1): 
39 |         return("NO") 
40 |     else: 
41 |         return("YES") 
42 | n = int(input())
43 | l=[]
44 | for i in range(n):
45 |     act = input()
46 |     l.append(act)
47 | names=[]
48 | search=[]
49 | for x in l:
50 |     cmd,name = x.split()
51 |     if(cmd=='add'):
52 |         names.append(name)
53 |     if(cmd=='find'):
54 |         search.append(name)
55 | # print(names)
56 | # print(search)
57 | ct=0
58 | for i in search:
59 |     ct=0
60 |     for j in names:
61 |         if(check(i,j)=="YES"):
62 |             ct+=1
63 |     print(ct)


--------------------------------------------------------------------------------
/Strings/DiscoverTheRightCharacter.cpp:
--------------------------------------------------------------------------------
 1 | // Discover the right Character
 2 | 
 3 | // Given a positive integer, return its corresponding column title as it would appear in an Excel Spreadsheet.
 4 | // For Example :
 5 | 
 6 | // 1 -> A
 7 | // 2 -> B
 8 | // ....
 9 | // ....
10 | // 26 -> Z
11 | // 27 -> AA
12 | // Input Format
13 | 
14 | // One integer denoting the column number.
15 | 
16 | // Constraints
17 | 
18 | // The integer size will be less than 32-bits.
19 | 
20 | // Output Format
21 | 
22 | // Output the corresponding column title.
23 | 
24 | // Sample Input 0
25 | 
26 | // 27
27 | // Sample Output 0
28 | 
29 | // AA
30 | 
31 | #include <cmath>
32 | #include <cstdio>
33 | #include <vector>
34 | #include <iostream>
35 | #include <algorithm>
36 | using namespace std;
37 | 
38 | 
39 | int main() {
40 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
41 |     int n;
42 |     cin>>n;
43 |     int rem[100],div,i=0,j;
44 |     while(n>0)
45 |     {
46 |         rem[i]=n%26;
47 |         if(rem[i]==0)
48 |         {
49 |             rem[i]=26;
50 |             n-=26;
51 |         }
52 |         n/=26;
53 |         i++;
54 |     }
55 |     for(j=i-1;j>=0;j--)
56 |         printf("%c",rem[j]+64);
57 |     return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/Strings/DiscoverTheRightNumber.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Given a column title as appears in an Excel Spreadsheet, return its corresponding column number.
 3 | For Example :
 4 | 
 5 |     A -> 1
 6 |     B -> 2
 7 |     ....
 8 |     ....
 9 |     Z -> 26
10 |     AA -> 27
11 | Input Format
12 | 
13 | One string denoting the column title of an excel spreadsheet.
14 | 
15 | Constraints
16 | 
17 | The answer will always fit in a 32-bit integer.
18 | 
19 | Output Format
20 | 
21 | Output an integer.
22 | 
23 | Sample Input 0
24 | 
25 | AA
26 | Sample Output 0
27 | 
28 | 27
29 | '''
30 | 
31 | 
32 | a = input()
33 | l = []
34 | b = 0
35 | t = 0
36 | for i in a:
37 |     l = l + [i]
38 | while(l):
39 |     a = l.pop()
40 |     if t == 0:
41 |         b = b + (ord(a) - 64)
42 |     else:
43 |         b = b + (ord(a) - 64) * pow(26, t)
44 |     t = t + 1
45 | print(b)
46 | 


--------------------------------------------------------------------------------
/Strings/DiscoverTheSubstring.java:
--------------------------------------------------------------------------------
 1 | // Discover the Substring
 2 | 
 3 | // strstr is a function that returns 1 if one string is present as substring in another and 0 otherwise. You are to write a program to print the number of times one string is present in the other as a substring.
 4 | 
 5 | // Input Format
 6 | 
 7 | // Two lines of input consisting of two strings.
 8 | 
 9 | // Constraints
10 | 
11 | // 1 <= length of strings <= 100
12 | 
13 | // Output Format
14 | 
15 | // Output one number, the number of times any one string appears in the other.
16 | 
17 | // Sample Input 0
18 | 
19 | // banana
20 | // ana
21 | // Sample Output 0
22 | 
23 | // 2
24 | // Explanation 0
25 | 
26 | // b(ana)na and ban(ana) so answer is 2
27 | 
28 | // Sample Input 1
29 | 
30 | // a
31 | // adamant
32 | // Sample Output 1
33 | 
34 | // 3
35 | // Explanation 1
36 | 
37 | // (a)damant, ad(a)mant and adam(a)nt. So answer is 3.
38 | 
39 | import java.io.*;
40 | import java.util.*;
41 | 
42 | public class Solution {
43 | 
44 |     public static void main(String[] args) {
45 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
46 |         Scanner sc = new Scanner(System.in);
47 |         int n;
48 |         String str;
49 |         String findStr;
50 |         str=sc.nextLine();
51 |         findStr=sc.nextLine();
52 |         if(str.length()<findStr.length())
53 |         {
54 |             String temp=str;
55 |             str=findStr;
56 |             findStr=temp;
57 |         }
58 |         // System.out.println(str);
59 |         // System.out.println(findStr);
60 |         int lastIndex=0;
61 |         int count=0;
62 |         while(lastIndex!=-1)
63 |         {
64 |             lastIndex=str.indexOf(findStr,lastIndex);
65 |             if(lastIndex!=-1)
66 |             {
67 |                 count++;
68 |                 lastIndex++;
69 |             }
70 |         }
71 |         System.out.println(count);
72 |     }
73 | }


--------------------------------------------------------------------------------
/Strings/DiscoverTheSubstring.py:
--------------------------------------------------------------------------------
 1 | # Discover the Substring
 2 | 
 3 | # strstr is a function that returns 1 if one string is present as substring in another and 0 otherwise. You are to write a program to print the number of times one string is present in the other as a substring.
 4 | 
 5 | # Input Format
 6 | 
 7 | # Two lines of input consisting of two strings.
 8 | 
 9 | # Constraints
10 | 
11 | # 1 <= length of strings <= 100
12 | 
13 | # Output Format
14 | 
15 | # Output one number, the number of times any one string appears in the other.
16 | 
17 | # Sample Input 0
18 | 
19 | # banana
20 | # ana
21 | # Sample Output 0
22 | 
23 | # 2
24 | # Explanation 0
25 | 
26 | # b(ana)na and ban(ana) so answer is 2
27 | 
28 | # Sample Input 1
29 | 
30 | # a
31 | # adamant
32 | # Sample Output 1
33 | 
34 | # 3
35 | # Explanation 1
36 | 
37 | # (a)damant, ad(a)mant and adam(a)nt. So answer is 3.
38 | 
39 | # Enter your code here. Read input from STDIN. Print output to STDOUT
40 | s,sb= input(),input()
41 | if len(sb)>len(s):
42 |     sb,s=s,sb
43 | 
44 | results = 0
45 | sub_len = len(sb)
46 | for i in range(len(s)):
47 |     if s[i:i+sub_len] == sb:
48 |         results += 1
49 | print(results)


--------------------------------------------------------------------------------
/Strings/Lapindrome.py:
--------------------------------------------------------------------------------
 1 | # Lapindromes 
 2 | 
 3 | # Lapindrome is defined as a string which when split in the middle, gives two halves having the same characters and same frequency of each character. If there are odd number of characters in the string, we ignore the middle character and check for lapindrome. For example gaga is a lapindrome, since the two halves ga and ga have the same characters with same frequency. Also, abccab, rotor and xyzxy are a few examples of lapindromes. Note that abbaab is NOT a lapindrome. The two halves contain the same characters but their frequencies do not match.
 4 | # Your task is simple. Given a string, you need to tell if it is a lapindrome.
 5 | 
 6 | # Input:
 7 | # First line of input contains a single integer T, the number of test cases.
 8 | # Each test is a single line containing a string S composed of only lowercase English alphabet.
 9 | # Output:
10 | # For each test case, output on a separate line: "YES" if the string is a lapindrome and "NO" if it is not.
11 | # Constraints:
12 | # 1 ≤ T ≤ 100
13 | # 2 ≤ |S| ≤ 1000, where |S| denotes the length of S
14 | # Example:
15 | # Input:
16 | # 6
17 | # gaga
18 | # abcde
19 | # rotor
20 | # xyzxy
21 | # abbaab
22 | # ababc
23 | 
24 | 
25 | # Output:
26 | # YES
27 | # NO
28 | # YES
29 | # YES
30 | # NO
31 | # NO
32 | 
33 | t = int(input())
34 | for i in range(t):
35 |     word = input()
36 |     word_len = len(word)
37 |     mid = word_len//2
38 |     if((word_len %2) ==0 ):
39 |         str1 = word[0:mid]
40 |         str2 = word[mid:]   
41 |     else:
42 |         str1 = word[0:mid]
43 |         str2 = word[mid+1:]
44 |     
45 |     str1 = sorted(str1)
46 |     str2 = sorted(str2)
47 |     if(str1 == str2):
48 |         print("YES")
49 |     else:
50 |         print("NO")


--------------------------------------------------------------------------------
/Strings/MinimizeWasteCells.cpp:
--------------------------------------------------------------------------------
 1 | // Previously, it was important for every company to have a motto.
 2 | 
 3 | // Now, it is important for every company to have a banner.
 4 | 
 5 | // Since companies want to save their resources, they decided to convert their motto into a banner.
 6 | 
 7 | // How this works is, you create a square matrix of size N x N, and fill in the elements of this matrix using the motto in row-major order.
 8 | 
 9 | // The remaining spaces in the matrix are called waste cells and are to be represented as '?'.
10 | 
11 | // You have to choose N in such a way that the number of waste cells is minimized.
12 | 
13 | // Input
14 | // Input consists of one line only, containing the company motto
15 | 
16 | // Output
17 | // Output must consist of the matrix formed from the input string
18 | 
19 | // Notes
20 | // The length of the input string will not exceed 1000
21 | 
22 | // Sample Input 0
23 | 
24 | // nike - just do it!
25 | // Sample Output 0
26 | 
27 | // nike 
28 | // - jus
29 | // t do 
30 | // it!??
31 | // ?????
32 | // Sample Input 1
33 | 
34 | // oneplus - never settle!
35 | // Sample Output 1
36 | 
37 | // onepl
38 | // us - 
39 | // never
40 | //  sett
41 | // le!??
42 | 
43 | 
44 | #include <cmath>
45 | #include <cstdio>
46 | #include <vector>
47 | #include <iostream>
48 | #include <algorithm>
49 | #include <string.h>
50 | using namespace std;
51 | 
52 | 
53 | int main() {
54 |     char s[1001];
55 |     cin.getline(s,1001);
56 |     int l=strlen(s);
57 |     int n,i,j,k=0;
58 |     n=ceil(sqrt(l));
59 |     for(i=0;i<n;i++)
60 |     {
61 |         for(j=0;j<n;j++)
62 |         {
63 |             if(k>=l)
64 |                 cout<<"?";
65 |             else
66 |                 cout<<s[k++];
67 |         }
68 |         cout<<endl;
69 |     }   
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/Strings/MinimizeWasteCells.py:
--------------------------------------------------------------------------------
 1 | # Previously, it was important for every company to have a motto.
 2 | 
 3 | # Now, it is important for every company to have a banner.
 4 | 
 5 | # Since companies want to save their resources, they decided to convert their motto into a banner.
 6 | 
 7 | # How this works is, you create a square matrix of size N x N, and fill in the elements of this matrix using the motto in row-major order.
 8 | 
 9 | # The remaining spaces in the matrix are called waste cells and are to be represented as '?'.
10 | 
11 | # You have to choose N in such a way that the number of waste cells is minimized.
12 | 
13 | # Input
14 | # Input consists of one line only, containing the company motto
15 | 
16 | # Output
17 | # Output must consist of the matrix formed from the input string
18 | 
19 | # Notes
20 | # The length of the input string will not exceed 1000
21 | 
22 | # Sample Input 0
23 | 
24 | # nike - just do it!
25 | # Sample Output 0
26 | 
27 | # nike 
28 | # - jus
29 | # t do 
30 | # it!??
31 | # ?????
32 | # Sample Input 1
33 | 
34 | # oneplus - never settle!
35 | # Sample Output 1
36 | 
37 | # onepl
38 | # us - 
39 | # never
40 | #  sett
41 | # le!??
42 | 
43 | 
44 | import math
45 | s = input()
46 | slen = len(s)
47 | i = 1
48 | size = math.ceil(math.sqrt(slen))
49 | k = 0
50 | for i in range(size):
51 |     for j in range(size):
52 |         try:
53 |             print(s[k], end='')
54 |             k += 1
55 |         except:
56 |             print('?', end='')
57 |     print()
58 | 


--------------------------------------------------------------------------------
/Strings/Repeated String.py:
--------------------------------------------------------------------------------
 1 | # Repeated String
 2 | 
 3 | # Lilah has a string, s, of lowercase English letters that she repeated infinitely many times.
 4 | 
 5 | # Given an integer, , find and print the number of letter a's in the first n letters of Lilah's infinite string.
 6 | 
 7 | # For example, if the string s='abcac' and n=10, the substring we consider is abcacabcac, the first 10 characters of her infinite string. There are 4 occurrences of a in the substring.
 8 | 
 9 | # Function Description
10 | 
11 | # Complete the repeatedString function in the editor below. It should return an integer representing the number of occurrences of a in the prefix of length n in the infinitely repeating string.
12 | 
13 | # repeatedString has the following parameter(s):
14 | 
15 | # s: a string to repeat
16 | # n: the number of characters to consider
17 | # Input Format
18 | 
19 | # The first line contains a single string, s. 
20 | # The second line contains an integer, n.
21 | 
22 | # Print a single integer denoting the number of letter a's in the first n letters of the infinite string created by repeating  infinitely many times.
23 | 
24 | # Sample Input 0
25 | 
26 | # aba
27 | # 10
28 | # Sample Output 0
29 | 
30 | # 7
31 | # Explanation 0 
32 | # The first  letters of the infinite string are abaabaabaa. Because there are  a's, we print  on a new line.
33 | 
34 | # Sample Input 1
35 | 
36 | # a
37 | # 1000000000000
38 | # Sample Output 1
39 | 
40 | # 1000000000000
41 | # Explanation 1 
42 | # Because all of the first  letters of the infinite string are a, we print  on a new line.
43 | 
44 | 
45 | 
46 | #!/bin/python3
47 | 
48 | import math
49 | import os
50 | import random
51 | import re
52 | import sys
53 | 
54 | # Complete the repeatedString function below.
55 | def repeatedString(s, n):
56 |     ct=0
57 |     if(s=='a'):
58 |         return n
59 |     else:
60 |         for ch in s:
61 |             if(ch=='a'):
62 |                 ct+=1
63 |     repeat=n//len(s)
64 |     ct_a = ct*repeat
65 |     n = n - repeat*len(s)
66 |     rem = s[0:n]
67 |     for ch in rem:
68 |         if(ch=='a'):
69 |             ct_a+=1
70 |     return ct_a
71 |     # return rem
72 | 
73 | if __name__ == '__main__':
74 |     fptr = open(os.environ['OUTPUT_PATH'], 'w')
75 | 
76 |     s = input()
77 | 
78 |     n = int(input())
79 | 
80 |     result = repeatedString(s, n)
81 | 
82 |     fptr.write(str(result) + '\n')
83 | 
84 |     fptr.close()
85 | 


--------------------------------------------------------------------------------
/Strings/ReverseVowels.cpp:
--------------------------------------------------------------------------------
 1 | // Given a string, reverse only vowels in it. Leave the remaining string as it is.
 2 | 
 3 | // Input Format
 4 | // One string.
 5 | 
 6 | // Constraints
 7 | // 1 <= Length of string <= 10^5
 8 | 
 9 | // Output Format
10 | // One string, the original string with vowels reversed.
11 | 
12 | // Sample Input 
13 | 
14 | // trumpisshit
15 | 
16 | // Sample Output 
17 | 
18 | // trimpisshut
19 | 
20 | // Explanation 
21 | // vowels occur in the following order : u, i, i. they are reversed to occur in this order : i, i, u.
22 | 
23 | #include <cmath>
24 | #include <cstdio>
25 | #include <vector>
26 | #include <iostream>
27 | #include <algorithm>
28 | using namespace std;
29 | 
30 | int main() {
31 |     char ch[100000];
32 |     int a[100000][2],j=0,i,k,temp;
33 |     cin>>ch;
34 |     for(i=0;ch[i]!='\0';i++)
35 |     {
36 |         if(ch[i]=='a' || ch[i]=='e' || ch[i]=='i' || ch[i]=='o' || ch[i]=='u' || ch[i]=='A' || ch[i]=='E' || ch[i]=='I' || ch[i]=='O' || ch[i]=='U')
37 |         {
38 |             a[j][0]=ch[i];
39 |             a[j][1]=i;
40 |             j++;
41 |         }
42 |     }
43 |     for(i=0,k=j-1;i<j/2;i++,k--)
44 |     {
45 |         temp=a[i][0];
46 |         a[i][0]=a[k][0];
47 |         a[k][0]=temp;
48 |     }
49 |     for(i=0;i<j;i++)
50 |         ch[a[i][1]]=a[i][0];
51 |     cout<<ch;
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/Strings/StringConcatenation.cpp:
--------------------------------------------------------------------------------
 1 | // A string is called a pString if it can be represented as p concatenated copies of some string.
 2 | // For example, the string "aabaabaabaab" is at the same time a 1String, a 2String and a 4String, but it is not a 3String, a 5String, or a 6String and so on. Obviously any string is a 1String.
 3 | 
 4 | // You are given a string s, consisting of lowercase English letters and a positive integer p.
 5 | // Your task is to find if it is possible to reorder the letters in the string s in such a way that the resulting string is a pString.
 6 | 
 7 | // Input Format
 8 | 
 9 | // The first input line contains integer p. 
10 | // The second line contains s, all characters in s are lowercase English letters.
11 | 
12 | // Constraints
13 | 
14 | // 1 ≤ p ≤ 1000
15 | // 1 ≤ |s| ≤ 1000
16 | 
17 | // Output Format
18 | 
19 | // Print "YES" if it is possible to rearrange the letters in string s in such a way that the result is a pString. 
20 | // Print the result on a single output line. If it is not possible print "NO". (without quotes).
21 | 
22 | // Sample Input 0
23 | 
24 | // 2
25 | // aazz
26 | // Sample Output 0
27 | 
28 | // YES
29 | // Explanation 0
30 | 
31 | // aazz can be rearranged to azaz which is a 2String
32 | 
33 | 
34 | #include <cmath>
35 | #include <cstdio>
36 | #include <vector>
37 | #include <iostream>
38 | #include <algorithm>
39 | using namespace std;
40 | 
41 | 
42 | int main() {
43 |     char s[1000];
44 |     int p;
45 |     int flag = 0;
46 |     cin>>p;
47 |     cin>>s;
48 |     int i;
49 |     int c[26] = {0};
50 |     for(i=0; s[i]!='\0'; i++)
51 |         c[s[i]-'a']+=1;
52 |     for(int i=0;i<26;i++)
53 |     {
54 |         if(c[i]!=0 && c[i]!=p)
55 |         {
56 |             flag = 1;
57 |             break;
58 |         }
59 |     }
60 |     if(flag==0){
61 |         cout<<"YES";
62 |     }
63 |     else{
64 |         cout<<"NO";
65 |     }
66 |     
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/Strings/StringConversion.cpp:
--------------------------------------------------------------------------------
 1 | // String Conversion
 2 | 
 3 | // The string "GOTISPATHETIC" is written in a zigzag pattern on a given number of rows like this:
 4 | 
 5 | // G---S---H---C-
 6 | // -O-I-P-T-E-I--
 7 | // --T---A---T---
 8 | // And then read line by line: GSHCOIPTEITAT
 9 | 
10 | // Write the code that will take a string and make this conversion given a number of rows.
11 | 
12 | // Input Format
13 | 
14 | // One string and one integer- the number of rows.
15 | 
16 | // Output Format
17 | 
18 | // One string
19 | 
20 | // Sample Input 0
21 | 
22 | // GOTISPATHETIC
23 | // 3
24 | // Sample Output 0
25 | 
26 | // GSHCOIPTEITAT
27 | 
28 | #include <cmath>
29 | #include <cstdio>
30 | #include <vector>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
38 |     int i,n,l,row=0,direction=0;
39 |     string str;
40 |     cin>>str;
41 |     cin>>n;
42 |     string a[n];
43 |     l=str.length();
44 |     for(i=0;i<l;i++)
45 |     {
46 |         a[row]=a[row]+(str[i]);
47 |         if(row==n-1)
48 |             direction=-1;
49 |         else if(row==0)
50 |             direction=1;
51 |         
52 |         if(direction==1)
53 |             row++;
54 |         else if(direction==-1)
55 |             row--;
56 |     }
57 |     for(i=0;i<n;i++)
58 |         cout<<a[i];
59 | 
60 |      
61 |     return 0;
62 | }
63 | 


--------------------------------------------------------------------------------
/Strings/allTrim.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ALL TRIM
 3 | This program eliminates all the extra spaces from the string.
 4 | 
 5 | INPUT FORMAT : one string
 6 | OUTPUT FORMAT : one string 
 7 | SAMPLE INPUT :    all      trim program    .    
 8 | SAMPLE OUTPUT :(all trim program.)
 9 | */
10 | 
11 | #include<stdio.h>
12 | #include<string.h>
13 | void allTrim(char *p)
14 | {
15 | char *m,*j;
16 | j=p;
17 | m=p;
18 | while(*m==' ')
19 | {
20 | m++;
21 | }  //eliminates left spaces
22 | while(*m!='\0')
23 | {
24 |    while(*m!='\0' && *m!=' ') //copy words
25 |      {
26 |      *j=*m;
27 |       j++;
28 |       m++;
29 |      }
30 |   if(*m=='\0') break;
31 |   *j=' ';
32 |   j++;
33 |   while(*m==' ') m++;
34 | }
35 | if(j>p)
36 | {
37 | if(*(j-1)==' ') j--;
38 | } 
39 | *j='\0';
40 | }
41 | 
42 | int main()
43 | {
44 | char a[2000];
45 | printf("Enter a string:");
46 | fgets(a,2000,stdin);
47 | a[strlen(a)-1]='\0';
48 | allTrim(a);
49 | printf("(%s)",a);
50 | return 0;
51 | }


--------------------------------------------------------------------------------
/Strings/leftTrim.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | LEFT TRIM
 3 | This program eliminates extra spaces from left side of the string.
 4 | 
 5 | INPUT FORMAT : one string
 6 | OUTPUT FORMAT : one string 
 7 | SAMPLE INPUT :           left trim program. 
 8 | SAMPLE OUTPUT :(left trim program.)
 9 | */
10 | 
11 | #include<stdio.h>
12 | #include<string.h>
13 | void leftTrim(char *p)
14 | {
15 | char *q;
16 | q=p;
17 | while(*q==' ')
18 | {
19 | q++;
20 | }
21 | if(q>p) //if there were extra spaces on left, q would have been increased
22 | {
23 | while(*q!='\0')
24 | {
25 | *p=*q;
26 | q++;
27 | p++;
28 | }
29 | *p='\0';
30 | }
31 | }
32 | 
33 | int main()
34 | {
35 | char a[1000];
36 | printf("Enter a string:");
37 | fgets(a,1000,stdin);
38 | a[strlen(a)-1]='\0';
39 | leftTrim(a);
40 | printf("(%s)",a);
41 | return 0;
42 | }


--------------------------------------------------------------------------------
/Strings/rightTrim.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | RIGHT TRIM
 3 | This program eliminates extra spaces from right side of the string.
 4 | 
 5 | INPUT FORMAT : one string
 6 | OUTPUT FORMAT : one string 
 7 | SAMPLE INPUT : right trim program              
 8 | SAMPLE OUTPUT :(right trim program) round brackets are added in the output so that you can see extra spaces got eliminated from right side of the string. 
 9 | */
10 | 
11 | #include<stdio.h>
12 | #include<string.h>
13 | void rightTrim(char *p)
14 | {
15 | char *q;
16 | q=p;
17 | while(*q!='\0')
18 | {
19 | q++;
20 | }
21 | q--; //because q was pointing '\0'
22 | while(q>=p && *q==' ') q--; 
23 | *(q+1)='\0';
24 | }
25 | 
26 | int main()
27 | {
28 | char a[1000];
29 | printf("Enter a string:");
30 | fgets(a,1000,stdin);
31 | a[strlen(a)-1]='\0';
32 | rightTrim(a);
33 | printf("(%s)",a);
34 | return 0;
35 | }


--------------------------------------------------------------------------------
/Structures/EmployeeSheetSTL.cpp:
--------------------------------------------------------------------------------
 1 | // You are working for a company. Define a struct as follows :
 2 | 
 3 | // struct Employee{
 4 | // 	char name[55];
 5 | // 	int salary;
 6 | // }
 7 | // Given data of n employees, you are to use any sorting algorithm to sort them according to their salary in ascending order, and print them in the format "name salary".
 8 | 
 9 | // NOTE : Participants using Java shall use classes instead of structs.
10 | 
11 | // It is guaranteed that all names are distinct. If two people have the same salary, the one with lexicographically smaller name must come before the other.
12 | 
13 | // NOTE : you are not allowed to make any global variables. You must create another function to do the sorting and pass your employee array as a pointer to that function to sort it.
14 | 
15 | // Input Format
16 | 
17 | // First line contains a number N, number of employees.
18 | // Next N lines contain one string and one integer each.
19 | 
20 | // Constraints
21 | 
22 | // 1 <= name of employee <= 50
23 | // 1 <= N <= 1000
24 | // 1 <= salary <= 1000
25 | 
26 | // Output Format
27 | 
28 | // Print the data of all employees in the format "name salary" with details of one employee on one line.
29 | 
30 | // Sample Input 0
31 | 
32 | // 5
33 | // Abhinav 100
34 | // Nischay 50
35 | // Sarthak 25
36 | // Abhiram 150
37 | // Praneeth 200
38 | // Sample Output 0
39 | 
40 | // Sarthak 25
41 | // Nischay 50
42 | // Abhinav 100
43 | // Abhiram 150
44 | // Praneeth 200
45 | 
46 | 
47 | #include <bits/stdc++.h>
48 | using namespace std;
49 | 
50 | struct salary 
51 | {
52 |   char  a[50];
53 |     int marks;
54 | };
55 | bool compare(salary d, salary b)
56 | {
57 |     if(d.marks == b.marks)
58 |     {
59 |         bool cmp = strcmp(d.a, b.a) >= 0 ? false : true;
60 |         return cmp;
61 |         
62 |     }
63 |     return (d.marks < b.marks);
64 | }
65 | int main() {   
66 |     int n;
67 |     cin>>n;
68 |     salary names[n];
69 |     for(int i=0; i<n; i++)
70 |     {
71 |         cin>>names[i].a;
72 |         cin>>names[i].marks;
73 |     }
74 |     
75 |     sort(names, names + n, compare);
76 |     for(int i=0; i<n; i++)
77 |     {
78 |         cout<<names[i].a<<" "<<names[i].marks<<"\n";
79 |     }    
80 |     return 0;
81 | }
82 | 


--------------------------------------------------------------------------------
/Structures/Structures date sorting.cpp:
--------------------------------------------------------------------------------
 1 | // Given a number of dates, sort them in such a way that the date that corresponds to the earliest day comes first and the date that corresponds to the latest day comes last.
 2 | 
 3 | // Input Format
 4 | 
 5 | // First line contains N, the number of dates. 
 6 | // Next N lines contain one date each in the following format : 
 7 | // DD MM YYYY.
 8 | // The date will be three integers separated by a space where the first integer is the day, the second integer is the month and the third is the year.
 9 | 
10 | // Constraints
11 | 
12 | // 1 <= N <= 100 
13 | // It is guaranteed that the date will be a valid date. 
14 | 
15 | // Output Format
16 | 
17 | // Output N lines. Each line must contain one date. The dates must appear in a sorted format.
18 | 
19 | // Sample Input 0
20 | 
21 | // 4
22 | // 9 8 1996
23 | // 31 4 1995
24 | // 30 4 1996
25 | // 25 12 1997
26 | // Sample Output 0
27 | 
28 | // 31 4 1995
29 | // 30 4 1996
30 | // 9 8 1996
31 | // 25 12 1997
32 | 
33 | 
34 | #include <stdio.h>
35 | #include <string.h>
36 | #include <math.h>
37 | #include <stdlib.h>
38 | typedef struct date date;
39 | struct date
40 | {
41 |     int day;
42 |     int month;
43 |     int year;
44 | };
45 | int main() {
46 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
47 |     int n,i,j;
48 |     scanf("%d",&n);
49 |     date arr[n],temp;
50 |     for(i=0;i<n;i++)
51 |         scanf("%d %d %d",&arr[i].day,&arr[i].month,&arr[i].year);
52 |     for(i=0;i<n-1;i++)
53 |     {
54 |         for(j=0;j<n-i-1;j++)
55 |         {
56 |             if(arr[j].year > arr[j+1].year)
57 |             {
58 |                 temp = arr[j];
59 |                 arr[j]=arr[j+1];
60 |                 arr[j+1]=temp;
61 |             }
62 |             else if((arr[j].year == arr[j+1].year) && (arr[j].month > arr[j+1].month))
63 |             {
64 |                 temp = arr[j];
65 |                 arr[j]=arr[j+1];
66 |                 arr[j+1]=temp;
67 |             }
68 |             else if((arr[j].month == arr[j+1].month) && (arr[j].day > arr[j+1].day))
69 |             {
70 |                 temp = arr[j];
71 |                 arr[j]=arr[j+1];
72 |                 arr[j+1]=temp;
73 |             }
74 |         }
75 |     }
76 |     for(i=0;i<n;i++)
77 |     {
78 |         printf("%d %d %d",arr[i].day,arr[i].month,arr[i].year);
79 |         printf("\n");
80 |     }
81 |     return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/Trees/BST Traversals.c:
--------------------------------------------------------------------------------
 1 | // Binary Search Tree Traversals
 2 | 
 3 | // You are given N values to be inserted into a binary search tree. Every value in the left subtree fo a node x must be less than or equal to x and every value in the right subtree of a node x must be greater than x. You are to insert the N values into a binary search tree in the order that they are given. Print the resultant binary search tree's pre-order, in-order and post-order traversal on three different lines.
 4 | 
 5 | // Input Format
 6 | 
 7 | // First line contains a number N. Next line contains N integers.
 8 | 
 9 | // Constraints
10 | 
11 | // 1 <= N <= 1000
12 | 
13 | // Output Format
14 | 
15 | // Output 3 lines. First line denoting the preorder traversal, second line denoting the inorder traversal and the last line denoting the postorder traversal.
16 | 
17 | // Sample Input 0
18 | 
19 | // 10
20 | // 12 3 5 11 15 5 4 4 8 15 
21 | // Sample Output 0
22 | 
23 | // 12 3 5 5 4 4 11 8 15 15 
24 | // 3 4 4 5 5 8 11 12 15 15 
25 | // 4 4 5 8 11 5 3 15 15 12 
26 | 
27 | #include <stdio.h>
28 | #include <stdlib.h>
29 | #include <string.h>
30 | #include <stdbool.h>
31 | #include <math.h>
32 | #define scan(x) scanf(" %d", &x)
33 | struct TreeNode {
34 |     int x;
35 |     struct TreeNode* L;
36 |     struct TreeNode* R;
37 | };
38 | typedef struct TreeNode TreeNode;
39 | TreeNode* newNode(int _x) {
40 |     TreeNode* node = (TreeNode*) malloc(sizeof(TreeNode));
41 |     node->x = _x;
42 |     node->L = node->R = NULL;
43 |     return node;
44 | }
45 | TreeNode* insert(TreeNode* node, int val) {
46 |     if (node == NULL) return newNode(val);
47 |     if (val <= node->x) node->L = insert(node->L, val);
48 |     else node->R = insert(node->R, val);
49 |     return node;
50 | }
51 | 
52 | /*******************************************************************/
53 | void postorder(TreeNode* Root)
54 | {
55 |      if(Root==NULL)
56 |          return;
57 |     postorder(Root->L);
58 |     postorder(Root->R);
59 |     printf("%d ", Root->x);
60 | }
61 | void preorder(TreeNode* Root)
62 | {
63 |      if(Root==NULL)
64 |          return;
65 |     printf("%d ", Root->x);
66 |     preorder(Root->L);
67 |     preorder(Root->R);
68 | }
69 | void inorder(TreeNode* Root)
70 | {
71 |      if(Root==NULL)
72 |          return;
73 |     inorder(Root->L);
74 |     printf("%d ", Root->x);
75 |     inorder(Root->R);
76 | }
77 | /*******************************************************************/
78 | 
79 | int main() {
80 |     int val, N; scan(N);
81 |     TreeNode* Root = NULL;
82 |     for (int i = 1; i <= N; i++) {
83 |         scan(val);
84 |         Root = insert(Root, val);
85 |     }
86 |     preorder(Root);
87 |     printf("\n");
88 |     inorder(Root);    
89 |     printf("\n");
90 |     postorder(Root);
91 | }


--------------------------------------------------------------------------------
/Trees/HeightOfBinaryTree.c:
--------------------------------------------------------------------------------
 1 | // Output Format
 2 | 
 3 | // Output one integer that is the height of the binary search tree.
 4 | 
 5 | // Sample Input 0
 6 | // 10
 7 | // 2 8 5 1 10 5 9 9 3 5 
 8 | 
 9 | // Sample Output 0
10 | // 6
11 | 
12 | 
13 | #include <stdio.h>
14 | #include <string.h>
15 | #include <math.h>
16 | #include <stdlib.h>
17 | 
18 | struct TreeNode{
19 |     int x;
20 |     struct TreeNode* L;
21 |     struct TreeNode* R;
22 | };
23 | 
24 | typedef struct TreeNode TreeNode;
25 | 
26 | TreeNode* newNode(int y){
27 |     TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
28 |     node->x = y;
29 |     node->L = node->R = NULL;
30 |     return node;
31 | }
32 | 
33 | int height(TreeNode *root){
34 |     if(root==NULL)
35 |         return 0;
36 |     else{
37 |         int ldepth = height(root->L);
38 |         int rdepth = height(root->R);
39 |         if(ldepth>rdepth)
40 |         {
41 |             return ldepth+1;
42 |         }
43 |         else
44 |             return rdepth+1;
45 |     }
46 | }
47 | 
48 | TreeNode* insert(TreeNode* node, int val)
49 | {
50 |     if(node==NULL) return newNode(val);
51 |     if(val<=node->x){
52 |         node->L = insert(node->L, val);
53 |     }else{
54 |         node->R = insert(node->R, val);
55 |     }
56 |     return node;
57 | }
58 | 
59 | int main() {
60 |     int val, N;
61 |     scanf("%d", &N);
62 |     TreeNode* Root= NULL;
63 |     for(int i=1;i<=N; i++){
64 |         scanf("%d", &val);
65 |         Root = insert(Root, val);
66 |     }
67 |     printf("%d", height(Root));
68 |     return 0;
69 | }
70 | 


--------------------------------------------------------------------------------
/Trees/InOrder.c:
--------------------------------------------------------------------------------
 1 | // Your task is to implement the following function :
 2 | 
 3 | // void inorder(TreeNode*)
 4 | // You will be working with the following structure :
 5 | 
 6 | // struct TreeNode {
 7 | // 	int x;
 8 | //     struct TreeNode* L;
 9 | //     struct TreeNode* R;
10 | // }
11 | // You may only edit the BODY of the code, leaving the HEAD and the TAIL as it is.
12 | 
13 | // Sample Input 0
14 | 
15 | // 7
16 | // 4 2 1 3 6 7 5
17 | // Sample Output 0
18 | 
19 | // 1 2 3 4 5 6 7 
20 | 
21 | 
22 | #include <stdio.h>
23 | #include <stdlib.h>
24 | #include <string.h>
25 | #include <stdbool.h>
26 | #include <math.h>
27 | #define scan(x) scanf(" %d", &x)
28 | struct TreeNode {
29 | 	int x;
30 | 	struct TreeNode* L;
31 | 	struct TreeNode* R;
32 | };
33 | typedef struct TreeNode TreeNode;
34 | TreeNode* newNode(int _x) {
35 | 	TreeNode* node = (TreeNode*) malloc(sizeof(TreeNode));
36 | 	node->x = _x;
37 | 	node->L = node->R = NULL;
38 |   return node;
39 | }
40 | TreeNode* insert(TreeNode* node, int val) {
41 | 	if (node == NULL) return newNode(val);
42 | 	if (val <= node->x) node->L = insert(node->L, val);
43 | 	else node->R = insert(node->R, val);
44 | return node;
45 | }
46 | 
47 | /*********************************************************/
48 | 
49 | void inorder(TreeNode* Root)
50 | {
51 |      if(Root==NULL)
52 |          return;
53 |     inorder(Root->L);
54 |     printf("%d ", Root->x);
55 |     inorder(Root->R);
56 | }
57 | 
58 | /*******************************************************/
59 | 
60 | int main() {
61 | 	int val, N; scan(N);
62 | 	TreeNode* Root = NULL;
63 | 	for (int i = 1; i <= N; i++) {
64 | 		scan(val);
65 | 		Root = insert(Root, val);
66 | 	}
67 | 	inorder(Root);
68 | }


--------------------------------------------------------------------------------
/Trees/PostOrder.c:
--------------------------------------------------------------------------------
 1 | // Your task is to implement the following function :
 2 | 
 3 | // void postorder(TreeNode*)
 4 | // You will be working with the following structure :
 5 | 
 6 | // struct TreeNode {
 7 | // 	int x;
 8 | //     struct TreeNode* L;
 9 | //     struct TreeNode* R;
10 | // }
11 | // You may only edit the BODY of the code, leaving the HEAD and the TAIL as it is.
12 | 
13 | // Sample Input 0
14 | 
15 | // 7
16 | // 4 2 1 3 6 7 5
17 | // Sample Output 0
18 | 
19 | // 1 3 2 5 7 6 4 
20 | 
21 | 
22 | #include <stdio.h>
23 | #include <stdlib.h>
24 | #include <string.h>
25 | #include <stdbool.h>
26 | #include <math.h>
27 | #define scan(x) scanf(" %d", &x)
28 | struct TreeNode {
29 | 	int x;
30 | 	struct TreeNode* L;
31 | 	struct TreeNode* R;
32 | };
33 | typedef struct TreeNode TreeNode;
34 | TreeNode* newNode(int _x) {
35 | 	TreeNode* node = (TreeNode*) malloc(sizeof(TreeNode));
36 | 	node->x = _x;
37 | 	node->L = node->R = NULL;
38 |     return node;
39 | }
40 | TreeNode* insert(TreeNode* node, int val) {
41 | 	if (node == NULL) return newNode(val);
42 | 	if (val <= node->x) node->L = insert(node->L, val);
43 | 	else node->R = insert(node->R, val);
44 |     return node;
45 | }
46 | 
47 | /*******************************************************************/
48 | void postorder(TreeNode* Root)
49 | {
50 |     if(Root==NULL)
51 |         return;
52 |     postorder(Root->L);
53 |     postorder(Root->R);
54 |     printf("%d ", Root->x);
55 | }
56 | /*******************************************************************/
57 | 
58 | int main() {
59 | 	int val, N; scan(N);
60 | 	TreeNode* Root = NULL;
61 | 	for (int i = 1; i <= N; i++) {
62 | 		scan(val);
63 | 		Root = insert(Root, val);
64 | 	}
65 | 	postorder(Root);
66 | }


--------------------------------------------------------------------------------
/Trees/PostOrderFromPreAndInorder.cpp:
--------------------------------------------------------------------------------
 1 | /* Given two strings for inorder and preorder traversals.
 2 | Print the postorder traversal result from the above two strings.
 3 | 
 4 | First string is inorder traversal result, while second one is preorder traversal result.
 5 | 
 6 | Sample Input:-
 7 | DBEAFC
 8 | ABDECF
 9 | 
10 | Sample Output:-
11 | DEBFCA  */
12 | 
13 | 
14 | #include <cmath>
15 | #include <cstdio>
16 | #include <vector>
17 | #include <iostream>
18 | #include <algorithm>
19 | #include <cstring>
20 | using namespace std;
21 | typedef struct tree tree;
22 | struct tree
23 | {
24 |     char data;
25 |     tree *left;
26 |     tree *right;
27 | };
28 | int search(char ch[], int start, int end, char value)
29 | {
30 |     int i,idx;
31 |     for(i=start;i<=end;i++)
32 |         if(ch[i]==value)
33 |         {
34 |             idx=i;
35 |             break;
36 |         }
37 |     return idx;
38 | }
39 | tree *newval(char val)
40 | {
41 |     tree *node= (tree *)malloc(sizeof(tree));
42 |     node->data=val;
43 |     node->left=NULL;
44 |     node->right=NULL;
45 |     return node;
46 | }
47 | tree *buildtree(char in[], char pre[], int start, int end)
48 | {
49 |     if(start>end)
50 |         return NULL;
51 |     static int preidx=0;
52 |     tree *node= newval(pre[preidx++]);
53 |     if(start==end)
54 |         return node;
55 |     int inidx= search(in,start, end,node->data);
56 |     node->left= buildtree(in,pre,start,inidx-1);
57 |     node->right= buildtree(in,pre,inidx+1,end);
58 |     return node;
59 | }
60 | void postorder(tree *root)
61 | {
62 |     if(root!=NULL)
63 |     {
64 |         postorder(root->left);
65 |         postorder(root->right);
66 |         cout<<root->data;
67 |     }
68 | }
69 | int main() {
70 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
71 |     char pre[100],in[100];
72 |     cin>>in>>pre;
73 |     int len=strlen(in);
74 |     tree *root = buildtree(in,pre,0,len-1);
75 |     postorder(root);
76 |     return 0;
77 | }
78 | 


--------------------------------------------------------------------------------
/Trees/PreOrder.c:
--------------------------------------------------------------------------------
 1 | // Your task is to implement the following function :
 2 | 
 3 | // void preorder(TreeNode*)
 4 | // You will be working with the following structure :
 5 | 
 6 | // struct TreeNode {
 7 | // 	int x;
 8 | //     struct TreeNode* L;
 9 | //     struct TreeNode* R;
10 | // }
11 | // You may only edit the BODY of the code, leaving the HEAD and the TAIL as it is.
12 | 
13 | // Sample Input 0
14 | 
15 | // 7
16 | // 4 2 1 3 6 7 5
17 | // Sample Output 0
18 | 
19 | // 4 2 1 3 6 5 7 
20 | 
21 | 
22 | #include <stdio.h>
23 | #include <stdlib.h>
24 | #include <string.h>
25 | #include <stdbool.h>
26 | #include <math.h>
27 | #define scan(x) scanf(" %d", &x)
28 | struct TreeNode {
29 | 	int x;
30 | 	struct TreeNode* L;
31 | 	struct TreeNode* R;
32 | };
33 | typedef struct TreeNode TreeNode;
34 | TreeNode* newNode(int _x) {
35 | 	TreeNode* node = (TreeNode*) malloc(sizeof(TreeNode));
36 | 	node->x = _x;
37 | 	node->L = node->R = NULL;
38 |     return node;
39 | }
40 | TreeNode* insert(TreeNode* node, int val) {
41 | 	if (node == NULL) return newNode(val);
42 | 	if (val <= node->x) node->L = insert(node->L, val);
43 | 	else node->R = insert(node->R, val);
44 |     return node;
45 | }
46 | 
47 | /*******************************************************************/
48 | 
49 | void preorder(TreeNode* Root)
50 | {
51 |     if(Root==NULL)
52 |         return;
53 |     printf("%d ", Root->x);
54 |     preorder(Root->L);
55 |     preorder(Root->R);
56 | }
57 | 
58 | /*******************************************************************/
59 | 
60 | int main() {
61 | 	int val, N; scan(N);
62 | 	TreeNode* Root = NULL;
63 | 	for (int i = 1; i <= N; i++) {
64 | 		scan(val);
65 | 		Root = insert(Root, val);
66 | 	}
67 | 	preorder(Root);
68 | }


--------------------------------------------------------------------------------
/Trees/TraversalsAndHeight.cpp:
--------------------------------------------------------------------------------
 1 | // Program to print inorder, preorder and postorder of the given tree and also find the height of the tree recursively
 2 | 
 3 | #include <iostream>
 4 | using namespace std;
 5 | 
 6 | struct Node
 7 | {
 8 |     int data;
 9 |     struct Node *left;
10 |     struct Node *right;
11 | };
12 | 
13 | Node* insert(Node* root, int data)
14 | {
15 |     Node* newNode = (Node*)malloc(sizeof(Node));
16 |     newNode->data = data;
17 |     newNode->left = NULL;
18 |     newNode->right = NULL;
19 |     if(root==NULL)
20 |         return newNode;
21 |     else if(data<root->data)
22 |         root->left = insert(root->left, data);
23 |     else
24 |         root->right = insert(root->right, data);
25 |     return root;
26 | }
27 | 
28 | void inorder(Node* root)
29 | {
30 |     if(root==NULL)
31 |         return;
32 |     inorder(root->left);
33 |     cout<<root->data<<"->";
34 |     inorder(root->right);
35 | }
36 | 
37 | void preorder(Node* root)
38 | {
39 |     if(root==NULL)
40 |         return;
41 |     cout<<root->data<<"->";
42 |     preorder(root->left);
43 |     preorder(root->right);
44 | }
45 | 
46 | void postorder(Node* root)
47 | {
48 |     if(root==NULL)
49 |         return;
50 |     postorder(root->left);
51 |     postorder(root->right);
52 |     cout<<root->data<<"->";
53 | }
54 | 
55 | int height(Node *root){
56 |     if(root==NULL)
57 |         return 0;
58 |     else
59 |     {
60 |         int ldepth = height(root->left);
61 |         int rdepth = height(root->right);
62 |         if(ldepth>rdepth)
63 |             return ldepth+1;
64 |         else
65 |             return rdepth+1;
66 |     }
67 | }
68 | 
69 | int main() 
70 | {
71 |     cout<<"This is my 1st tree program!"<<endl;
72 |     Node* root = NULL;
73 |     root = insert(root, 3);
74 |     root = insert(root, 2);
75 |     root = insert(root, 1);
76 |     root = insert(root, 4);
77 |     root = insert(root, 5);
78 |     int h = height(root);
79 |     cout<<"Inorder:"<<endl;
80 |     inorder(root);
81 |     cout<<endl<<"Postorder:"<<endl;
82 |     postorder(root);
83 |     cout<<endl<<"Preorder:"<<endl;
84 |     preorder(root);
85 |     cout<<"Height of tree:"<<h<<endl;
86 |     return 0;
87 | }


--------------------------------------------------------------------------------