├── README.md
├── Possiblepermutation.py
├── Binary Duplication.py
├── Paint House Min Price.java
├── Replacearray.CPP
├── HarryPotterHalfBlood.CPP
├── HarrypotterSoccers.CPP
├── StringMatching.C
├── Array
    └── Gfg
    │   ├── Maximize sum of consecutive differences in a circular array.CPP
    │   ├── Sort Elements by frequency.CPP
    │   ├── Relative_Sorting.CPP
    │   ├── Search an element in a sorted and rotated array.CPP
    │   └── Next Greater Element.CPP
├── Bitwise_XOR.py
├── OS
    ├── Sequential File Allocation.CPP
    ├── FCFS.CPP
    └── SJF.CPP
├── Pattern5.C
├── Pattern3.CPP
├── Add 2 values.CPP
├── Minimum_frequency.C
├── Decimal to binary.CPP
├── Compiler
    └── Left recursion.CPP
├── ReverseVowels.C
├── HighestPossibleProduct.CPP
├── Pattern4.C
├── MinimumNumberFunction.CPP
├── Pattern2.C
├── Stairofnumbers.CPP
├── Frequency_in_strings.C
├── Equal_bases.CPP
├── Forming_Numericals_Pattern.C
├── SmallestPalindrome.C
├── Special_array_sorting.CPP
├── StringRepetitions.CPP
├── Square in a circle.CPP
├── LL_insertatanypos.CPP
├── MaximumElementonStack.CPP
├── Domino_Piles.CPP
├── Reincarnation.CPP
├── SmartFunction.CPP
├── 7 divisible_pairs.CPP
├── LittleShino.CPP
├── Pattern_printing9.C
├── Bug and Secret Santa.C
├── StringConversionzigzag.CPP
├── ParliamentSquare.CPP
├── ConfusedInteger.CPP
├── N_as_sum_of_primes.CPP
├── Let us xor.CPP
├── Char Compression.C
├── Count_the_primes.CPP
├── Lex Characters Unique.CPP
├── Blissfull pairs.CPP
├── Athletic_Akhil.CPP
├── Sorted_team.CPP
├── Array_as_a_hill.CPP
├── Friendshipended.CPP
├── Vowel Repitition.CPP
├── Color the Fence(Love).CPP
├── *rotate the array.CPP
├── BS !.CPP
├── Greatestnumberwithdigits.CPP
├── Consecutiveprimesum.CPP
├── Coders_day.CPP
├── CircularQueue.CPP
├── Eat less.CPP
├── RomantoDecimal.CPP
├── Electronic_Store_Sort.CPP
├── HappySighting.C
├── Stackusingarray.C
├── Canadian to turn off light bulb.CPP
├── Candies to Children.CPP
├── Slime(Microbial Infestation).CPP
├── Ways to decode.C
├── Algorithms
    ├── Water the grass.CPP
    ├── Maximizing special nodes.CPP
    ├── Bag of gold again.CPP
    └── Ebola curve.CPP
├── Cityofstars.CPP
├── Exclusive OR.CPP
├── Star_Strings.CPP
├── PermutationProblemwithKswaps.CPP
├── Sumofalldigits.CPP
├── Fewa and her photoshoot.CPP
├── LLinsertionatbeginning.CPP
├── Shortest_man.CPP
├── Smaller_team.CPP
├── Diamond_Pattern.CPP
├── Largest Rectangular Area Under Histogram.CPP
├── Electronicstore.CPP
├── Disintegrate LL.CPP
├── PaneerLove.CPP
├── Residueofexecution.CPP
├── SMS_language.C
├── Pstring.CPP
├── Amogh's Homework.CPP
├── Johny_in_a_matrix.CPP
├── LL_searching.C
├── Subway_runner.CPP
├── Subwayrunner.CPP
├── Maximum xor subset.CPP
├── Bracket Sequence.CPP
├── ResetButtons.CPP
├── Farthest String.CPP
├── Tricky_Treat.CPP
├── GCD.CPP
├── Word_index1.CPP
├── Play_with_strings.C
├── OrangePartitioning.C
├── Shopping in clusters.CPP
├── Nastya studies informatics.CPP
├── Bag of Gold again.C
├── Datesorting.CPP
├── Barua Number.CPP
├── Two_sum_value.CPP
├── LoopedList.C
├── One teacher Two classes.CPP
├── Pyramidbynumericals.CPP
├── Into the forest.C
├── Intothewater.CPP
├── Great_Pattern.CPP
├── Tilak has fun with the Lights.CPP
├── Gas Stations.CPP
├── EmployeeSheet.CPP
├── Dylan and array(Arrays without local maximum).CPP
├── Pucca and the card game.CPP
├── PrimeOfPrimes.CPP
├── Jason fights the monster.CPP
├── KefaHatesCoins.C
├── Tisha_and_Orange_Sorting.CPP
└── TurningBinaryMatrix.CPP


/README.md:
--------------------------------------------------------------------------------
1 | # Competitive_Programming
2 | Examples to showcase problems involving competitive programming
3 | 


--------------------------------------------------------------------------------
/Possiblepermutation.py:
--------------------------------------------------------------------------------
 1 | from itertools import permutations
 2 | s = input()
 3 | l = list(map("".join,permutations(s)))
 4 | c=0
 5 | for i in l:
 6 |     if(l.count(i)>1):
 7 |         c=1
 8 |         break;
 9 | if(c==1):
10 |     print("\n".join(l))
11 | else:
12 |     l.sort()
13 |     print("\n".join(l))
14 | 


--------------------------------------------------------------------------------
/Binary Duplication.py:
--------------------------------------------------------------------------------
 1 | t=int(input())
 2 | l=[]
 3 | for i in range(t):
 4 |     l.append(int(input()))
 5 | x=(max(l)//2)-2
 6 | j=0
 7 | s=['0','1','1','0']
 8 | while (j<t):
 9 |     p=len(s)
10 |     if p>=l[j]:
11 |         print(s[l[j]])
12 |     else:
13 |         for i in range(p):
14 |             if s[i]=='0':
15 |                 s.append('1')
16 |             else:
17 |                 s.append('0')
18 |         continue
19 |     j+=1
20 | 


--------------------------------------------------------------------------------
/Paint House Min Price.java:
--------------------------------------------------------------------------------
 1 | public int minCost(int[][] costs) {
 2 |     if(costs==null||costs.length==0)
 3 |         return 0;
 4 |  
 5 |     for(int i=1; i<costs.length; i++){
 6 |         costs[i][0] += Math.min(costs[i-1][1], costs[i-1][2]);
 7 |         costs[i][1] += Math.min(costs[i-1][0], costs[i-1][2]);
 8 |         costs[i][2] += Math.min(costs[i-1][0], costs[i-1][1]);
 9 |     }
10 |  
11 |     int m = costs.length-1;
12 |     return Math.min(Math.min(costs[m][0], costs[m][1]), costs[m][2]);
13 | }
14 | 


--------------------------------------------------------------------------------
/Replacearray.CPP:
--------------------------------------------------------------------------------
 1 | #include <cmath>
 2 | #include <cstdio>
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | 
 8 | 
 9 | int main() {
10 |     int n;
11 |     cin>>n;
12 |     int a[n];
13 |     for(int i = 0;i<n;i++)
14 |         cin>>a[i];
15 |     int max = a[n-1];
16 |     a[n-1] = 0;
17 |     for(int i=n-2;i>=0;i--)
18 |     {
19 |         int temp = a[i];
20 |         a[i] = max;
21 |         
22 |         if (max<temp)
23 |             max = temp;
24 |     }
25 |     for(int i = 0;i<n;i++)
26 |         cout<<a[i]<<" ";
27 |     return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/HarryPotterHalfBlood.CPP:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |  stack<int> s;
 6 |  int n;
 7 |  cin>>n;
 8 |  int a[n];
 9 |  for(int i=0;i<n;i++)
10 |  {
11 |  cin>>a[i];
12 |  }
13 |  int t;
14 |  int x,top1;
15 |  int sum=0;
16 |  int k =0;
17 |  cin>>t>>x;
18 |  int count =0;
19 |  while(t--)
20 |  {
21 |  
22 |  string s1;
23 |  cin>>s1;
24 |  if(s1 == "Harry")
25 |  {
26 |  s.push(a[k]);
27 |  sum+= a[k];
28 |  k++;
29 |  
30 |  }
31 |  if(sum == x)
32 |  {
33 |  cout<<s.size()<<endl;
34 |  break;
35 |  }
36 |  else if(s1 == "Remove")
37 |  {
38 |  top1 = s.top();
39 |  sum-= top1;
40 |  s.pop();
41 |  }
42 |  
43 |  }
44 |  if(sum!= x)
45 |  {
46 |  cout<<"-1"<<endl;
47 |  }
48 |  return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/HarrypotterSoccers.CPP:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |  stack<int> S;
 6 |  int N;
 7 |  cin>>N;
 8 |  int arr[N];
 9 |  for(int i=0;i<N;i++)
10 |  {
11 |  cin>>arr[i];
12 |  }
13 |  int p;
14 |  int q,TOP;
15 |  int sum=0;
16 |  int k =0;
17 |  cin>>p>>q;
18 |  int count =0;
19 |  while(p--)
20 |  {
21 |  
22 |  string strr;
23 |  cin>>strr;
24 |  if(strr == "Harry")
25 |  {
26 |  S.push(arr[k]);
27 |  sum+= arr[k];
28 |  k++;
29 |  
30 |  }
31 |  if(sum == q)
32 |  {
33 |  cout<<S.size()<<endl;
34 |  break;
35 |  }
36 |  else if(strr == "Remove")
37 |  {
38 |  TOP = S.top();
39 |  sum-= TOP;
40 |  S.pop();
41 |  }
42 |  
43 |  }
44 |  if(sum != q)
45 |  {
46 | cout<<"-1"<<endl;
47 |  }
48 |  return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/StringMatching.C:
--------------------------------------------------------------------------------
 1 | Write a program that takes two strings as input and prints "yes" if the second string is a substring of the first string and "no" otherwise.
 2 | 
 3 | Sample Input 0
 4 | 
 5 | Hello World!
 6 | Hello
 7 | Sample Output 0
 8 | 
 9 | yes
10 | 
11 | 
12 | 
13 | 
14 | #include<stdio.h>
15 | #include<stdlib.h>
16 | #include<string.h>
17 | int main()
18 | { char s[10000000];
19 |  scanf("%[^\n]s ",s);
20 | char sec[1000000];
21 |  scanf("%s",sec);
22 |  long long int n,m;
23 |  n=strlen(s);
24 |  m=strlen(sec);
25 |  for(long long int i=0;i<=n-m;i++){
26 |      long long int j;
27 |      for(j=0;j<m;j++){
28 |          if(s[i+j]!=sec[j])
29 |              break;
30 |      }
31 |      if(j==m){
32 |          printf("yes");
33 |          return 0;
34 |      }
35 |  }
36 |  printf("no");
37 |  return 0;
38 | }
39 | 


--------------------------------------------------------------------------------
/Array/Gfg/Maximize sum of consecutive differences in a circular array.CPP:
--------------------------------------------------------------------------------
 1 |  Input : arr[] = { 4, 2, 1, 8 }
 2 | Output : 18
 3 | Rearrange given array as : { 1, 8, 2, 4 }
 4 | Sum of difference between consecutive element
 5 | = |1 - 8| + |8 - 2| + |2 - 4| + |4 - 1|
 6 | = 7 + 6 + 2 + 3
 7 | = 18.
 8 | 
 9 | Input : arr[] = { 10, 12, 15 }
10 | Output : 10
11 | 
12 | 
13 | #include <bits/stdc++.h> 
14 | using namespace std; 
15 | 
16 | int maxSum(int arr[], int n) 
17 | { 
18 | 	int sum = 0; 
19 | 
20 | 	sort(arr, arr + n); 
21 | 
22 | 	for (int i = 0; i < n/2; i++) 
23 | 	{ 
24 | 		sum -= (2 * arr[i]); 
25 | 		sum += (2 * arr[n - i - 1]); 
26 | 	} 
27 | 
28 | 	return sum; 
29 | } 
30 | int main() 
31 | { 
32 | 	int arr[] = { 4, 2, 1, 8 }; 
33 | 	int n = sizeof(arr)/sizeof(arr[0]); 
34 | 	cout << maxSum(arr, n) << endl; 
35 | 	return 0; 
36 | } 
37 | 


--------------------------------------------------------------------------------
/Bitwise_XOR.py:
--------------------------------------------------------------------------------
 1 | Find the XOR of two numbers and print it.
 2 | 
 3 | Hint : Input the numbers as strings.
 4 | 
 5 | Input Format
 6 | 
 7 | First line contains first number X and second line contains second number Y.
 8 | The numbers will be given to you in binary form.
 9 | 
10 | Constraints
11 | 
12 | 0 <= X <= 2^1000
13 | 0 <= Y <= 2^1000
14 | 
15 | Output Format
16 | 
17 | Output one number in binary format, the XOR of two numbers.
18 | 
19 | Sample Input 0
20 | 
21 | 11011
22 | 10101
23 | Sample Output 0
24 | 
25 | 01110
26 | 
27 | 
28 | a=input()
29 | b=input()
30 | if(len(a)>len(b)):
31 |     b='0'*(len(a)-len(b))+b
32 | elif(len(b)>len(a)):
33 |     a='0'*(len(b)-len(a))+a
34 | for i in range(len(a)):
35 |     if((a[i]=='1' and b[i]=='1')or(a[i]=='0' and b[i]=='0')):
36 |         print("0",end="")
37 |     else:
38 |         print("1",end="")
39 | 


--------------------------------------------------------------------------------
/OS/Sequential File Allocation.CPP:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | struct fileTable{
 4 |     char name[20];
 5 |     int nob,blocks[30];
 6 | };
 7 | int main(){
 8 |     struct fileTable ft[30];
 9 |     int i,j,n;
10 |     char s[20];
11 |     cin>>n;
12 |     for(i=0;i<n;i++)
13 |     {
14 |         cin>>ft[i].name;
15 |         cin>>ft[i].nob;
16 |         for(j=0;j<ft[i].nob;j++)
17 |             cin>>ft[i].blocks[j];
18 |     }
19 |     cin>>s;
20 |     for(i=0;i<n;i++){
21 |         if(strcmp(s,ft[i].name)==0){
22 |             break;
23 |         }
24 |     }
25 |     if(i==n)
26 |        cout<<"file nt found";
27 |     else{
28 |         cout<<"Blocks occupied";
29 |         cout<<"\n"<<ft[i].name<<" "<<ft[i].nob;
30 |         for(j=0;j<ft[i].nob;j++)
31 |             cout<<ft[i].blocks[j];
32 |     }
33 |     return 0;
34 | }
35 |     
36 |    
37 |         
38 | 


--------------------------------------------------------------------------------
/Pattern5.C:
--------------------------------------------------------------------------------
 1 | PRINT THE BELOW MENTIONED PATTERN FOR ANY "N" VALUE. WHERE "N" INDICATES NO.OF ROWS.
 2 | 
 3 | Input Format
 4 | 
 5 | A SINGLE INTEGER DENOTING N VALUE
 6 | 
 7 | Constraints
 8 | 
 9 | 1<=N<=100
10 | 
11 | Output Format
12 | 
13 | PATTERN AS SHOWN IN SAMPLE TEST CASE
14 | 
15 | Sample Input 0
16 | 
17 | 5
18 | Sample Output 0
19 | 
20 | 1
21 |  2
22 |   3
23 |    4
24 |     5
25 |     
26 |     
27 |     
28 |     
29 |     #include <stdio.h>
30 | #include <string.h>
31 | #include <math.h>
32 | #include <stdlib.h>
33 | 
34 | int main() {
35 | 
36 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
37 |     int n,i,j,k;
38 |     scanf("%d",&n);
39 |     for(i=1;i<=n;i++)
40 |     {
41 |         for(j=1;j<=i-1;j++)
42 |             printf(" ");
43 |         
44 |             printf("%d",i);
45 |         
46 |         printf("\n");
47 |     }
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/Pattern3.CPP:
--------------------------------------------------------------------------------
 1 | PRINT THE BELOW MENTIONED PATTERN FOR ANY "N" VALUE. WHERE "N" INDICATES NO.OF ROWS.
 2 | 
 3 | Input Format
 4 | 
 5 | A SINGLE INTEGER DENOTING N VALUE
 6 | 
 7 | Constraints
 8 | 
 9 | 1<=N<=100
10 | 
11 | Output Format
12 | 
13 | PATTERN AS SHOWN IN SAMPLE TEST CASE
14 | 
15 | Sample Input 0
16 | 
17 | 5
18 | Sample Output 0
19 | 
20 |     1
21 |    12
22 |   123
23 |  1234
24 | 12345
25 | 
26 | 
27 | 
28 | #include <stdio.h>
29 | #include <string.h>
30 | #include <math.h>
31 | #include <stdlib.h>
32 | 
33 | int main() {
34 | 
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
36 |     int n,i,j,k;
37 |     scanf("%d",&n);
38 |     for(i=1;i<=n;i++)
39 |     {
40 |         for(j=1;j<=n-i;j++)
41 |             printf(" ");
42 |         for(k=1;k<=i;k++){
43 |             printf("%d",k);
44 |         }
45 |         printf("\n");
46 |     }
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/Add 2 values.CPP:
--------------------------------------------------------------------------------
 1 | Given two values, they can be integer or floating point numbers, add them.
 2 | 
 3 | Input Format
 4 | 
 5 | Two values separated by a space.
 6 | 
 7 | Constraints
 8 | 
 9 | No constraints.
10 | 
11 | Output Format
12 | 
13 | One value, the result of sum of two input values.
14 | 
15 | Sample Input 0
16 | 
17 | 5 4
18 | Sample Output 0
19 | 
20 | 9
21 | Explanation 0
22 | 
23 | 5 + 4 = 9
24 | 
25 | 
26 | 
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | #include <iomanip>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
38 |     double a,b;
39 |     cin>>a>>b;
40 |     a=a+b;
41 |     long int c=ceil(a);
42 |     if(c>a){
43 |         cout<<fixed<<showpoint;
44 |         cout<<setprecision(2);
45 |         cout<<a;}
46 |     else
47 |         cout<<c;
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/Minimum_frequency.C:
--------------------------------------------------------------------------------
 1 | Problem Description
 2 | 
 3 | How to find lowest frequency character in a string using loop in C programming.
 4 | Test Case 1
 5 | Input (stdin)
 6 | madam
 7 | 
 8 | Expected Output
 9 | d=1
10 | 
11 | Test Case 2
12 | Input (stdin)
13 | eefffggghhh
14 | 
15 | Expected Output
16 | e=2
17 | 
18 | 
19 | 
20 | #include <stdio.h>
21 | #define MAX_SIZE 100
22 | #define MAX_CHARS 255
23 | int main()
24 | {
25 | char str[MAX_SIZE];
26 |   int freq[MAX_CHARS];
27 |   int i=0,min;
28 |   int ascii;
29 |   scanf("%s",str);
30 |   for(i=0;i<MAX_CHARS;i++)
31 |   {
32 |     freq[i]=0;
33 |   }
34 |   i=0;
35 |   while(str[i] !='\0')
36 |   {
37 |     ascii = (int)str[i];
38 |     freq[ascii] += 1;
39 |   i++;
40 |   }
41 |   min=0;
42 |   for(i=0;i<MAX_CHARS;i++)
43 |   {
44 |     if(freq[i] !=0)
45 |     {
46 |       if(freq[min]==0 || freq[i]<freq[min])
47 |          min= i;
48 |     }
49 |   }
50 |   printf("%c=%d",min,freq[min]);
51 | 	return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Decimal to binary.CPP:
--------------------------------------------------------------------------------
 1 | Write a program that takes as input one decimal number N, and prints its binary form.
 2 | 
 3 | Input Format
 4 | 
 5 | One number N.
 6 | 
 7 | Constraints
 8 | 
 9 | 0 <= N <= 10^18
10 | 
11 | Output Format
12 | 
13 | Binary representation of the number N.
14 | 
15 | Sample Input 0
16 | 
17 | 2
18 | Sample Output 0
19 | 
20 | 10
21 | 
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 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
34 |     long long int n;
35 |     cin>>n;
36 |     if(n==0){
37 |         cout<<0;
38 |         return 0;
39 |     }
40 |     string s;
41 |     while(n!=0){
42 |         int rem = n%2;
43 |         s+=to_string(rem);
44 |         n=n/2;
45 |     }
46 |     for(int i=s.length()-1;i>=0;i--){
47 |         cout<<s[i];
48 |     }
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/Compiler/Left recursion.CPP:
--------------------------------------------------------------------------------
 1 | input:
 2 | 	A->Aa|b	
 3 | output
 4 | 	A'->aA'
 5 | 	A->bA'
 6 | 	A->e
 7 |   
 8 |   
 9 | #include<stdio.h>
10 | #include<string.h>
11 | int main(){
12 |     char input[100],*l,*r,*temp,tempprod[20],productions[25][10];
13 |     int i=0,j=0,flag=0;
14 |     printf("enter the productions");
15 |     scanf("%s",input);
16 |     l=strtok(input,"->");
17 |     r=strtok(NULL,"->");
18 |     temp=strtok(r,"|");
19 |     while(temp){
20 |         if(temp[0]==l[0]){
21 |             flag=1;
22 |             sprintf(productions[i++],"%s'->%s%s'\0",l,temp+1,l);
23 |         }
24 |         else
25 |             sprintf(productions[i++],"%s->%s%s'\0",l,temp,l);
26 |         temp=strtok(NULL,"|");
27 |     }
28 |     sprintf(productions[i++],"%s->%c",l,(char)238);
29 |     if(flag==0){
30 |         printf("No Left recursion");
31 |     }
32 |     else{
33 |         for(j=0;j<i;j++)
34 |        {
35 |             printf("\n%s",productions[j]);
36 |         }
37 |     }
38 |         return 0;
39 |     }
40 | 


--------------------------------------------------------------------------------
/ReverseVowels.C:
--------------------------------------------------------------------------------
 1 | Given a string, reverse only vowels in it. Leave the remaining string as it is.
 2 | 
 3 | Input Format
 4 | 
 5 | One string.
 6 | 
 7 | Constraints
 8 | 
 9 | 1 <= Length of string <= 10^5
10 | 
11 | Output Format
12 | 
13 | One string, the original string with vowels reversed.
14 | 
15 | Sample Input 0
16 | 
17 | trumpisshit
18 | Sample Output 0
19 | 
20 | trimpisshut
21 | 
22 | 
23 | 
24 | 
25 | #include<stdio.h>
26 | 
27 | int main() {
28 |     char s[100000],a[100000];
29 |     scanf("%s",s);
30 |     int i,k=0,st[100001];
31 |     for(i=0;s[i]!='\0';i++)
32 |     {
33 |        if(s[i]=='a' || s[i]=='e' || s[i]=='i' || s[i]=='o' || s[i]=='u' || s[i]=='A' || s[i]=='E'||                   s[i]=='I' || s[i]=='O' || s[i]=='U')
34 |        {
35 |            st[k]=i;
36 |            a[k]=s[i];
37 |            k++;
38 |        }            
39 |     }
40 |     int end=k-1;
41 |     for(i=0;i<k;i++)
42 |     {
43 |         s[st[i]]=a[end];
44 |         end--;
45 |     }
46 |     printf("%s",s);
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/HighestPossibleProduct.CPP:
--------------------------------------------------------------------------------
 1 | Given an array of N integers, your task is to print the highest possible product by multiplying any three numbers from the array.
 2 | 
 3 | Input Format
 4 | 
 5 | First line contains an integer N. 
 6 | Next line contains N space separated integers.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 106
11 | 0 <= |Ai| <= 103
12 | 
13 | Output Format
14 | 
15 | Output one numbers, the maximum product.
16 | 
17 | Sample Input 0
18 | 
19 | 6
20 | 0 -1 3 100 70 50
21 | Sample Output 0
22 | 
23 | 350000
24 | 
25 | 
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include<climits>
31 | #include <algorithm>
32 | using namespace std;
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
36 |     int n;
37 |     cin>>n;
38 |     int a[n];
39 |     for(int i=0;i<n;i++){
40 |         cin>>a[i];
41 |     }
42 |     sort(a,a+n);
43 |     int res;
44 |     res=a[n-1]*a[n-2]*a[n-3];
45 |     cout<<res;
46 |     
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/Pattern4.C:
--------------------------------------------------------------------------------
 1 | PRINT THE BELOW MENTIONED PATTERN FOR ANY "N" VALUE. WHERE "N" INDICATES NO.OF ROWS.
 2 | 
 3 | Input Format
 4 | 
 5 | A SINGLE INTEGER DENOTING N VALUE
 6 | 
 7 | Constraints
 8 | 
 9 | 1<=N<=100
10 | 
11 | N is only odd
12 | 
13 | Output Format
14 | 
15 | PATTERN AS SHOWN IN SAMPLE TEST CASE
16 | 
17 | Sample Input 0
18 | 
19 | 5
20 | Sample Output 0
21 | 
22 | 1   5
23 |  2 4
24 |   3
25 |   
26 |   
27 |   
28 |   #include <stdio.h>
29 | #include <string.h>
30 | #include <math.h>
31 | #include <stdlib.h>
32 | 
33 | int main() {
34 | 
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
36 |     int n,i,j,k,x;
37 |     scanf("%d",&n);
38 |     x=ceil(n/2.0);
39 |     for(i=1;i<=x;i++)
40 |     {
41 |         for(j=1;j<i;j++)
42 |         {
43 |             printf(" ");
44 |         }
45 |         printf("%d ",i);
46 |         for(k=i+1;k<n-i;k++)
47 |         {
48 |             printf(" ");
49 |         }
50 |         if(i!=n-i+1)
51 |             printf("%d\n",n-i+1);
52 |     }
53 |     
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/MinimumNumberFunction.CPP:
--------------------------------------------------------------------------------
 1 | Input Format
 2 | 
 3 | The input contains a single integer n (the number of integers to be compared).
 4 | 
 5 | Constraints
 6 | 
 7 | 2 <= n <= 50
 8 | 
 9 | Output Format
10 | 
11 | 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.
12 | 
13 | Sample Input 0
14 | 
15 | 2
16 | Sample Output 0
17 | 
18 | min(int, int)
19 | Explanation 0
20 | 
21 | image
22 | 
23 | Sample Input 1
24 | 
25 | 4
26 | Sample Output 1
27 | 
28 | min(int, min(int, min(int, int)))
29 | 
30 | 
31 | 
32 | #include <cmath>
33 | #include <cstdio>
34 | #include <vector>
35 | #include <iostream>
36 | #include <algorithm>
37 | using namespace std;
38 | 
39 | 
40 | int main() {
41 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
42 |     int n,i;
43 |     cin>>n;
44 |     for(i=0;i<n-1;i++)
45 |         cout<<"min(int, ";
46 |     cout<<"int";
47 |     for(i=0;i<n-1;i++)
48 |         cout<<")";
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/Pattern2.C:
--------------------------------------------------------------------------------
 1 | PRINT THE BELOW MENTIONED PATTERN FOR ANY "N" VALUE. WHERE "N" INDICATES NO.OF ROWS.
 2 | 
 3 | Input Format
 4 | 
 5 | A SINGLE INTEGER DENOTING N VALUE
 6 | 
 7 | Constraints
 8 | 
 9 | 1<=N<=100
10 | 
11 | Output Format
12 | 
13 | PATTERN AS SHOWN IN SAMPLE TEST CASE
14 | 
15 | Sample Input 0
16 | 
17 | 5
18 | Sample Output 0
19 | 
20 | 1
21 | 01
22 | 101
23 | 0101
24 | 10101
25 | Sample Input 1
26 | 
27 | 3
28 | Sample Output 1
29 | 
30 | 1
31 | 01
32 | 101
33 | 
34 | 
35 | 
36 | #include <stdio.h>
37 | #include <string.h>
38 | #include <math.h>
39 | #include <stdlib.h>
40 | 
41 | int main() {
42 | int n;
43 |     scanf("%d",&n);
44 |     for(int i=1;i<=n;i++){
45 |         if(i%2==1){
46 |             for(int j=1;j<=i;j++){
47 |                 printf("%d",j%2);
48 |             }
49 |         }
50 |         else{
51 |             for(int j=0;j<i;j++){
52 |                 printf("%d",j%2);
53 |             }
54 |         }
55 |         printf("\n");
56 |     }
57 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
58 |     return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/Stairofnumbers.CPP:
--------------------------------------------------------------------------------
 1 | Your task is to print a stairs of numbers in the following format :
 2 | 
 3 | N = 1
 4 | 1
 5 | 
 6 | N = 2
 7 |   1
 8 | 2 3
 9 | 
10 | N = 3
11 |     1
12 |   2 3
13 | 3 4 5
14 | and so on.
15 | 
16 | Input
17 | Input consists of only one integer N
18 | 
19 | Output
20 | Print the required pattern
21 | 
22 | Notes
23 | N is a non-negative integer less than or equal to 10
24 | 
25 | Sample Input 0
26 | 
27 | 2
28 | Sample Output 0
29 | 
30 |   1 
31 | 2 3 
32 | Sample Input 1
33 | 
34 | 3
35 | Sample Output 1
36 | 
37 |     1 
38 |   2 3 
39 | 4 5 6 
40 | 
41 | 
42 | #include <cmath>
43 | #include <cstdio>
44 | #include <vector>
45 | #include <iostream>
46 | #include <algorithm>
47 | using namespace std;
48 | 
49 | 
50 | int main() {
51 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
52 |     int n,i,j,k=1;
53 |     cin>>n;
54 |     for(i=1;i<n+1;i++)
55 |     {
56 |         for(j=n-i;j>0;j--)
57 |             cout<<"  ";
58 |         for(j=0;j<i;j++)
59 |             cout<<k++<<" ";
60 |         cout<<endl;
61 |         
62 |     }
63 |     return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/Frequency_in_strings.C:
--------------------------------------------------------------------------------
 1 | Problem Description
 2 | 
 3 | How to find highest frequency character in a string using loop in C programming.Find frequency of each characters in the string and store it in some array of integers.
 4 | Find maximum element in the array. Maximum element in the array will the be maximum occurring character in the string.
 5 | 
 6 | Test Case 1
 7 | Input (stdin)
 8 | aaabbcd
 9 | 
10 | Expected Output
11 | a=3
12 | b=2
13 | c=1
14 | d=1
15 | 
16 | Test Case 2
17 | Input (stdin)
18 | aabbccdd
19 | 
20 | Expected Output
21 | a=2
22 | b=2
23 | c=2
24 | d=2
25 | 
26 | 
27 | 
28 | 
29 | #include <stdio.h>
30 | #include <string.h>
31 |  
32 | int main()
33 | {
34 |    char string[100];
35 |    int c = 0, count[26] = {0}, x;
36 | 
37 |    scanf("%s",string);
38 |  
39 |    while (string[c] != '\0') {
40 | 
41 |  
42 |       if (string[c] >= 'a' && string[c] <= 'z') {
43 |          x = string[c] - 'a';
44 |          count[x]++;
45 |       }
46 |  
47 |       c++;
48 |    }
49 |  
50 |    for (c = 0; c <26; c++)
51 |    { if(count[c]!=0)
52 |          printf("%c=%d\n",c+'a',count[c]);
53 |    }
54 |    return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/Equal_bases.CPP:
--------------------------------------------------------------------------------
 1 | Given a decimal number N, you need to find the number of bases 1 < b <= n such that when the number N is represented in base 'b', it ends in a zero.
 2 | 
 3 | Input Format
 4 | 
 5 | Input contains only one number, N.
 6 | 
 7 | Constraints
 8 | 
 9 | 1 <= N <= 10000
10 | 
11 | Output Format
12 | 
13 | Output one number, the number of bases b such that when number N is represented in base b, the number contains a trailing zero.
14 | 
15 | Sample Input 0
16 | 
17 | 12
18 | Sample Output 0
19 | 
20 | 5
21 | Explanation 0
22 | 
23 | Base : Number : 
24 | 2 1100
25 | 3 110
26 | 4 30
27 | 5 22
28 | 6 20
29 | 7 15
30 | 8 14
31 | 9 13
32 | 10 12
33 | 11 11
34 | 12 10
35 | 
36 | 12 ends with a zero in 5 different number systems - 2,3,4,6 and 12. Hence the answer is 12.
37 | 
38 | 
39 | 
40 | 
41 | #include <stdio.h>
42 | int main()
43 | {
44 |     int number, i,count=0,t;
45 | 
46 | 
47 |     scanf("%d",&number);
48 | 
49 |     for(i=1; i <= number; ++i)
50 |     {
51 |         if (number%i == 0)
52 |         {
53 |             count++;
54 |         }
55 |     }
56 | t= count-1;
57 |     printf("%d",t);
58 |     return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/Forming_Numericals_Pattern.C:
--------------------------------------------------------------------------------
 1 | Print the following pattern :
 2 | 
 3 | N = 1
 4 | 1
 5 | 
 6 | N = 2
 7 | 2 2 2
 8 | 2 1 2
 9 | 2 2 2
10 | 
11 | N = 3
12 | 
13 | 3 3 3 3 3
14 | 3 2 2 2 3
15 | 3 2 1 2 3
16 | 3 2 2 2 3
17 | 3 3 3 3 3
18 | 
19 | and so on.
20 | Input Format
21 | 
22 | One number N
23 | 
24 | Constraints
25 | 
26 | 1 <= N <= 10
27 | 
28 | Output Format
29 | 
30 | The pattern
31 | 
32 | Sample Input 0
33 | 
34 | 2
35 | Sample Output 0
36 | 
37 | 2 2 2
38 | 2 1 2
39 | 2 2 2
40 | 
41 | 
42 | 
43 | #include <stdio.h>
44 |  
45 | int main() {
46 |     int n,i,j,k;
47 |     scanf("%d",&n);
48 |     for (i=n;i>=1;i--) {
49 |         for (j=n;j>=i;j--)
50 |               printf("%d ",j);
51 |         for (j=1;j<(i*2)-1;j++)
52 |               printf("%d ",i);
53 |         for (j=i+1;j<=n;j++)
54 |               printf("%d ",j);
55 |         printf("\n"); 
56 |     }
57 |     for (i=2;i<=n;i++) {
58 |         for (j=n;j>=i;j--)
59 |               printf("%d ",j);
60 |         for (j=1;j<(i*2)-1;j++)
61 |               printf("%d ",i);
62 |         for (j=i+1;j<=n;j++)
63 |               printf("%d ",j);
64 |         printf("\n");
65 |     }
66 |     return 0;
67 | }
68 | 


--------------------------------------------------------------------------------
/SmallestPalindrome.C:
--------------------------------------------------------------------------------
 1 | Problem Description
 2 | 
 3 | An integer is said to be a palindrome if its value is the same when read from both the right and left side. For a given positive Integer X , write a program that outputs the value of the smallest palindrome greater than X.
 4 | 
 5 | Input
 6 | Integer X such that X<10000.
 7 | 
 8 | Output
 9 | Output the smallest palindrome larger than X.Note : Numbers are always displayed without leading zeros.
10 | 
11 | Test Case 1
12 | Input (stdin)
13 | 606
14 | 
15 | Expected Output
16 | 616
17 | 
18 | Test Case 2
19 | Input (stdin)
20 | 303
21 | 
22 | Expected Output
23 | 313
24 | 
25 | 
26 | 
27 | #include <stdio.h>
28 | #include<string.h>
29 | int main()
30 | {char i,j,len,str[50];
31 |  scanf("%s",str);
32 |  len=strlen(str);
33 |  j = len;
34 |   i = -1;
35 |  while(++i <= --j) {
36 |     if(str[i] != str[j]) {
37 |           break;
38 |        }
39 |     }
40 |  if(j < i) {
41 |    if(len & 1) {
42 |      if(str[len/2] < '9'){
43 |            str[len/2]++;
44 |            printf("%s\n",str);
45 |                 }
46 | 
47 |                 else {
48 |                     str[len/2] = '0';}
49 |    }
50 |  }   
51 | 	return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Special_array_sorting.CPP:
--------------------------------------------------------------------------------
 1 | 
 2 | Sample Input 0
 3 | 
 4 | 2
 5 | 4
 6 | 1 0 3 2
 7 | 3
 8 | 2 1 0
 9 | Sample Output 0
10 | 
11 | Yes
12 | No
13 | 
14 | 
15 | 
16 | 
17 | #include <stdio.h>
18 | #include <string.h>
19 | #include <math.h>
20 | #include <stdlib.h>
21 | 
22 | int main() {
23 | int test;
24 |     scanf("%d",&test);
25 |     for(int i=0;i<test;i++){
26 |         int n;
27 |         scanf("%d",&n);
28 |         int a[n];
29 |         for(int i=0;i<n;i++){
30 |             scanf("%d",&a[i]);
31 |         }
32 |         int flag=0;
33 |         for(int i=0;i<n-1;i++){
34 |             if(a[i]>a[i+1]){
35 |                 if(a[i]-a[i+1]==1 || a[i+1]-a[i]==-1){
36 |                     int temp=a[i];
37 |                     a[i]=a[i+1];
38 |                     a[i+1]=temp;
39 |                 }
40 |                 else{
41 |                     flag=1;
42 |                     break;
43 |                 }
44 |             }
45 |         }
46 |         if(flag==0)
47 |             printf("Yes\n");
48 |         else
49 |             printf("No\n");
50 |     }
51 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/StringRepetitions.CPP:
--------------------------------------------------------------------------------
 1 | Given a string, find the smallest string that can generate the original string by concatenation. See example case for clarity.
 2 | 
 3 | Input Format
 4 | 
 5 | One string. String is guaranteed to contain lowercase letters only.
 6 | 
 7 | Constraints
 8 | 
 9 | 1 <= length of string <= 5000
10 | 
11 | Output Format
12 | 
13 | Print the smallest string that can be repeated to get the original string.
14 | 
15 | Sample Input 0
16 | 
17 | abababab
18 | Sample Output 0
19 | 
20 | ab
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 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
33 |     string str;
34 |     cin>>str;
35 |     string str2="",str3;
36 |     int i,j;
37 |     for(i=1;i<=str.length();i++){
38 |         str3="";
39 |         str2+=str[i-1];
40 |         //cout<<str2<<endl;
41 |         for(j=1;j<=str.length()/i;j++)
42 |             str3+=str2;
43 |         //cout<<str3<<endl;
44 |         if(str3==str)
45 |             break;
46 |     }
47 |     cout<<str2;
48 | 
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/Array/Gfg/Sort Elements by frequency.CPP:
--------------------------------------------------------------------------------
 1 | Input : arr[] = {2, 3, 2, 4, 5, 12, 2, 3, 3, 3, 12}
 2 | Output : 3 3 3 3 2 2 2 12 12 4 5
 3 | Explanation :
 4 | No. Freq
 5 | 2  : 3
 6 | 3  : 4
 7 | 4  : 1
 8 | 5  : 1
 9 | 12 : 2
10 | 
11 | 
12 | 
13 | #include <bits/stdc++.h> 
14 | using namespace std;
15 | bool compare(pair<int,int> &p1, 
16 | 			pair<int, int> &p2) 
17 | { 
18 | 	if (p1.second == p2.second) 
19 | 		return p1.first < p2.first; 
20 | 	return p1.second > p2.second; 
21 | } 
22 | void printSorted(int arr[], int n) 
23 | { 
24 | 	map<int, int> m; 
25 | 	for (int i = 0; i < n; i++) 
26 | 		m[arr[i]]++; 
27 | 	int s = m.size(); 
28 | 	pair<int, int> p[s]; 
29 | 	int i = 0; 
30 | 	for (auto it = m.begin(); it != m.end(); ++it) 
31 | 		p[i++] = make_pair(it->first, it->second); 
32 | 	sort(p, p + s, compare); 
33 | 
34 | 	cout << "Elements sorted by frequency are: "; 
35 | 	for (int i = 0; i < s; i++) 
36 | 	{ 
37 | 		int freq = p[i].second; 
38 | 		while (freq--) 
39 | 			cout << p[i].first << " "; 
40 | 	} 
41 | } 
42 | int main() 
43 | { 
44 | 	int arr[] = {2, 3, 2, 4, 5, 12, 2, 3, 
45 | 				3, 3, 12}; 
46 | 	int n = sizeof(arr)/ sizeof(arr[0]); 
47 | 	printSorted(arr, n); 
48 | 	return 0; 
49 | } 
50 | 


--------------------------------------------------------------------------------
/Square in a circle.CPP:
--------------------------------------------------------------------------------
 1 | 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.
 2 | 
 3 | Input
 4 | Input consists of multiple test cases. 
 5 | Each test case contains one integer a denoting the side-length of the square between the two circles.
 6 | 
 7 | Output
 8 | Print the area of the ring.
 9 | 
10 | Sample Input 0
11 | 
12 | 3
13 | 3
14 | 4
15 | 5
16 | Sample Output 0
17 | 
18 | 7.068583
19 | 12.566371
20 | 19.634954
21 | 
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 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
34 |     int t;
35 |     cin>>t;
36 |     while(t--)
37 |     {
38 |         double n;
39 |         cin>>n;
40 |         double r=n/sqrt(2);
41 |         double r1=n/2;
42 |         double a=M_PI*(r*r-r1*r1);
43 |         printf("%.6f\n",a);
44 |         
45 |     }
46 |     return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/LL_insertatanypos.CPP:
--------------------------------------------------------------------------------
 1 | #include <cmath>
 2 | #include <cstdio>
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | struct node{
 8 |     int data;
 9 |     struct node* next;
10 | }*head;
11 | struct val{
12 |     int p;
13 |     int x;
14 |     
15 | };
16 | void insert(int p,int x){
17 |     struct node *n=new node();
18 |     n->data=x;
19 |     n->next=NULL;
20 |     if(head==NULL)
21 |         head=n;
22 |     else if(p==0){
23 |         n->next=head;
24 |         head=n;
25 |     }
26 |     else{
27 |      struct node *t=new node();
28 |         t=head;
29 |         p-=1;
30 |         while(p-->0){
31 |         t=t->next;    
32 |         }
33 |         n->next=t->next;
34 |         t->next=n;
35 |     }
36 | }
37 | int main() {
38 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
39 |     int n;
40 |     cin>>n;
41 |     head=new node();
42 |  struct val v[n];
43 |     for(int i=0;i<n;i++){
44 |         cin>>v[i].p>>v[i].x;
45 |         insert(v[i].p,v[i].x);
46 |     }
47 |     
48 |     while(head->next->next!=NULL){
49 |         
50 |         cout<<head->data<<"->";
51 |         head=head->next;
52 |         
53 |     }
54 |     cout<<head->data;
55 |     return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/MaximumElementonStack.CPP:
--------------------------------------------------------------------------------
 1 | Output Format
 2 | 
 3 | image
 4 | 
 5 | Sample Input 0
 6 | 
 7 | 10
 8 | 1 97
 9 | 2
10 | 1 20
11 | 2
12 | 1 26
13 | 1 20
14 | 2
15 | 3
16 | 1 91
17 | 3
18 | Sample Output 0
19 | 
20 | 26
21 | 91
22 | 
23 | 
24 | 
25 | 
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <stack>
31 | #include <algorithm>
32 | using namespace std;
33 | 
34 | 
35 | int main() {
36 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
37 |     stack<int> s,ma;
38 |     int m = -1;
39 |     int q,t,v;
40 |     cin >> q;
41 |     while(q--)
42 |     {
43 |         cin >> t;
44 |         if(t == 1)
45 |         {
46 |             cin >> v;
47 |             if(ma.empty())
48 |                 ma.push(v);
49 |             else if(v > ma.top())
50 |             {
51 |                 ma.push(v);
52 |             }
53 |             s.push(v);
54 |         }
55 |         else if(t == 2)
56 |         {
57 |             if(s.top() == ma.top())
58 |             {
59 |                 ma.pop();
60 |             }
61 |             s.pop();
62 |         }
63 |         else if(t == 3)
64 |         {
65 |             cout << ma.top() << endl;
66 |         }
67 |     }
68 |     return 0;
69 | }
70 | 
71 | 


--------------------------------------------------------------------------------
/Domino_Piles.CPP:
--------------------------------------------------------------------------------
 1 | You are given a rectangular board of M × N squares. Also you are given an unlimited number of standard domino pieces of 2 × 1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions:
 2 | 
 3 | 1.Each domino completely covers two squares.
 4 | 
 5 | 2.No two dominoes overlap.
 6 | 
 7 | 3.Each domino lies entirely inside the board. It is allowed to touch the edges of the board.
 8 | 
 9 | Find the maximum number of dominoes, which can be placed under these restrictions.
10 | 
11 | Input Format
12 | 
13 | In a single line you are given two integers M and N — board sizes in squares
14 | 
15 | Constraints
16 | 
17 | 1 ≤ M ≤ N ≤ 16
18 | 
19 | Output Format
20 | 
21 | Output one number — the maximal number of dominoes, which can be placed.
22 | 
23 | Sample Input 0
24 | 
25 | 2 4
26 | Sample Output 0
27 | 
28 | 4
29 | 
30 | 
31 | 
32 | #include <cmath>
33 | #include <cstdio>
34 | #include <vector>
35 | #include <iostream>
36 | #include <algorithm>
37 | using namespace std;
38 | 
39 | 
40 | int main() {
41 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
42 |     int l,a,b;
43 |     cin>>a>>b;
44 |     l=a*b;
45 |     cout<<l/2;
46 |     return 0;
47 | }
48 | 


--------------------------------------------------------------------------------
/Reincarnation.CPP:
--------------------------------------------------------------------------------
 1 | In the world of numbers every number dies at some point and reincarnates. The newer generation will always surpass the previous generation and hence every number X upon incarnation will be promoted with a power Y i.e. X will now become X raised to the power Y. The god of the world of numbers needs a small break and hence has given you the task of reincarnating the incoming numbers after raising them to the power Y.
 2 | 
 3 | Input Format
 4 | 
 5 | Two numbers, X and Y.
 6 | 
 7 | Constraints
 8 | 
 9 | 1 <= X <= 10
10 | 0 <= Y <= 10
11 | 
12 | Output Format
13 | 
14 | One number, X raised to the power Y.
15 | 
16 | Sample Input 0
17 | 
18 | 2 4
19 | Sample Output 0
20 | 
21 | 16
22 | Explanation 0
23 | 
24 | 2 raised to the power 4 = 2 * 2 * 2 * 2 = 16
25 | 
26 | 
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 |     long long int a,b,c;
39 |     cin>>a>>b;
40 |     c=a;
41 |     if(b==0){
42 |         cout<<"1";
43 |     }
44 |     else{
45 |     for(int i=1;i<b;i++)
46 |     {
47 |         c=c*a;
48 |         
49 |     }
50 |     cout<<c;}
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/SmartFunction.CPP:
--------------------------------------------------------------------------------
 1 | The function myfunc takes 2 integers n and m as input. 
 2 | The fucntion accepts two integers ’n’ and ‘m’ as its argument. 
 3 | Implement the function to find the sum of ’n’ and ‘m’ and check if the number of digits in ’n’ and number of digits in sum of ’n’ and ‘m’ are same. 
 4 | If they are same then return the sum of ’n’ and ‘m’ else return ’n’.
 5 | 
 6 | Input Format
 7 | 
 8 | The function would be called by giving 2 integer inputs
 9 | 
10 | Constraints
11 | 
12 | 0<= N , M <= 100000
13 | 
14 | Output Format
15 | 
16 | Return the expected value
17 | 
18 | Sample Input 0
19 | 
20 | 178 62
21 | Sample Output 0
22 | 
23 | 240
24 | 
25 | 
26 | 
27 | #include <bits/stdc++.h>
28 | 
29 | using namespace std;
30 | 
31 | int MyFunc(int n, int m) {
32 |     // Complete this function
33 |     string s = to_string(n);
34 |     string sum = to_string(n+m);
35 |   //  cout<<s<<" "<<sum;
36 |     if(s.length()==sum.length()){
37 |         return n+m;
38 |     }
39 |     else return n;
40 | }
41 | 
42 | int main() {
43 |     int n;
44 |     int m;
45 |     cin >> n >> m;
46 |     vector<int> array(n);
47 |     for(int array_i = 0; array_i < n; array_i++){
48 |         cin >> array[array_i];
49 |     }
50 |     int result = MyFunc(n, m);
51 |     cout << result << endl;
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/7 divisible_pairs.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 | Sample Output 0
20 | 
21 | 2
22 | 
23 | 
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 t;
38 |     int rem[7] = {0};
39 |     for(int i=0;i<n;i++){
40 |         cin>>t;
41 |         rem[t%7]++;
42 |     }
43 |     int count = 0;
44 |     count+=(rem[1]*rem[6]);
45 |     count+=(rem[2]*rem[5]);
46 |     count+=(rem[3]*rem[4]);
47 |     count+=(rem[0]*(rem[0]-1)/2);
48 |     cout<<count;
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/LittleShino.CPP:
--------------------------------------------------------------------------------
 1 | Little Shino loves maths. Today her teacher gave her two integers. Shino is now wondering how many integers can divide both the numbers. She is busy with her assignments. Help her to solve the problem.
 2 | 
 3 | Input:
 4 | First line of the input file contains two integers, a and b.
 5 | 
 6 | Output:
 7 | Print the number of common factors of a and b.
 8 | 
 9 | Constraints:
10 | 
11 | SAMPLE INPUT 
12 | 10 15
13 | SAMPLE OUTPUT 
14 | 2
15 | Explanation
16 | The common factors of 10 and 15 are 1 and 5.
17 | 
18 | 
19 | 
20 | 
21 | #include<iostream> 
22 | #include<math.h>
23 | using namespace std; 
24 | 
25 | int gcd(int a, int b) 
26 | { 
27 | 	if (a == 0) 
28 | 		return b; 
29 | 	return gcd(b%a, a); 
30 | } 
31 | int commDiv(int a,int b) 
32 | { 
33 | 	// find gcd of a,b 
34 | 	int n = gcd(a, b); 
35 | 
36 | 	// Count divisors of n. 
37 | 	int result = 0; 
38 | 	for (int i=1; i<=sqrt(n); i++) 
39 | 	{ 
40 | 		// if 'i' is factor of n 
41 | 		if (n%i==0) 
42 | 		{ 
43 | 			// check if divisors are equal 
44 | 			if (n/i == i) 
45 | 				result += 1; 
46 | 			else
47 | 				result += 2; 
48 | 		} 
49 | 	} 
50 | 	return result; 
51 | } 
52 | 
53 | // Driver program to run the case 
54 | int main() 
55 | { 
56 | 	int a,b; 
57 | 	cin>>a>>b;
58 | 	
59 | 	cout << commDiv(a, b); 
60 | 	return 0; 
61 | } 
62 | 
63 | 


--------------------------------------------------------------------------------
/Pattern_printing9.C:
--------------------------------------------------------------------------------
 1 | Given a number N, print a pattern as shown below :
 2 | 
 3 | n = 1
 4 | *
 5 | 
 6 | n = 2
 7 |  *
 8 | ***
 9 |  *
10 | 
11 |  n = 3
12 |    *
13 |   ***
14 |  *****
15 |   ***
16 |    *
17 | and so on..
18 | Hint : Print the upper triangle and the lower reverse triangle separately.
19 | 
20 | Input Format
21 | 
22 | Only one integer, the number n.
23 | 
24 | Constraints
25 | 
26 | 1 <= n <= 100
27 | 
28 | Output Format
29 | 
30 | The required pattern
31 | 
32 | Sample Input 0
33 | 
34 | 1
35 | Sample Output 0
36 | 
37 | *
38 | 
39 | 
40 | #include <stdio.h>
41 | #include <string.h>
42 | #include <math.h>
43 | #include <stdlib.h>
44 | 
45 | int main() {
46 |   int n, c, k, space = 1;
47 |  
48 |   //printf("Enter number of rows\n");
49 |   scanf("%d", &n);
50 |  
51 |   space = n - 1;
52 |  
53 |   for (k = 1; k <= n; k++)
54 |   {
55 |     for (c = 1; c <= space; c++)
56 |       printf(" ");
57 |  
58 |     space--;
59 |  
60 |     for (c = 1; c <= 2*k-1; c++)
61 |       printf("*");
62 |  
63 |     printf("\n");
64 |   }
65 |  
66 |   space = 1;
67 |  
68 |   for (k = 1; k <= n - 1; k++)
69 |   {
70 |     for (c = 1; c <= space; c++)
71 |       printf(" ");
72 |  
73 |     space++;
74 |  
75 |     for (c = 1 ; c <= 2*(n-k)-1; c++)
76 |       printf("*");
77 |  
78 |     printf("\n");
79 |   }
80 |  
81 |   return 0;
82 | 
83 | }
84 | 


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


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


--------------------------------------------------------------------------------
/ParliamentSquare.CPP:
--------------------------------------------------------------------------------
 1 | 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.
 2 | 
 3 | 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.
 4 | 
 5 | Input Format
 6 | 
 7 | The input contains three positive integer numbers in the first line: n,  m and a.
 8 | 
 9 | Constraints
10 | 
11 | 1 ≤  n, m, a ≤ 10^9
12 | 
13 | Output Format
14 | 
15 | Write the needed number of flagstones.
16 | 
17 | Sample Input 0
18 | 
19 | 6 6 4
20 | Sample Output 0
21 | 
22 | 4
23 | 
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 a,b,c;
36 |     long long l,m;
37 |     cin>>a>>b>>c;
38 |     l=a/c;
39 |     if(a%c!=0){
40 |         l++;
41 |     }
42 |     m=b/c;
43 |     if(b%c!=0){
44 |         m++;
45 |     }
46 |     cout<<l*m<<"\n";
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/ConfusedInteger.CPP:
--------------------------------------------------------------------------------
 1 | 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.
 2 | 
 3 | Input Format
 4 | 
 5 | Input contains the value of integer X.
 6 | 
 7 | Constraints
 8 | 
 9 | 0 < X < 2x10^9
10 | 
11 | Output Format
12 | 
13 | Output "yes" if X can be expressed as A^P and "no" otherwise.
14 | 
15 | Sample Input 0
16 | 
17 | 4
18 | Sample Output 0
19 | 
20 | yes
21 | Explanation 0
22 | 
23 | Yes as 2^2 = 4
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 x,flag=0;
37 |     cin>>x;
38 |     if (x<2)
39 |     {cout<<"yes";
40 |         flag=1;}
41 |   
42 |     for (auto i = 2; i<=sqrt(x); i++)
43 |     {
44 |         for (auto j = 2; j<=32; j++)
45 |         {
46 |             if(pow(i, j)==x)
47 |             {cout<<"yes";
48 |                 flag=1;}
49 |         }
50 |     }
51 |     if(flag==0)
52 |         cout<<"no";
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/N_as_sum_of_primes.CPP:
--------------------------------------------------------------------------------
 1 | Given a number N, print "YES" if N can be expressed as a sum of 2 prime numbers and "NO" otherwise.
 2 | 
 3 | Input Format
 4 | 
 5 | One number, N.
 6 | 
 7 | Constraints
 8 | 
 9 | 1 <= N <= 10^5.
10 | 
11 | Output Format
12 | 
13 | "YES" or "NO"
14 | 
15 | Sample Input 0
16 | 
17 | 5
18 | Sample Output 0
19 | 
20 | YES
21 | Explanation 0
22 | 
23 | 5 = 2 + 3
24 | 
25 | Sample Input 1
26 | 
27 | 11
28 | Sample Output 1
29 | 
30 | NO
31 | 
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 power(int a, unsigned int n, int p){
43 |     int res = 1;
44 |     a = a % p;
45 |     while (n>0){
46 |         if (n & 1)
47 |             res = (res*a)%p;
48 |         n = n >> 1;
49 |         a = (a*a)%p;
50 |     }
51 |     return res;
52 | }
53 | 
54 | bool isPrime(int n, int k){
55 |     if (n==1 || (n%2==0 && n!=2))
56 |         return false;
57 |     if (n<=3)
58 |         return true;
59 |     while (k>0){
60 |         int a = 2 + rand()%(n-4);
61 |         if(power(a, n-1, n) != 1)
62 |             return false;
63 |         k--;
64 |     }
65 |     return true;
66 | }
67 | 
68 | 
69 | int main() {
70 |     int n;
71 |     cin >> n;
72 |     if (n%2==0)
73 |         cout << "YES";
74 |     else if(isPrime(n-2, 10))
75 |         cout << "YES";
76 |     else
77 |         cout << "NO";
78 |     return 0;
79 | }
80 | 


--------------------------------------------------------------------------------
/Let us xor.CPP:
--------------------------------------------------------------------------------
 1 | There are 2 positive integers a and b such that they have a sum of s and the bitwise XOR of the numbers is x. How many possible values exist for the ordered pair (a, b)?
 2 | 
 3 | Input Format
 4 | 
 5 | The first line of the input contains s and x, the sum and bitwise xor of the pair of positive integers, respectively.
 6 | 
 7 | Constraints
 8 | 
 9 | (2 ≤ s ≤ 1e12) where 1eN stands for Nth power of 10
10 | 
11 | (0 ≤ x ≤ 1e12) where 1eN stands for Nth power of 10
12 | 
13 | Output Format
14 | 
15 | Print a single integer, the number of solutions under the given conditions. If no solutions exist, then print 0.
16 | 
17 | Sample Input 0
18 | 
19 | 9 5
20 | Sample Output 0
21 | 
22 | 4
23 | Sample Input 1
24 | 
25 | 3 3
26 | Sample Output 1
27 | 
28 | 2
29 | Sample Input 2
30 | 
31 | 5 2
32 | Sample Output 2
33 | 
34 | 0
35 | 
36 | 
37 | 
38 | 
39 | #include<iostream>
40 | #include<cstdio>
41 | using namespace std;
42 | typedef long long ll;
43 | ll sum,XOR,AND;
44 | ll one_bits,res;
45 | 
46 | int main()
47 | {
48 |     scanf("%lld%lld",&sum,&XOR);
49 |     AND=(sum-XOR)/2;
50 |     if((sum-XOR)%2!=0||sum<XOR||(AND&XOR)!=0)
51 |         printf("0\n");
52 |     else{
53 |         one_bits=0;
54 |         while(XOR){
55 |             if(XOR&1)
56 |                 one_bits++;
57 |             XOR>>=1;
58 |         }
59 |         res=(1ll<<one_bits);
60 |         if(AND==0)
61 |             res-=2;
62 |         printf("%lld\n",res);
63 |     }
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/Char Compression.C:
--------------------------------------------------------------------------------
 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. You may choose to compress whatever characters you want. Only the length of the final string must be minimum.
 7 | 
 8 | INPUT
 9 | The input is one string that needs to be compressed.
10 | 
11 | OUTPUT
12 | Print the final compressed string of minimum length
13 | 
14 | CONSTRAINTS
15 | Length of input string will not be more than 1000.
16 | Input string will consist of lowercase english alphabets only.
17 | 
18 | Sample Input 0
19 | 
20 | bbaannaannaa
21 | Sample Output 0
22 | 
23 | banana
24 | Explanation 0
25 | 
26 | string "bbaannaannaa" can be compressed to "banana" by compressing every pair of adjacent equal characters.
27 | 
28 | 
29 | 
30 | 
31 | #include <cmath>
32 | #include <cstdio>
33 | #include <vector>
34 | #include <iostream>
35 | #include <cstring>
36 | #include <algorithm>
37 | using namespace std;
38 | 
39 | 
40 | int main() {
41 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
42 |     string s;
43 |     cin>>s;
44 |     int n=s.length();
45 |     for(int i=0;i<n;i++)
46 |     {
47 |         if(s[i]!=s[i+1])
48 |             cout<<s[i];
49 |     }
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/Count_the_primes.CPP:
--------------------------------------------------------------------------------
 1 | Jayraj attended the campus placement drive conducted by Amazon. In the technical round the interviewer asked the candidate to write an algorithm to count the number of primes in a given range. Jayaraj wrote an algorithm as he is good at logic building. But the interviewer asked him to code it. But Jayaraj was not good at coding. So please help him in writing the code by submitting your solution to this problem
 2 | 
 3 | Input Format
 4 | 
 5 | Two space seperated Integers indicating the first and last values
 6 | 
 7 | Constraints
 8 | 
 9 | 1<=first<=last<=10^12
10 | 
11 | Output Format
12 | 
13 | The count of prime number in that range
14 | 
15 | Sample Input 0
16 | 
17 | 1 10
18 | Sample Output 0
19 | 
20 | 4
21 | Explanation 0
22 | 
23 | The primes from 1 to 10 are 2,3,5,7
24 | 
25 | 
26 | 
27 | 
28 | #include <stdio.h>
29 | 
30 | #define N 100000005
31 | #define long long long
32 | #define max(x, y) ((x > y) ? x : y)
33 | 
34 | char comp[N], sieve[N];
35 | 
36 | int main()
37 | {
38 |     long a, b, i, j, ans = 0;
39 |     scanf("%lld %lld", &a, &b);
40 |     for(j = 2; j*j <= b; ++j)
41 |     {
42 |         if(sieve[j])
43 |             continue;
44 |         for(i = j+j; i*i <= b; i += j)
45 |             sieve[i] = 1;
46 |         for(i = j*max(2, a/j + (a%j > 0)); i <= b; i += j)
47 |             comp[i-a+1] = 1;
48 |     }
49 |     for(i = max(2, a); i <= b; ++i)
50 |         if(!comp[i-a+1])
51 |             ans++;
52 |     printf("%lld", ans);
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Lex Characters Unique.CPP:
--------------------------------------------------------------------------------
 1 | Given a string consisting of lowercase english letters only, print all the unique characters in it in lexicographically increasing order.
 2 | 
 3 | Input Format
 4 | 
 5 | One string S.
 6 | 
 7 | Constraints
 8 | 
 9 | 1 <= strlen(S) <= 1000
10 | 
11 | Output Format
12 | 
13 | One string consisting of the unique characters of string S in alphabetic order.
14 | 
15 | Sample Input 0
16 | 
17 | alohamora
18 | Sample Output 0
19 | 
20 | ahlmor
21 | 
22 | 
23 | 
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 |     string s;
36 |     cin>>s;
37 |     int flag;
38 |     string str="";
39 |     str+=s[0];
40 |     for(int i=1;i<s.length();i++){
41 |         flag = 0;
42 |         for(int j=0;j<str.length();j++){
43 |             if(str[j] == s[i]){
44 |                 flag = 1;
45 |                 break;
46 |             }
47 |         }
48 |         if(!flag){
49 |             str+=s[i];
50 |         }
51 |     }
52 |     
53 |     for(int i=0;i<str.length();i++){
54 |         for(int j=i+1;j<str.length();j++){
55 |             if(str[i]>str[j]){
56 |                 char temp = str[i];
57 |                 str[i] = str[j];
58 |                 str[j] = temp;
59 |             }
60 |         }
61 |     }
62 |     
63 |     cout<<str;
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/Blissfull pairs.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 | Sample Output 0
22 | 
23 | 4
24 | Explanation 0
25 | 
26 | All possible subarrays are :
27 | 1
28 | 1 2
29 | 1 2 3 
30 | 1 2 3 4 
31 | 1 2 3 4 5
32 | 2
33 | 2 3
34 | 2 3 4
35 | 2 3 4 5
36 | 3
37 | 3 4
38 | 3 4 5
39 | 4
40 | 4 5
41 | 5
42 | 
43 | The 4 unique pairs are : 
44 | (2, 1)
45 | (3, 2)
46 | (4, 3)
47 | (5, 4)
48 | 
49 | 
50 | 
51 | #include <cmath>
52 | #include <cstdio>
53 | #include <vector>
54 | #include <iostream>
55 | #include <stack>
56 | #include <algorithm>
57 | using namespace std;
58 | 
59 | 
60 | int main() {
61 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
62 |     int n;
63 |     cin >> n;
64 |     stack<int> s;
65 |     int ans = 0,temp;
66 |     for(int i = 0;i < n;i++)
67 |     {
68 |         cin >> temp;
69 |         while(!s.empty() && temp > s.top())
70 |         {
71 |             s.pop();
72 |             ans++;
73 |         }
74 |         if(!s.empty()) ans++;
75 |         s.push(temp);
76 |     }
77 |     cout << ans;
78 | }
79 | 


--------------------------------------------------------------------------------
/Array/Gfg/Relative_Sorting.CPP:
--------------------------------------------------------------------------------
 1 | Given two arrays A1[] and A2[] of size N and M respectively. 
 2 | The task is to sort A1 in such a way that the relative order among the elements will be same as those in A2. 
 3 | For the elements not present in A2, append them at last in sorted order. 
 4 | It is also given that the number of elements in A2[] are smaller than or equal to number of elements in A1[] and A2[] has all distinct elements.
 5 | 
 6 | Note: Expected time complexity is O(N log(N)).
 7 | 
 8 | 
 9 | #include<iostream>
10 | #include<map>
11 | #include<vector>
12 | using namespace std;
13 | 
14 | int main() {
15 | 	int t;
16 | 	cin>>t;
17 | 	while(t--)
18 | 	{
19 | 	    int n,m;
20 | 	    cin>>n>>m;
21 | 	    vector<int> arr(n);
22 | 	    for(int i=0;i<n;i++)
23 | 	    cin>>arr[i];
24 | 	    vector<int> brr(m);
25 | 	    for(int i=0;i<m;i++)
26 | 	    cin>>brr[i];
27 | 	    map<int,int> mp;
28 | 	    for(int i=0;i<n;i++)
29 | 	    {
30 | 	        mp[arr[i]]++;
31 | 	    }
32 | 	    for(int i=0;i<m;i++)
33 | 	    {
34 | 	        if(mp[brr[i]])
35 | 	        {
36 | 	            while(mp[brr[i]])
37 | 	            {
38 | 	                cout<<brr[i]<<" ";
39 | 	                mp[brr[i]]--;
40 | 	                
41 | 	            }
42 | 	        }
43 | 	    }
44 | 	   for(auto it=mp.begin();it!=mp.end();it++)
45 | 	   {
46 | 	       while(it->second)
47 | 	       {
48 | 	           cout<<it->first<<" ";
49 | 	           it->second--;
50 | 	       }
51 | 	   }
52 | 	   
53 | 	    cout<<endl;
54 | 	}
55 | 	return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/Array/Gfg/Search an element in a sorted and rotated array.CPP:
--------------------------------------------------------------------------------
 1 | // Search an element in sorted and rotated 
 2 | // array using single pass of Binary Search 
 3 | #include <bits/stdc++.h> 
 4 | using namespace std; 
 5 | 
 6 | // Returns index of key in arr[l..h] if 
 7 | // key is present, otherwise returns -1 
 8 | int search(int arr[], int l, int h, int key) 
 9 | { 
10 | 	if (l > h) return -1; 
11 | 
12 | 	int mid = (l+h)/2; 
13 | 	if (arr[mid] == key) return mid; 
14 | 
15 | 	/* If arr[l...mid] is sorted */
16 | 	if (arr[l] <= arr[mid]) 
17 | 	{ 
18 | 		/* As this subarray is sorted, we can quickly 
19 | 		check if key lies in half or other half */
20 | 		if (key >= arr[l] && key <= arr[mid]) 
21 | 		return search(arr, l, mid-1, key); 
22 | 		/*If key not lies in first half subarray, 
23 | 		Divide other half into two subarrays, 
24 | 		such that we can quickly check if key lies 
25 | 		in other half */
26 | 		return search(arr, mid+1, h, key); 
27 | 	} 
28 | 
29 | 	/* If arr[l..mid] first subarray is not sorted, then arr[mid... h] 
30 | 	must be sorted subarray */
31 | 	if (key >= arr[mid] && key <= arr[h]) 
32 | 		return search(arr, mid+1, h, key); 
33 | 
34 | 	return search(arr, l, mid-1, key); 
35 | } 
36 | 
37 | // Driver program 
38 | int main() 
39 | { 
40 | 	int arr[] = {4, 5, 6, 7, 8, 9, 1, 2, 3}; 
41 | 	int n = sizeof(arr)/sizeof(arr[0]); 
42 | 	int key = 6; 
43 | 	int i = search(arr, 0, n-1, key); 
44 | 
45 | 	if (i != -1) 
46 | 	cout << "Index: " << i << endl; 
47 | 	else
48 | 	cout << "Key not found"; 
49 | } 
50 | 


--------------------------------------------------------------------------------
/Athletic_Akhil.CPP:
--------------------------------------------------------------------------------
 1 | Akhil is an athlete.
 2 | 
 3 | As a part of his training he started working on his jumping skills recently. Currently he's located at point 0. He needs to get to the point x as a part of his training regime.
 4 | 
 5 | To make the training more fruitful, he has decided that he'll first jump by only one unit, and each subsequent jump will be exactly one longer than the previous one. He can go either left or right with each jump. He wonders how many jumps he needs to reach the point x.
 6 | 
 7 | Input Format
 8 | 
 9 | The input data consists of only one integer x
10 | 
11 | Constraints
12 | 
13 | ( - 1e9 ≤ x ≤ 1e9) where 1eN stands for Nth power of 10
14 | 
15 | Output Format
16 | 
17 | Output the minimal number of jumps that Akhil requires to reach x.
18 | 
19 | Sample Input 0
20 | 
21 | 2
22 | Sample Output 0
23 | 
24 | 3
25 | Sample Input 1
26 | 
27 | 6
28 | Sample Output 1
29 | 
30 | 3
31 | Sample Input 2
32 | 
33 | 0
34 | Sample Output 2
35 | 
36 | 0
37 | 
38 | 
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 |   
51 | 
52 | 
53 |     long long x;
54 |     scanf("%lld",&x);
55 |     if(x<0)x=-x;
56 |     int n= 0;
57 |     int current = 0;
58 |     while(current<x||(current-x)%2)
59 |     {
60 |         n++;
61 |         current = current + n;
62 |     }
63 |     cout<<n<<endl;
64 | }
65 | 


--------------------------------------------------------------------------------
/Sorted_team.CPP:
--------------------------------------------------------------------------------
 1 | 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.
 2 | 
 3 | Formally, use the selection sort technique to sort the array of player heights.
 4 | 
 5 | INPUT
 6 | 
 7 | 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.
 8 | 
 9 | OUTPUT
10 | 
11 | Print the heights of the players in a line after the sorting routine.
12 | 
13 | Sample Input 0
14 | 
15 | 8
16 | 3 4 5 2 4 10 18 1
17 | Sample Output 0
18 | 
19 | 1 2 3 4 4 5 10 18 
20 | 
21 | 
22 | 
23 | 
24 | #include <cmath>
25 | #include <cstdio>
26 | #include <vector>
27 | #include <iostream>
28 | #include <algorithm>
29 | using namespace std;
30 | int main() {
31 |     int n;
32 |     cin>>n;
33 |     int i,arr[n];
34 |     for(i=0;i<n;i++)
35 |         cin>>arr[i];
36 |     int k=n-1;
37 |     int temp=0,index;
38 |     int b[n];
39 |     for(i=0;i<n;i++)
40 |         b[i]=arr[i];
41 |     sort(b,b+n);
42 |     while(k--)
43 |     {
44 |         for(i=0;i<n;i++)
45 |         {
46 |             if(b[temp]==arr[i])
47 |             {
48 |                 index=i;
49 |             }
50 |         }
51 |         swap(arr[temp],arr[index]);
52 |         temp++;
53 |     }
54 |     for(i=0;i<n;i++)
55 |         cout<<arr[i]<<" ";
56 |     return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/Array_as_a_hill.CPP:
--------------------------------------------------------------------------------
 1 | Array of integers is a mountain, if:
 2 | 
 3 | it is strictly increasing in the beginning;
 4 | after that it is constant;
 5 | after that it is strictly decreasing.
 6 | The first block (increasing) and the last block (decreasing) may be absent. It is allowed that both of this blocks are absent.
 7 | For example, the following three arrays are a mountain: [5, 7, 11, 11, 2, 1], [4, 4, 2], [7],
 8 | but the following three are not unimodal: [5, 5, 6, 6, 1], [1, 2, 1, 2], [4, 5, 5, 6].
 9 | 
10 | Write a program that checks if an array is a mountain.
11 | 
12 | Input Format
13 | 
14 | The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array.
15 | 
16 | The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 1000) — the elements of the array.
17 | 
18 | Output Format
19 | 
20 | Print "yes" if the given array is a mountain. Otherwise, print "no".
21 | 
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 |     
34 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
35 |      int n,a[100],i;
36 |      cin>>n;
37 |     for(i=1; i<=n; i++)
38 |     {
39 |         cin>>a[i];
40 |     }
41 |     int f1=1;
42 |     a[n+1]=a[0]=1<<30;
43 |     int f=2;
44 |     while(a[f]>a[f-1]) f++;
45 |     while(a[f]==a[f-1]) f++;
46 |     while(a[f]<a[f-1]) f++;
47 |     if(f<=n) cout<<"no"<<endl;
48 |     else cout<<"yes"<<endl;
49 |     return 0;
50 | }
51 | 
52 | 


--------------------------------------------------------------------------------
/Friendshipended.CPP:
--------------------------------------------------------------------------------
 1 | Ramesh is learning to chat on Facebook and he wants to say “Goodbye” (no space between Good and bye) to his friend Suresh. Ramesh typed the word w. It is considered that Ramesh managed to say “Goodbye” if several letters can be deleted from the typed word w so that it results in the word "Goodbye". For example, if Ramesh types the word "btaGpotodbqqyeekje", it will be considered that he said “Goodbye”, and if he types "pngodtbeyz", it will be considered that he didn't manage to say Goodbye. Determine whether Ramesh managed to say “Goodbye” by the given word w to Suresh.
 2 | 
 3 | Input
 4 | Input contains one string. 
 5 | Input string consists of small and capital alphabets only.
 6 | 
 7 | Output
 8 | Output 'Yes' if he managed to say goodbye. else output 'No'.
 9 | 
10 | Sample Input 0
11 | 
12 | btaGpotodbqqyeekje
13 | Sample Output 0
14 | 
15 | Yes
16 | 
17 | 
18 | #include <string.h>
19 | #include <cstdio>
20 | #include <vector>
21 | #include <iostream>
22 | #include <algorithm>
23 | using namespace std;
24 | 
25 | 
26 | int main() {
27 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
28 |     string s;
29 |     cin>>s;
30 |     int i,c=0;
31 |     string s1="Goodbye";
32 |     int len=s.length();
33 |     int k=0;
34 |     for(i=0;i<len;i++)
35 |     {
36 |         if(s[i]==s1[k])
37 |         {
38 |             c++;
39 |             k++;
40 |         }
41 |     }
42 |     if(c==7)
43 |     {
44 |         cout<<"Yes";
45 |     }
46 |     else
47 |     {
48 |         cout<<"No";
49 |     }
50 |     return 0;
51 | }
52 | 
53 | 


--------------------------------------------------------------------------------
/Vowel Repitition.CPP:
--------------------------------------------------------------------------------
 1 | Luffy likes to repeat vowel letters when he writes word.For example instead of the word "onepiece" he can write "oneeepiiiceeee"
 2 | Zoro does not like this bhevior so he wants to write the program to the format words written by luffy.This program must convert all consecutive vowels to single vowels
 3 | The vowel letters include "a","e","i","o","u" and "y".
 4 | There are exceptions if letters "e" or "o" repeat in a row exactly 2 times like in words "feet" and "foot",the program must skip them and do not transform them into the vowel.
 5 | 
 6 | 
 7 | 
 8 | Sample Input0
 9 | 13
10 | pobeeeedaaaaa
11 | 
12 | Sample Output0
13 | pobeda
14 | 
15 | 
16 | Sample Input1
17 | 22
18 | iiiimpleeemeentatiioon
19 | 
20 | Sample Output1
21 | implemeentatioon
22 | 
23 | 
24 | #include<iostream>
25 | #include<cstring>
26 | using namespace std;
27 | 
28 | int main(){
29 | string s;
30 | int n,k;
31 | cin>>n;
32 | cin>>s;
33 | for(int i=0;i<n;i++){
34 |     if(s[i]!='a' && s[i]!='e' && s[i]!='i' && s[i]!='o' && s[i]!='u')
35 |     {
36 |     cout<<s[i];
37 |     }
38 |     else if(s[i]=='a' || s[i]=='i' || s[i]=='u'){
39 |     cout<<s[i];
40 |     k=i;
41 |     while(s[k]==s[i])
42 |     {
43 |     i++;
44 |     }
45 |     i--;
46 |     }
47 |     else if(s[i]=='e' || s[i]=='o')
48 |     {
49 |     if(s[i]!=s[i+2] && s[i]==s[i+1])
50 |     {
51 |     cout<<s[i]<<s[i+1];
52 |     i=i+1;
53 |     }
54 |     else
55 |     {
56 |     cout<<s[i];
57 |     k=i;
58 |     while(s[k]==s[i]){
59 |     i++;
60 |     }
61 |     i--;
62 |     }
63 |     }
64 | } 
65 | return 0;
66 | }
67 | 


--------------------------------------------------------------------------------
/Color the Fence(Love).CPP:
--------------------------------------------------------------------------------
 1 | Igor has fallen in love with Tanya. Now Igor wants to show his feelings and write a number on the fence opposite to Tanya's house. Igor thinks that the larger the number is, the more chance to win Tanya's heart he has.
 2 | 
 3 | Unfortunately, Igor could only get v liters of paint. He did the math and concluded that digit d requires ad liters of paint. Besides, Igor heard that Tanya doesn't like zeroes. That's why Igor won't use them in his number.
 4 | 
 5 | Help Igor find the maximum number he can write on the fence.
 6 | 
 7 | Input
 8 | The first line contains a positive integer v (0 ≤ v ≤ 106). The second line contains nine positive integers a1, a2, ..., a9 (1 ≤ ai ≤ 105).
 9 | 
10 | Output
11 | Print the maximum number Igor can write on the fence. If he has too little paint for any digit (so, he cannot write anything), print -1.
12 | 
13 | Examples
14 | input
15 | 5
16 | 5 4 3 2 1 2 3 4 5
17 | output
18 | 55555
19 | 
20 | input
21 | 2
22 | 9 11 1 12 5 8 9 10 6
23 | output
24 | 33
25 | 
26 | input
27 | 0
28 | 1 1 1 1 1 1 1 1 1
29 | output
30 | -1
31 | 
32 | 
33 | 
34 | #include<bits/stdc++.h>
35 | using namespace std ;
36 | int a[10]  , l , m = 1e9 ;
37 | int main()
38 | {
39 | 	int n ;
40 | 	cin >> n ;
41 | 	for ( int i = 1 ; i<=9 ; i++)
42 | 		cin >> a[i], m = min( m , a[i] ) ;
43 | 	l = n/m;
44 | 	if ( l== 0 ) 
45 | 	{
46 | 		cout << -1 ;
47 | 		return 0 ;
48 | 	}
49 | 	while ( l-- ) 
50 | 		for ( int i =9 ; i>= 0 ; i--)
51 | 			if ((n-a[i]) / m == l && n>=a[i]) 
52 | 			{
53 | 				cout << i ;
54 | 				n-=a[i] ;
55 | 				break ;
56 | 			}
57 | 
58 | }
59 | 


--------------------------------------------------------------------------------
/OS/FCFS.CPP:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | void waitingtime(int p[],int n,int bt[],int wt[],int at[]){
 4 |     int ct[n];
 5 |     ct[0]=0;
 6 |     wt[0]=0;
 7 |     for(int i=1;i<n;i++){
 8 |         ct[i]=bt[i-1]+ct[i-1];
 9 |         wt[i]=ct[i]-at[i];
10 |         if(wt[i]<0)
11 |             wt[i]=0;
12 |     }
13 | }
14 | 
15 | void turnaroundtime(int p[],int n,int bt[],int wt[],int tat[]){
16 |     for(int i=0;i<n;i++)
17 |         tat[i]=bt[i]+wt[i];
18 | }
19 | void avgtime(int p[],int n,int bt[],int at[])
20 | {
21 |     int wt[n],tat[n];
22 |     waitingtime(p,n,bt,wt,at);
23 |     turnaroundtime(p,n,bt,wt,tat);
24 |     cout<<"Processes"<<"Burst Time"<<"Arrival Time"<<"Waiting Time"<<"TurnAround Time\n";
25 |     int t_wt=0,t_tat=0;
26 |     for(int i=0;i<n;i++){
27 |         t_wt=t_wt+wt[i];
28 |         t_tat=t_tat+tat[i];
29 |         cout << " " << i+1 << "\t\t" << bt[i] << "\t\t"
30 |              << at[i] << "\t\t" << wt[i] << "\t\t "
31 |              << tat[i]  <<  "\n";
32 |     }
33 |       cout << "Average waiting time = "
34 |          << (float)t_wt / (float)n; 
35 |     cout << "\nAverage turn around time = "
36 |          << (float)t_tat / (float)n; 
37 | } 
38 | int main(){
39 |      int processes[] = {1, 2, 3}; 
40 |     int n = sizeof processes / sizeof processes[0]; 
41 |   
42 |     // Burst time of all processes 
43 |     int burst_time[] = {5, 9, 6}; 
44 |   
45 |     // Arrival time of all processes 
46 |     int arrival_time[] = {0, 3, 6}; 
47 |   
48 |     avgtime(processes, n, burst_time, arrival_time); 
49 |   return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/*rotate the array.CPP:
--------------------------------------------------------------------------------
 1 | Given an array of integers of size n, rotate it's elements towards right K times.
 2 | 
 3 | Note: One rotation of the array (a0, a1, a2... an-1, an) results into (an, a1, a2...., an-2, an-1).
 4 | 
 5 | Explanation for a Sample i/o
 6 | 
 7 | Sample Input: 5 1 3 5 7 9 3
 8 | 
 9 | Sample Output: 5 7 9 1 3
10 | 
11 | Explanation: We have to perform 3 rotations : 1st rotation : 9 1 3 5 7 2nd rotation : 7 9 1 3 5 3rd rotation : 5 7 9 1 3
12 | 
13 |     
14 | Input Format
15 | 
16 | First line contains an integer n. Second line contains n integers, denoting the array a[n]. Third line contains one integer k, the number of times the array is to be rotated.
17 | 
18 | Constraints
19 | 
20 | 1 <= n <= 1000
21 | 
22 | Output Format
23 | 
24 | Output n integers, denoting the array a[n] after rotation.
25 | 
26 | Sample Input 0
27 | 
28 | 5
29 | 1 3 5 7 9
30 | 3
31 | Sample Output 0
32 | 
33 | 5 7 9 1 3 
34 | 
35 | 
36 | 
37 | #include <stdio.h>
38 | #include <string.h>
39 | #include <math.h>
40 | #include <stdlib.h>
41 | 
42 | int main() {
43 | 
44 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
45 |     int n;
46 |     scanf("%d",&n);
47 |     int a[n];
48 |     for(int i=0;i<n;i++)
49 |         scanf("%d",&a[i]);
50 |     int k;
51 |     scanf("%d",&k);
52 |     
53 |     int b[n];
54 |     for(int i=n-1;i>=0;i--){
55 |         if(i+k>=n) {
56 |             int p=(i+k)%n;
57 |             b[p]=a[i];
58 |         }else b[i+k]=a[i];
59 |     }
60 |     
61 |     
62 |     for(int i=0;i<n;i++)
63 |         printf("%d ",b[i]);
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/BS !.CPP:
--------------------------------------------------------------------------------
 1 | You are given two arrays of integers a and b. For each element of the second array bj you should find the number of elements in array a that are less than or equal to the value bj.
 2 | 
 3 | Input Format
 4 | 
 5 | The first line contains two integers n, m — the sizes of arrays a and b. The second line contains n integers — the elements of array a.
 6 | 
 7 | The third line contains m integers — the elements of array b.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= n, m <= 200
12 | - 10^9 <= ai <= 10^9
13 | - 10^9 <= bj <= 10^9
14 | 
15 | Output Format
16 | 
17 | Print m integers, separated by spaces: the j-th of which is equal to the number of such elements in array a that are less than or equal to the value bj.
18 | 
19 | Sample Input 0
20 | 
21 | 5 4
22 | 1 3 5 7 9
23 | 6 4 2 8
24 | Sample Output 0
25 | 
26 | 3 2 1 4 
27 | 
28 | 
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 |     long long int n,m;
41 |     cin>>n>>m;
42 |     long long int i,arr[n],brr[m],count[m],j;
43 |     for(i=0;i<n;i++)
44 |         cin>>arr[i];
45 |     for(i=0;i<m;i++)
46 |         cin>>brr[i];
47 |     sort(arr,arr+n);
48 |     for(i=0;i<m;i++)
49 |         count[i]=0;
50 |     for(i=0;i<m;i++)
51 |     {
52 |         for(j=0;j<n;j++)
53 |         {
54 |             if(brr[i]>=arr[j])
55 |                 count[i]++;
56 |             else
57 |                 break;
58 |         }
59 |     }
60 |     for(i=0;i<m;i++)
61 |         cout<<count[i]<<" ";
62 |     return 0;
63 | }
64 | 


--------------------------------------------------------------------------------
/Greatestnumberwithdigits.CPP:
--------------------------------------------------------------------------------
 1 | #include <cmath>
 2 | #include <cstdio>
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | 
 8 | 
 9 | void findMaximumNum(string str, int k, string& max) 
10 | { 
11 |     // return if no swaps left 
12 |     if(k == 0) 
13 |         return; 
14 |   
15 |     int n = str.length(); 
16 |       
17 |     // consider every digit 
18 |     for (int i = 0; i < n - 1; i++) 
19 |     { 
20 |        
21 |         // and compare it with all digits after it 
22 |         for (int j = i + 1; j < n; j++) 
23 |         { 
24 |             // if digit at position i is less than digit 
25 |             // at position j, swap it and check for maximum 
26 |             // number so far and recurse for remaining swaps 
27 |             if (str[i] < str[j]) 
28 |             { 
29 |                 // swap str[i] with str[j] 
30 |                 swap(str[i], str[j]); 
31 |   
32 |                 // If current num is more than maximum so far 
33 |                 if (str.compare(max) > 0) 
34 |                     max = str; 
35 |   
36 |                 // recurse of the other k - 1 swaps 
37 |                 findMaximumNum(str, k - 1, max); 
38 |   
39 |                 // backtrack 
40 |                 swap(str[i], str[j]); 
41 |             } 
42 |         } 
43 |     } 
44 | } 
45 |   
46 | // Driver code 
47 | int main() 
48 | { 
49 |     string str ;
50 |     cin>>str;
51 |   
52 |     int k = 4; 
53 |   
54 |     string max = str; 
55 |     findMaximumNum(str, k, max); 
56 |   
57 |     cout << max << endl; 
58 |   
59 |     return 0; 
60 | } 
61 | 


--------------------------------------------------------------------------------
/Consecutiveprimesum.CPP:
--------------------------------------------------------------------------------
 1 | Some prime numbers can be expressed as Sum of other consecutive prime numbers.
 2 | 
 3 | For example
 4 | 
 5 | 5 = 2 + 3 
 6 | 17 = 2 + 3 + 5 + 7 
 7 | 41 = 2 + 3 + 5 + 7 + 11 + 13
 8 | 
 9 | 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.
10 | 
11 | Write code to find out number of prime numbers that satisfy the above mentioned property in a given range.
12 | 
13 | Input Format:
14 | Each test case contains a number N <= 1000000000
15 | 
16 | Output Format:
17 | Print the total number of all such prime numbers which are less than or equal to N.
18 | 
19 | 
20 | 
21 | 
22 | #include <cmath>
23 | #include <cstdio>
24 | #include <vector>
25 | #include <iostream>
26 | #include <algorithm>
27 | using namespace std;
28 | 
29 | 
30 | bool isPrime(int n){
31 |     if(n<=1)
32 |         return false;
33 |     for(int i=2;i<=sqrt(n);i++){
34 |         if(n%i==0)
35 |             return false;
36 |     }
37 |     return true;
38 | }
39 | 
40 | int main() {
41 | 
42 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
43 |     int n;
44 |     cin>>n;
45 |     int sum=2,count=0;
46 |     if(n<5){
47 |         cout<<0;
48 |         return 0;
49 |     }
50 |     for(int i=3;sum<=n;i++){
51 |         if(isPrime(i)){
52 |             sum+=i;
53 |             if(sum<=n){
54 |                 if(isPrime(sum)){
55 |                     count++;
56 |                 }
57 |             }
58 |             
59 |         }
60 |     }
61 |     cout<<count;
62 |     return 0;
63 | }
64 | 


--------------------------------------------------------------------------------
/Coders_day.CPP:
--------------------------------------------------------------------------------
 1 | Input Format
 2 | 
 3 | A single integer denoting the year y.
 4 | 
 5 | Constraints
 6 | 
 7 | 1700 <= y <= 2700
 8 | 
 9 | Output Format
10 | 
11 | Print the full date of Day of the Programmer during year y in the format dd.mm.yyyy, where dd is the two-digit day, mm is the two-digit month, and yyyy is y.
12 | 
13 | Sample Input 0
14 | 
15 | 2017
16 | Sample Output 0
17 | 
18 | 13.09.2017
19 | 
20 | 
21 | #include <cmath>
22 | #include <cstdio>
23 | #include <vector>
24 | #include <iostream>
25 | #include <algorithm>
26 | using namespace std;
27 | 
28 | 
29 | int main() {
30 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
31 |     int n,s;
32 |     s=0;
33 |     cin>>n;
34 |     if(n>=1700&&n<=1917)
35 |     {
36 |     if(n%4==0)
37 |     {
38 |         s=s+31+29+31+30+31+30+31+31;
39 |        // cout<<s;
40 |         int diff=256-s;
41 |         cout<<diff<<".09."<<n;
42 |     }
43 |     else
44 |         {
45 |         s=s+31+28+31+30+31+30+31+31;
46 |         //cout<<s;
47 |         int diff=256-s;
48 |         cout<<diff<<".09."<<n;
49 |     }
50 |     }
51 |      if(n>=1919)
52 |     {
53 |         if((n%400==0)||(n%4==0 && n%100!=0))
54 |             {
55 |         s=s+31+29+31+30+31+30+31+31;
56 |        // cout<<s;
57 |         int diff=256-s;
58 |         cout<<diff<<".09."<<n;
59 |     }
60 |     else
61 |         {
62 |         s=s+31+28+31+30+31+30+31+31;
63 |         //cout<<s;
64 |         int diff=256-s;
65 |         cout<<diff<<".09."<<n;
66 |     }
67 |     }
68 |     if(n==1918)
69 |     {
70 |         
71 |         cout<<"26.09."<<n; 
72 |     }
73 |         
74 |     return 0;
75 | }
76 | 


--------------------------------------------------------------------------------
/CircularQueue.CPP:
--------------------------------------------------------------------------------
 1 | #include "stdio.h"
 2 | #include "string.h"
 3 | #include "stdlib.h"
 4 | #include "math.h"
 5 | struct queueNode{
 6 |     int data;
 7 |     struct queueNode* next;
 8 | };
 9 | typedef struct queueNode queueNode;
10 | queueNode* head = NULL;
11 | queueNode* newNode(int val)
12 | {
13 |     queueNode* t = (queueNode*) malloc(sizeof(queueNode));
14 |     t->data = val;
15 |     t->next = NULL;
16 |     return t;
17 | }
18 | 
19 | void push(int val)
20 | {
21 |     queueNode* p,*p1;
22 |     p=newNode(val);
23 |    
24 |       if(head==NULL)
25 |         head=p;
26 |     else
27 |     {
28 |         p1=head;
29 |     while(p1->next!=NULL)
30 |     {
31 |     p1=p1->next;
32 |     }
33 |     p1->next=p;
34 |     }
35 | }
36 | void pop()
37 | {
38 |      queueNode* p1;
39 |       
40 |      p1=head;
41 |     head=head->next;
42 |     p1->next=NULL;
43 | }
44 | int top()
45 | {
46 |     return head->data;
47 | }
48 | int empty()
49 | {
50 |     return (head==NULL);
51 | 
52 | }
53 | int main()
54 | {
55 |     int n;
56 |     scanf("%d", &n);
57 |     for (int i = 0; i < n; i++)
58 |     {
59 |         char s[50];
60 |         int x;
61 |         scanf(" %s", s);
62 |         if (s[0] == 't')
63 |         {
64 |             if (empty()) printf("Invalid\n");
65 |             else                
66 |                 printf("%d\n", top());
67 |         }
68 |         else if (s[0] == 'p' && s[1] == 'o')
69 |         {
70 |             if (empty()) printf("Invalid\n");
71 |             else    pop();
72 |         }
73 |         else
74 |         {
75 |             scanf(" %d", &x);
76 |             push(x);
77 |         }
78 |     }
79 |     return 0;
80 | }
81 | 


--------------------------------------------------------------------------------
/Eat less.CPP:
--------------------------------------------------------------------------------
 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 | 
 3 | 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.
 4 | 
 5 | Notes: Has to be done greedily so that you have to burn as less calories as possible
 6 | 
 7 | Input Format
 8 | 
 9 | 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].
10 | 
11 | Constraints
12 | 
13 | 1<=n<=40 1<=ci<=1000
14 | 
15 | Output Format
16 | 
17 | Print a long integer denoting the minimum number of miles Marc must walk to maintain his weight.
18 | 
19 | Sample Input 0
20 | 
21 | 3
22 | 1 3 2
23 | Sample Output 0
24 | 
25 | 11
26 | 
27 | 
28 | 
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 |     long long n;
41 |     cin>>n;
42 |     long long a[n],i,j=0,s=0;
43 |     for(i=0;i<n;i++)
44 |         cin>>a[i];
45 |     sort(a,a+n,greater<>());
46 |     for(i=0;i<n;i++)
47 |     {
48 |         s+=pow(2,j)*a[i];
49 |         j++;
50 |     }
51 |     cout<<s;
52 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/RomantoDecimal.CPP:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<string.h>
 3 |  
 4 | int digit(char);
 5 |  
 6 | int main(){
 7 |  
 8 |     char roman_Number[1000];
 9 |     int i=0;
10 |     long int number =0;
11 |  
12 |     printf("Enter any roman number (Valid digits are I, V, X, L, C, D, M):  \n");
13 |     scanf("%s",roman_Number);
14 |  
15 |     while(roman_Number[i]!=0){
16 |  
17 |          if(digit(roman_Number[i]) < 0){
18 |              printf("Invalid roman digit : %c",roman_Number[i]);
19 |              return 0;
20 |          }
21 |  
22 |          if((strlen(roman_Number) -i) > 2){
23 |              if(digit(roman_Number[i]) < digit(roman_Number[i+2])){
24 |                  printf("Invalid roman number");
25 |                  return 0;
26 |              }
27 |          }
28 |  
29 |          if(digit(roman_Number[i]) >= digit(roman_Number[i+1]))
30 |              number = number + digit(roman_Number[i]);
31 |          else{
32 |              number = number + (digit(roman_Number[i+1]) - digit(roman_Number[i]));
33 |              i++;
34 |          }
35 |          i++;
36 |     }
37 |  
38 |     printf("Its decimal value is : %ld",number);
39 |  
40 |     return 0;
41 |  
42 | }
43 |  
44 | int digit(char c){
45 |  
46 |     int value=0;
47 |  
48 |     switch(c){
49 |          case 'I': value = 1; break;
50 |          case 'V': value = 5; break;
51 |          case 'X': value = 10; break;
52 |          case 'L': value = 50; break;
53 |          case 'C': value = 100; break;
54 |          case 'D': value = 500; break;
55 |          case 'M': value = 1000; break;
56 |          case '\0': value = 0; break;
57 |          default: value = -1; 
58 |     }
59 |  
60 |     return value;
61 | }
62 | 


--------------------------------------------------------------------------------
/Electronic_Store_Sort.CPP:
--------------------------------------------------------------------------------
 1 | 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.
 2 | 
 3 | 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.
 4 | 
 5 | INPUT
 6 | 
 7 | 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) 
 8 | the first n - 1 of which are standing in ascending order according to their battery percentage.
 9 | 
10 | OUTPUT
11 | 
12 | Print the battery percentages of the customers in a line after the new person has been put in his right place in the queue.
13 | 
14 | Sample Input 0
15 | 
16 | 6
17 | 1 3 5 7 9 4
18 | Sample Output 0
19 | 
20 | 1 3 4 5 7 9 
21 | 
22 | 
23 | 
24 | #include <cmath>
25 | #include <cstdio>
26 | #include <vector>
27 | #include <iostream>
28 | #include <algorithm>
29 | using namespace std;
30 | int main() {
31 |     int n;
32 |     cin>>n;
33 |     int arr[n],i,j;
34 |     for(i=0;i<n;i++)
35 |         cin>>arr[i];
36 |     int key;
37 |     for(j=1;j<n;j++)
38 |     {
39 |         key=arr[j];
40 |         i=j-1;
41 |         while(i>0&&arr[i]>key)
42 |         {
43 |             arr[i+1]=arr[i];
44 |             i=i-1;
45 |         }
46 |         arr[i+1]=key;
47 |     }
48 |     
49 |     for(i=0;i<n;i++)
50 |         cout<<arr[i]<<" ";
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/HappySighting.C:
--------------------------------------------------------------------------------
 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 | Sample Input 0
21 | 
22 | 4
23 | 200 100 100 200
24 | Sample Output 0
25 | 
26 | 2
27 | Explanation 0
28 | 
29 | Sample Ordering that gives answer 2 :
30 | 
31 | 100 200 100 200
32 | 
33 | 
34 | 
35 | #include <stdio.h>
36 | #include <string.h>
37 | #include <math.h>
38 | #include <stdlib.h>
39 | int n,x,a[1005],cnt,ans;
40 | int main(){
41 |     scanf("%d",&n);
42 |     //cin>>n;
43 |     for (int i=1;i<=n;i++){
44 |         scanf("%d",&x);
45 |         //cin>>x;
46 |         a[x]++;
47 |     }
48 |     while (1){
49 |      if (n==0) break;
50 |      int cnt=0;
51 |      for (int i=1;i<=1000;i++) if (a[i]) cnt++,a[i]--,n--;
52 |      ans+=cnt-1;
53 |     }
54 |    printf("%d\n",ans);
55 |     //cout<<ans;
56 | }
57 | 
58 | 
59 | 
60 | 
61 | 


--------------------------------------------------------------------------------
/Stackusingarray.C:
--------------------------------------------------------------------------------
 1 | 
 2 | //HEAD
 3 | 
 4 | #include "stdio.h"
 5 | #include "string.h"
 6 | #include "stdlib.h"
 7 | #include "math.h"
 8 | 
 9 | //BODY
10 | 
11 | int stackArr[100005];
12 | int top = -1;// - Stores the index of the topmost element on the stack
13 | void push(int x){
14 | top++;
15 | stackArr[top]=x;
16 | } //- Insert an element onto the top of the stack
17 | int peek(){
18 | return stackArr[top];
19 | } //- Returns the topmost element on the stack
20 | void pop(){
21 | stackArr[top]=NULL;
22 | top--;
23 | } //- Removes an element from the top of the stack
24 | int empty(){
25 | if(top==-1)
26 | return 1;
27 | else
28 | return 0;
29 | }// - Returns 1 if the stack is empty and 0 otherwise
30 | 
31 | //TAIL
32 | 
33 | int main()
34 | {
35 |     int n;
36 |     top = -1;
37 |     scanf("%d", &n);
38 |     for (int i = 0; i < n; i++) {
39 |         int t, x;
40 |         scanf("%d", &t);
41 |         if (t == 1) {
42 |             scanf("%d", &x);
43 |             push(x);
44 |         }
45 |         else if (t == 2) {
46 |             if (empty()) {
47 |                 printf("Invalid\n");
48 |             }
49 |             else {
50 |                 pop();
51 |             }
52 |         }
53 |         else if (t == 3){
54 |             if (empty()) {
55 |                 printf("Invalid\n");
56 |                 continue;
57 |             }
58 |             for (int j = top; j >= 0; j--) {
59 |                 printf("%d ", stackArr[j]);
60 |             }printf("\n");
61 |         }
62 |         else {
63 |             if (empty()) {
64 |                 printf("Invalid\n");
65 |                 continue;
66 |             }
67 |             printf("%d\n", peek());
68 |         }
69 |     }
70 |     return 0;
71 | }
72 | 
73 | 


--------------------------------------------------------------------------------
/Canadian to turn off light bulb.CPP:
--------------------------------------------------------------------------------
 1 | Robin Scherbatsky, a proud canadian wants to turn on all the light bulbs.
 2 | But since she is a Canadian and she is scared to go into the dark.
 3 | 
 4 | N light bulbs are connected by a wire. Each bulb has a switch associated with it, however due to faulty wiring, a switch also changes the state of all the bulbs to the right of current bulb. Given an initial state of all bulbs, find the minimum number of switches you have to press to turn on all the bulbs. You can press the same switch multiple times.
 5 | 
 6 | Note : 0 represents the bulb is off and 1 represents the bulb is on.
 7 | 
 8 | Input Format
 9 | 
10 | First line contains an integer N.
11 | Next line contains N binary integers (0 or 1).
12 | 
13 | Constraints
14 | 
15 | 1 <= N <= 105
16 | 
17 | Output Format
18 | 
19 | Output the minimum number of switches you'll need to press.
20 | 
21 | Sample Input 0
22 | 
23 | 4
24 | 0 1 0 1
25 | Sample Output 0
26 | 
27 | 4
28 | 
29 | 
30 | 
31 | 
32 | #include <cmath>
33 | #include <cstdio>
34 | #include <vector>
35 | #include <iostream>
36 | #include <algorithm>
37 | using namespace std;
38 | 
39 | 
40 | int main() {
41 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
42 |     int n, count=0;
43 |     cin>>n;
44 |     int a[n];
45 |     for(int i=0;i<n;i++)
46 |     {
47 |         cin>>a[i];
48 |     }
49 |     for(int i=0;i<n;i++)
50 |     {
51 |         if(a[i]==0)
52 |         {
53 |             count++;
54 |             for(int j=i;j<n;j++)
55 |             {
56 |                 if(a[j]==0)
57 |                     a[j]=1;
58 |                 else
59 |                     a[j]=0;
60 |             }
61 |         }
62 |     }
63 |     cout<<count;
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/Candies to Children.CPP:
--------------------------------------------------------------------------------
 1 | There are N children standing in a line. Each child is assigned a rating value.
 2 | 
 3 | You are giving candies to these children subjected to the following requirements:
 4 | - Each child must have at least one candy.
 5 | - Children with a higher rating get more candies than their neighbors.
 6 | 
 7 | What is the minimum candies you must give?
 8 | 
 9 | Input Format
10 | 
11 | First line contains an integer N. 
12 | Next line contains N space separated integers.
13 | 
14 | Constraints
15 | 
16 | 1 <= N <= 106
17 | 1 <= Ai <= 103
18 | 
19 | Output Format
20 | 
21 | Output the minimum number of candies you can give out.
22 | 
23 | Sample Input 0
24 | 
25 | 2
26 | 1 2
27 | Sample Output 0
28 | 
29 | 3
30 | Explanation 0
31 | 
32 | The candidate with 1 rating gets 1 candy and candidate with rating cannot get 1 candy as 1 is its neighbor. So rating 2 candidate gets 2 candies. In total, 2+1 = 3 candies need to be given out.
33 | 
34 | 
35 | 
36 | 
37 | #include <cmath>
38 | #include <cstdio>
39 | #include <vector>
40 | #include <iostream>
41 | #include <algorithm>
42 | using namespace std;
43 | 
44 | 
45 | int main() {
46 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
47 |     int n,i;
48 |     cin>>n;
49 |     int ratings[n];
50 |     for(i=0;i<n;i++)
51 |         cin>>ratings[i];
52 |     int candy[n],sum=0;
53 |     for(i=0;i<n;i++)
54 |         candy[i]=1;
55 |     for(i=1;i<n;i++)
56 |         if(ratings[i]>ratings[i-1])  
57 |             candy[i]=candy[i-1]+1;
58 |     for(i=n-1;i>0;i--)
59 |         if(ratings[i-1]>ratings[i] && candy[i-1]<=candy[i])
60 |             candy[i-1]=candy[i]+1;
61 |     for(i=0;i<n;i++)
62 |         sum+=candy[i];
63 |     cout<<sum;
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/Slime(Microbial Infestation).CPP:
--------------------------------------------------------------------------------
 1 | There are n slimes in a row. Each slime has an integer value (possibly negative or zero) associated with it.
 2 | 
 3 | Any slime can eat its adjacent slime (the closest slime to its left or to its right, assuming that this slime exists).
 4 | 
 5 | When a slime with a value x eats a slime with a value y, the eaten slime disappears, and the value of the remaining slime changes to x−y.
 6 | 
 7 | The slimes will eat each other until there is only one slime left.
 8 | 
 9 | Find the maximum possible value of the last slime.
10 | 
11 | Input
12 | The first line of the input contains an integer n (1≤n≤500000) denoting the number of slimes.
13 | 
14 | The next line contains n integers ai (−109≤ai≤109), where ai is the value of i-th slime.
15 | 
16 | Output
17 | Print an only integer — the maximum possible value of the last slime.
18 | 
19 | Examples
20 | input
21 | 4
22 | 2 1 2 1
23 | output
24 | 4
25 | input
26 | 5
27 | 0 -1 -1 -1 -1
28 | output
29 | 4
30 | Note
31 | In the first example, a possible way of getting the last slime with value 4 is:
32 | 
33 | Second slime eats the third slime, the row now contains slimes 2,−1,1
34 | Second slime eats the third slime, the row now contains slimes 2,−2
35 | First slime eats the second slime, the row now contains 4
36 | In the second example, the first slime can keep eating slimes to its right to end up with a value of 4.
37 | 
38 | 
39 | 
40 | #include<bits/stdc++.h>
41 | using namespace std;
42 | int main()
43 | {
44 | 	int n;
45 | 	cin>>n;
46 | 	int a[n];
47 | 	for(int i=0;i<n;i++)
48 | 	cin>>a[i];
49 | 	sort(a,a+n);
50 | 	long long int ans=a[n-1];
51 | 	if(n>1)
52 | 	ans=ans-a[0];
53 | 	for(int i=1;i<n-1;i++)
54 | 	{
55 | 		ans=ans+abs(a[i]);
56 | 	}
57 | 	cout<<ans<<endl;
58 | }
59 | 


--------------------------------------------------------------------------------
/Ways to decode.C:
--------------------------------------------------------------------------------
 1 | A numeric string can be converted to an alphabetic string in the following manner :
 2 | 
 3 | replace '0' by 'A', '1' by 'B' ... '25' by 'Z'.
 4 | 
 5 | Unfortunately, this method of encoding and decoding is not very robust as some strings can result in multiple outputs and hence cause ambiguity, for example, the string "1101" can be read as "LB", "BBAB", "BKB", "LAB" etc etc.
 6 | 
 7 | Your task is, given a numeric string, give the number of distinct alphabetic strings that it can be decoded to.
 8 | 
 9 | Since this number can be very large, output it modulo 1e9 + 7
10 | 
11 | Note that you can only consider either 1 or 2 contiguous characters and convert them to alphabets while decoding if possible
12 | 
13 | Input
14 | 
15 | Input consists of one string only
16 | 
17 | Output
18 | 
19 | Print the number of ways module 1e9+7
20 | 
21 | Notes
22 | 
23 | The length of the input string does not exceed 1e6
24 | 
25 | Sample Input 0
26 | 
27 | 1101
28 | Sample Output 0
29 | 
30 | 5
31 | 
32 | 
33 | 
34 | 
35 | 
36 | #include <stdio.h>
37 | #include <string.h>
38 | #include <math.h>
39 | #include <stdlib.h>
40 | long m=1e9+7;
41 | long  numDecodings(char* A)
42 | {
43 | int *count,i,n;    
44 | if(!A)    return 0;    
45 | n=strlen(A);    
46 | if(n==1)    return 1;    
47 | count = (int*)malloc(sizeof(int)*(n+1));    
48 | count[0] = count[1] = 1;     
49 | for (i = 2; i <= n; i++)    
50 | {        
51 | count[i] = 0; 
52 | if (A[i-1] >= '0')    count[i] = count[i-1]; 
53 | if (A[i-2]=='0'||A[i-2] == '1' || (A[i-2] == '2' && A[i-1] < '6') ) count[i] = (count[i]+count[i-2])%m;    
54 | }    
55 | return count[n]%m;}
56 | 
57 | int main()
58 | {
59 |     char ch[1000005];
60 |     scanf("%s",ch);
61 |     long x=numDecodings(ch);
62 |     printf("%ld",x);
63 | }
64 | 


--------------------------------------------------------------------------------
/Array/Gfg/Next Greater Element.CPP:
--------------------------------------------------------------------------------
 1 | For the input array [4, 5, 2, 25}, the next greater elements for each element are as follows.
 2 | 
 3 | Element       NGE
 4 |    4      -->   5
 5 |    5      -->   25
 6 |    2      -->   25
 7 |    25     -->   -1
 8 |    
 9 |    
10 | #include <bits/stdc++.h> 
11 | 
12 | using namespace std; 
13 | 
14 | /* prints element and NGE pair for all 
15 | elements of arr[] of size n */
16 | void printNGE(int arr[], int n) 
17 | { 
18 | 	stack<int> s; 
19 | 	unordered_map<int, int> mp; 
20 | 
21 | 	/* push the first element to stack */
22 | 	s.push(arr[0]); 
23 | 	
24 | 
25 | 	// iterate for rest of the elements 
26 | 	for (int i = 1; i < n; i++) { 
27 | 
28 | 		if (s.empty()) { 
29 | 			s.push(arr[i]); 
30 | 			continue; 
31 | 		} 
32 | 
33 | 		/* if stack is not empty, then 
34 | 	pop an element from stack. 
35 | 	If the popped element is smaller 
36 | 	than next, then 
37 | 	a) print the pair 
38 | 	b) keep popping while elements are 
39 | 	smaller and stack is not empty */
40 | 		while (s.empty() == false && s.top() < arr[i]) { 
41 | 			mp[s.top()] = arr[i]; 
42 | 			s.pop(); 
43 | 		} 
44 | 
45 | 		/* push next to stack so that we can find 
46 | 	next smaller for it */
47 | 		s.push(arr[i]); 
48 | 	} 
49 | 
50 | 	/* After iterating over the loop, the remaining 
51 | elements in stack do not have the next smaller 
52 | element, so print -1 for them */
53 | 	while (s.empty() == false) { 
54 | 		mp[s.top()] = -1; 
55 | 		s.pop(); 
56 | 	} 
57 | 
58 | 	for (int i=0; i<n; i++) 
59 | 	cout << arr[i] << " ---> " << mp[arr[i]] << endl; 
60 | } 
61 | 
62 | /* Driver program to test above functions */
63 | int main() 
64 | { 
65 | 	int arr[] = { 11, 13, 21, 3 }; 
66 | 	int n = sizeof(arr) / sizeof(arr[0]); 
67 | 	printNGE(arr, n); 
68 | 	return 0; 
69 | } 
70 | 


--------------------------------------------------------------------------------
/Algorithms/Water the grass.CPP:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | #include <algorithm>
 4 | #include <cmath>
 5 | using namespace std;
 6 | 
 7 | #define MAX_SIZE 10000
 8 | 
 9 | struct Sprinkler
10 | {
11 |     double left;
12 |     double right;
13 |     bool operator <(const Sprinkler &s) const
14 |     {
15 |         return left <s.left;
16 |     }
17 | }sprinklers[MAX_SIZE+5];
18 | 
19 | int WaterTheGrass(int m, int l)
20 | {
21 |     double rightmost = 0.0;
22 |     int count = 0;
23 |     int i, j;
24 |     for (i = 0; i <m; i = j)
25 |     {
26 |         if (sprinklers[i].left > rightmost) break;
27 |         for (j = i+1; j <m && sprinklers[j].left <= rightmost; ++j)
28 |         {
29 |             if (sprinklers[j].right > sprinklers[i].right)
30 |             {
31 |                 i = j;
32 |             }
33 |         }
34 |         ++count;
35 |         rightmost = sprinklers[i].right;
36 |         if (rightmost >= l) break;
37 |     }
38 |     if (rightmost >= l)
39 |     {
40 |         return count;
41 |     }
42 |     return -1;
43 | }
44 | 
45 | int main(void)
46 | {
47 |     int n, l;
48 |     double w;
49 |     while (cin >> n >> l >> w)
50 |     {
51 |         w /= 2.0;
52 |         int i, m = 0;
53 |         for (i = 0; i <n; ++i)
54 |         {
55 |             int p, r;
56 |             cin>>p>>r;
57 |             if (r > w)
58 |             {
59 |                 double halfCoveredLen = sqrt((double)r*r - w*w);    //Attention to double, wrong several times...
60 |                 sprinklers[m].left = (double)p - halfCoveredLen;
61 |                 sprinklers[m++].right = (double)p + halfCoveredLen;
62 |             }
63 |         }
64 |         sort(sprinklers, sprinklers+m);
65 |         cout <<WaterTheGrass(m, l) <<endl;
66 |     }
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/Cityofstars.CPP:
--------------------------------------------------------------------------------
 1 | Mia loves stars. She loves stars the most when they assume the shape of a diamond. She is also very particular about the size of the stars that she wants.
 2 | 
 3 | Look at the following cases :
 4 | 
 5 | N = 1
 6 | *
 7 | 
 8 | N = 2
 9 |  *
10 | ***
11 |  *
12 |  
13 | N = 3
14 |   *
15 |  ***
16 | *****
17 |  ***
18 |   *
19 | Sebastian wants to gift mia a design of stars of her favourite size. However he is a performer and not a programmer and hence has asked you for help.
20 | 
21 | Write a program that accepts an integer and creates a pattern accordingly.
22 | 
23 | Input
24 | Only one integer N
25 | 
26 | Output
27 | Print the design as shown in the examples
28 | 
29 | Notes
30 | 0 ≤ N ≤ 10
31 | 
32 | Sample Input 0
33 | 
34 | 3
35 | Sample Output 0
36 | 
37 |   *
38 |  ***
39 | *****
40 |  ***
41 |   *
42 | Sample Input 1
43 | 
44 | 4
45 | Sample Output 1
46 | 
47 |    *
48 |   ***
49 |  *****
50 | *******
51 |  *****
52 |   ***
53 |    *
54 |    
55 | #include <cmath>
56 | #include <cstdio>
57 | #include <vector>
58 | #include <iostream>
59 | #include <algorithm>
60 | using namespace std;
61 | 
62 | 
63 | int main() {
64 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
65 |     int n,i,j,k;
66 |     cin>>n;
67 |     for(i=1;i<n+1;i++)
68 |     {
69 |         for(j=n-i;j>0;j--)
70 |             cout<<" ";
71 |         for(j=0;j<i;j++)
72 |             cout<<"*";
73 |         for(j=i-1;j>0;j--)
74 |             cout<<"*";
75 |         cout<<endl;
76 |         
77 |     }
78 |     for(i=n-1;i>0;i--)
79 |     {
80 |         for(j=n-i;j>0;j--)
81 |             cout<<" ";
82 |         for(j=0;j<i;j++)
83 |             cout<<"*";
84 |         for(j=i-1;j>0;j--)
85 |             cout<<"*";
86 |         cout<<endl;
87 |         
88 |     }
89 |     return 0;
90 | }
91 | 


--------------------------------------------------------------------------------
/Exclusive OR.CPP:
--------------------------------------------------------------------------------
 1 | Find the XOR of two numbers and print it.
 2 | 
 3 | Hint : Input the numbers as strings.
 4 | 
 5 | Input Format
 6 | 
 7 | First line contains first number X and second line contains second number Y.
 8 | The numbers will be given to you in binary form.
 9 | 
10 | Constraints
11 | 
12 | 0 <= X <= 2^1000
13 | 0 <= Y <= 2^1000
14 | 
15 | Output Format
16 | 
17 | Output one number in binary format, the XOR of two numbers.
18 | 
19 | Sample Input 0
20 | 
21 | 11011
22 | 10101
23 | Sample Output 0
24 | 
25 | 01110
26 | 
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | using namespace std;
33 | 
34 | 
35 | void helper(string s1,string s2,string &s,int n)
36 | {
37 |     s="";
38 |     for(int i=0;i<n;i++)
39 |     {
40 |         if(s1[i]== s2[i])
41 |             s=s+"0";
42 |         else
43 |             s=s+"1";
44 |     }
45 |     
46 | }
47 | 
48 | int main() {
49 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
50 |     
51 |     string s1,s2,s;
52 |     cin>>s1>>s2;
53 |     int n;
54 |     string x,y,res;
55 |     
56 |     if(s1.size() > s2.size())
57 |     {
58 |         n = s1.size() - s2.size();
59 |         x="";
60 |         while(n!=0)
61 |         {
62 |             x = x+"0";
63 |             n--;
64 |         }
65 |         x=x+s2;
66 |         helper(s1,x,s,s1.size());
67 |     }
68 |     
69 |     else if(s1.size()==s2.size())
70 |         helper(s1,s2,s,s1.size());
71 |     
72 |     else
73 |     {
74 |         n = s2.size() - s1.size();
75 |         x="";
76 |         while(n!=0)
77 |         {
78 |             x = x+"0";
79 |             n--;
80 |         }
81 |         x=x+s1;
82 |         helper(x,s2,s,s2.size());
83 |     }
84 |     cout<<s;
85 |     return 0;
86 | }
87 | 


--------------------------------------------------------------------------------
/Star_Strings.CPP:
--------------------------------------------------------------------------------
 1 | Input Format
 2 | 
 3 | A single string denoting w.
 4 | 
 5 | Constraints
 6 | 
 7 | 1 <= strlen(w) <= 100 w contains only alphabets a-z (lowercase).
 8 | 
 9 | Output Format
10 | 
11 | Print "Yes" if it is beautiful otherwise "No".
12 | 
13 | Sample Input 0
14 | 
15 | abacaba
16 | Sample Output 0
17 | 
18 | Yes
19 | Explanation 0
20 | 
21 | Every pair of consecutive characters consists of one vowel and one consonant, so the word is beautiful and we print Yes.
22 | 
23 | Sample Input 1
24 | 
25 | badd
26 | Sample Output 1
27 | 
28 | No
29 | Explanation 1
30 | 
31 | There are two consecutive occurrences of d, so it is not beautiful and we print No.
32 | 
33 | Sample Input 2
34 | 
35 | yes
36 | Sample Output 2
37 | 
38 | No
39 | Explanation 2
40 | 
41 | The first pair of letters (y and e) both appear in our set of vowel characters, so the word is not beautiful and we print No.
42 | 
43 | 
44 | 
45 | #include <cmath>
46 | #include <cstdio>
47 | #include <vector>
48 | #include <iostream>
49 | #include <algorithm>
50 | using namespace std;
51 | 
52 | 
53 | int main() {
54 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
55 |     int flag=0,i;
56 |     string s;
57 |     getline(cin,s);
58 |     
59 |     for(i=0;i<s.length();i++)
60 |     {
61 |         if(s[i]==s[i+1])
62 |         {
63 |             flag=1;
64 |             cout<<"No";
65 | return 0;
66 |         }
67 |         
68 |         if((s[i]=='a'||s[i]=='e'||s[i]=='i'||s[i]=='o'||s[i]=='u'||s[i]=='y')&&(s[i+1]=='a'||s[i+1]=='e'||s[i+1]=='i'||s[i+1]=='o'||s[i+1]=='u'||s[i+1]=='y'))
69 |            {
70 |                cout<<"No";
71 |                return 0;
72 |                
73 |            }
74 |           
75 |            }
76 |         
77 |            
78 |            cout<<"Yes";
79 |     return 0;
80 | }
81 | 


--------------------------------------------------------------------------------
/PermutationProblemwithKswaps.CPP:
--------------------------------------------------------------------------------
 1 | ou are given an array of N integers which is a permutation of the first N natural numbers. You can swap any two elements of the array. You can make at most K swaps. What is the largest permutation, in numerical order, you can make?
 2 | 
 3 | Input Format
 4 | 
 5 | The first line of the input contains two integers, N and K, the size of the input array and the maximum swaps you can make, respectively. The second line of the input contains a permutation of the first N natural numbers.
 6 | 
 7 | Constraints
 8 | 
 9 | 1≤N≤10^5 1≤K≤10^9
10 | 
11 | Output Format
12 | 
13 | Print the lexicographically largest permutation you can make with at most K swaps
14 | 
15 | Sample Input 0
16 | 
17 | 5 1
18 | 4 2 3 5 1
19 | Sample Output 0
20 | 
21 | 5 2 3 4 1
22 | 
23 | 
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 |     long long int n,k,max;
36 |     cin>>n>>k;
37 |     long long int a[n];
38 |     for(long long int i=0;i<n;i++){
39 |         cin>>a[i];
40 |     }
41 |     long long int j=0,index;
42 |     while(k){
43 |         max = a[j];
44 |         for(long long int i=j+1;i<n;i++){
45 |             if(a[i]>max){
46 |                 max=a[i];
47 |                 index = i;
48 |             }
49 |         }
50 |         if(max > a[j]){
51 |             int temp = a[j];
52 |             a[j] = a[index];
53 |             a[index] = temp;
54 |             k--;
55 |         }
56 |         
57 |         j++;
58 |         if(j==n){
59 |             break;
60 |         }
61 |     }
62 |     for(long long int i=0;i<n;i++){
63 |         cout<<a[i]<<" ";
64 |     }
65 |     return 0;
66 | }
67 | 


--------------------------------------------------------------------------------
/Sumofalldigits.CPP:
--------------------------------------------------------------------------------
 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 | INPUT
15 | Input consist of two numbers P and Q separated by a space.
16 | 
17 | OUTPUT
18 | Print a single digit, the final digit when the numbers of I are continuously added.
19 | 
20 | CONSTRAINTS
21 | 1 ≤ P ≤ 10100000 
22 | **1 ≤ Q ≤ **105 
23 | 
24 | Sample Input 0
25 | 
26 | 148 3
27 | Sample Output 0
28 | 
29 | 3
30 | 
31 | 
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 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
44 |     int a[100001],k,r;
45 |     char str[100001];
46 |     cin>>str;
47 |         cin>>k;
48 |         long long i=0,s=0;
49 |         while(str[i]){
50 |             a[i]=(int)str[i]-48;
51 |         //    cout<<a[i]<<" ";
52 |         s+=a[i];
53 |             i++;
54 |         }
55 |   
56 |     long long tot=s*k;
57 |     s=0;
58 |     while(1){
59 |         s=0;
60 |         while(tot>0){
61 |             r=tot%10;
62 |             tot/=10;
63 |             s+=r;
64 |         }
65 |         //cout<<s<<endl;
66 |         tot=s;
67 |         if(s<10)
68 |             break;
69 |     }
70 |    cout<<s;
71 |  return 0;
72 | }
73 | 


--------------------------------------------------------------------------------
/Fewa and her photoshoot.CPP:
--------------------------------------------------------------------------------
 1 | Ms. Fewa is a model and gets N chocolates per photo shoot. She neither wants to put on weight nor wants to cut down the chocolate consumption. She gets more calories per chocolate as she increases the consumption. Given N chocolates, ith chocolate has A[i] calories.
 2 | 
 3 | Lets say she is currently eating the chocolate with index k, and she has eaten c chocolates before this one, then the amount of calories she'll gain from eating the chocolate will be = (c + 1) * k.
 4 | 
 5 | While the chocolates can be eaten in any order, calculate the minimum number of calories she might get with the consumption of all N chocolates.
 6 | 
 7 | Print the minimum amount of calories gained while eating all N chocolates.
 8 | 
 9 | Input Format
10 | 
11 | First line contains an integer N. 
12 | Second line contains N space separated integers, ith of them denoting A[i].
13 | 
14 | Constraints
15 | 
16 | 1<= N,A[i] <=1000
17 | 
18 | Output Format
19 | 
20 | Print one integer equal to the minimum amount of calories that she can gain while eating all the chocolates
21 | 
22 | Sample Input 0
23 | 
24 | 3
25 | 2 3 2
26 | Sample Output 0
27 | 
28 | 13
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 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
41 |     int n;
42 |     cin>>n;
43 |     int a[n],i,j,t,s=0;
44 |     for(i=0;i<n;i++)
45 |         cin>>a[i];
46 |     for(i=0;i<n;i++){
47 |         for(j=i+1;j<n;j++){
48 |             if(a[i]<a[j]){
49 |                 t=a[i];
50 |                 a[i]=a[j];
51 |                 a[j]=t;
52 |             }
53 |         }
54 |     }
55 |     for(i=0;i<n;i++){
56 |         s+=(i+1)*a[i];
57 |     }
58 |     cout<<s;
59 |     return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/OS/SJF.CPP:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h> 
 2 | using namespace std; 
 3 |   
 4 | struct Process 
 5 | { 
 6 |    int pid;  
 7 |    int bt;  
 8 | }; 
 9 | bool comparison(Process a, Process b) 
10 | { 
11 |      return (a.bt < b.bt); 
12 | } 
13 | void findWaitingTime(Process proc[], int n, int wt[]) 
14 | {  
15 |     wt[0] = 0; 
16 |     for (int i = 1; i < n ; i++ ) 
17 |         wt[i] = proc[i-1].bt + wt[i-1] ; 
18 | } 
19 | void findTurnAroundTime(Process proc[], int n, 
20 |                         int wt[], int tat[]) 
21 | { 
22 |     for (int i = 0; i < n ; i++) 
23 |         tat[i] = proc[i].bt + wt[i]; 
24 | } 
25 | void findavgTime(Process proc[], int n) 
26 | { 
27 |     int wt[n], tat[n], total_wt = 0, total_tat = 0; 
28 |     findWaitingTime(proc, n, wt); 
29 |     findTurnAroundTime(proc, n, wt, tat); 
30 |     cout << "\nProcesses "<< " Burst time "
31 |          << " Waiting time " << " Turn around time\n"; 
32 |     for (int i = 0; i < n; i++) 
33 |     { 
34 |         total_wt = total_wt + wt[i]; 
35 |         total_tat = total_tat + tat[i]; 
36 |         cout << " " << proc[i].pid << "\t\t"
37 |              << proc[i].bt << "\t " << wt[i] 
38 |              << "\t\t " << tat[i] <<endl; 
39 |     } 
40 |   
41 |     cout << "Average waiting time = "
42 |          << (float)total_wt / (float)n; 
43 |     cout << "\nAverage turn around time = "
44 |          << (float)total_tat / (float)n; 
45 | } 
46 | int main() 
47 | { 
48 |      
49 |     int n,i;
50 |     cin>>n;
51 |     struct Process proc[n];
52 |     for(i=0;i<n;i++)
53 |     {
54 |         proc[i].pid=i+1;
55 |         cin>>proc[i].bt;
56 |     } 
57 |     sort(proc, proc + n, comparison); 
58 |   
59 |     cout << "Order in which process gets executed\n"; 
60 |     for (int i = 0 ; i < n; i++) 
61 |         cout << proc[i].pid <<" "; 
62 |   
63 |     findavgTime(proc, n); 
64 |     return 0; 
65 | } 
66 | 


--------------------------------------------------------------------------------
/LLinsertionatbeginning.CPP:
--------------------------------------------------------------------------------
 1 | Write a program to create a linked list with the given number of elements by inserting every element at the beginning.If there are no elements given then the head of the linked list will be null. After completing the insertion of all elements print the elements in the linked list at the end. If no elements are inserted then print null on the standard output.
 2 | 
 3 | Note: Intially the linked list will be empty
 4 | 
 5 | Input Format
 6 | 
 7 | First Line contains number of elements(n) to be inserted and followed the n elements
 8 | 
 9 | Constraints
10 | 
11 | 0<=n<=100
12 | 
13 | 1<=element<=10000
14 | 
15 | Output Format
16 | 
17 | Print the elements in the linkedlist
18 | 
19 | Sample Input 0
20 | 
21 | 5
22 | 5
23 | 4
24 | 3
25 | 2
26 | 1
27 | Sample Output 0
28 | 
29 | 1->2->3->4->5
30 | Explanation 0
31 | 
32 | Initially the list will be empty and then we will add 5. After that we will add 4 infront of 5. Similarly 3 infront of 4 and so on.
33 | 
34 | 
35 | 
36 | #include <stdio.h>
37 | #include <string.h>
38 | #include <math.h>
39 | #include <stdlib.h>
40 | struct node
41 | {
42 |     int data;
43 |     struct node *next;
44 | };
45 | void insertbefore(struct node** headref,int data)
46 | {
47 |     struct node* newnode=(struct node*)malloc(sizeof(struct node));
48 |     newnode->data = data;
49 |     newnode->next = *headref;
50 |     *headref = newnode;
51 | }
52 | void print(struct node* Node)
53 | {
54 |     while(Node->next!=NULL)
55 |     {
56 |         printf("%d->",Node->data);
57 |         Node = Node->next;
58 |     }
59 |     printf("%d",Node->data);
60 | }
61 | int main() {
62 |     struct node* head = NULL;
63 |     int size;
64 |     scanf("%d",&size);
65 |     int i,val;
66 |     for(i=0;i<size;i++)
67 |     {
68 |         scanf("%d",&val);
69 |         insertbefore(&head,val);
70 |     }
71 |     print(head);
72 |     return 0;
73 | }
74 | 


--------------------------------------------------------------------------------
/Shortest_man.CPP:
--------------------------------------------------------------------------------
 1 | 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.
 2 | 
 3 | Formally, swap the first element of the array with the smallest element of the array.
 4 | 
 5 | INPUT
 6 | 
 7 | 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.
 8 | 
 9 | OUTPUT
10 | 
11 | Print the heights of the players in a line after the shortest person has swapped places with the first person.
12 | 
13 | Sample Input 0
14 | 
15 | 5
16 | 3 8 2 5 9
17 | Sample Output 0
18 | 
19 | 2 8 3 5 9 
20 | 
21 | 
22 | 
23 | #include <cmath>
24 | #include <cstdio>
25 | #include <vector>
26 | #include <iostream>
27 | #include <algorithm>
28 | using namespace std;
29 | int main() {
30 |     long int n;
31 |     cin>>n;
32 |     int i,arr[n];
33 |     for(i=0;i<n;i++)
34 |         cin>>arr[i];
35 |     int min=arr[0];
36 |     int index;
37 |     for(i=0;i<n;i++)
38 |     {
39 |         if(arr[i]<min)
40 |         {
41 |             min=arr[i];
42 |             index=i;
43 |         }
44 |     }
45 |     int temp;
46 |     if(min!=arr[0])
47 |     {
48 |         temp=arr[0];
49 |         arr[0]=arr[index];
50 |         arr[index]=temp;
51 |         
52 |     }
53 |     for(i=0;i<n;i++)
54 |         cout<<arr[i]<<" ";
55 |     return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/Smaller_team.CPP:
--------------------------------------------------------------------------------
 1 | 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.
 2 | 
 3 | 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.
 4 | 
 5 | INPUT
 6 | 
 7 | 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)
 8 | 
 9 | OUTPUT
10 | 
11 | Print the heights of the players in a line after the k switches are complete.
12 | 
13 | Sample Input 0
14 | 
15 | 7
16 | 4 9 6 3 1 7 5
17 | 4
18 | Sample Output 0
19 | 
20 | 1 3 4 5 6 7 9 
21 | 
22 | 
23 | 
24 | #include <cmath>
25 | #include <cstdio>
26 | #include <vector>
27 | #include <iostream>
28 | #include <algorithm>
29 | using namespace std;
30 | int main() {
31 |     int n;
32 |     cin>>n;
33 |     int i,arr[n];
34 |     for(i=0;i<n;i++)
35 |         cin>>arr[i];
36 |     int k;
37 |     cin>>k;
38 |     int temp=0,index;
39 |     int b[n];
40 |     for(i=0;i<n;i++)
41 |         b[i]=arr[i];
42 |     sort(b,b+n);
43 |     while(k--)
44 |     {
45 |         for(i=0;i<n;i++)
46 |         {
47 |             if(b[temp]==arr[i])
48 |             {
49 |                 index=i;
50 |             }
51 |         }
52 |         swap(arr[temp],arr[index]);
53 |         temp++;
54 |     }
55 |     for(i=0;i<n;i++)
56 |         cout<<arr[i]<<" ";
57 |     return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/Diamond_Pattern.CPP:
--------------------------------------------------------------------------------
 1 | Given a number N, print a pattern as shown below :
 2 | 
 3 | n = 1
 4 | *
 5 | 
 6 | n = 2
 7 |  *
 8 | ***
 9 |  *
10 | 
11 |  n = 3
12 |    *
13 |   ***
14 |  *****
15 |   ***
16 |    *
17 | and so on..
18 | Hint : Print the upper triangle and the lower reverse triangle separately.
19 | 
20 | Input Format
21 | 
22 | Only one integer, the number n.
23 | 
24 | Constraints
25 | 
26 | 1 <= n <= 100
27 | 
28 | Output Format
29 | 
30 | The required pattern
31 | 
32 | Sample Input 0
33 | 
34 | 1
35 | Sample Output 0
36 | 
37 | *
38 | 
39 | 
40 | 
41 | 
42 | #include <cmath>
43 | #include <cstdio>
44 | #include <vector>
45 | #include <iostream>
46 | #include <algorithm>
47 | using namespace std;
48 | 
49 | 
50 | int main() {
51 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
52 |     int n,i,j,k,l,t,test;
53 |     cin>>test;
54 |     while(test--){
55 |         cin>>n;
56 |         int space = 2*(n-1);
57 |         for(i=1;i<=n;i++){
58 |             t=0;
59 |             for(k=1;k<=space;k++){
60 |                 cout<<" ";
61 |             }
62 | 
63 |             for(j=1;j<=i;j++){  
64 |                 cout<<"*"<<" ";
65 |                 t++;
66 |             }
67 |             for(l=t-1;l>=1;l--){
68 |                 cout<<"*"<<" ";
69 |             }
70 |             space-=2;
71 |             cout<<endl;
72 |         }
73 |      //   int len=i;
74 |         space = 2;
75 | 
76 |         for(int i=n-1;i>=1;i--){
77 |             t=0;
78 |             for(k=1;k<=space;k++){
79 |                 cout<<" ";
80 |             }
81 |             for(j=1;j<=i;j++){  
82 |                 cout<<"*""<<" ";
83 |                 t++;
84 |             }
85 |             for(l=t-1;l>=1;l--){
86 |                 cout<<""*""<<" ";
87 |             }
88 |             space+=2;
89 |             cout<<endl;
90 |         }
91 |         cout<<endl;
92 |     }
93 |     return 0;
94 | }
95 | 


--------------------------------------------------------------------------------
/Largest Rectangular Area Under Histogram.CPP:
--------------------------------------------------------------------------------
 1 | You are given a histogram that consists of N vertical bars.
 2 | The ith bar from the left has height Hi.
 3 | 
 4 | Your task is to calculate the maximum area of any rectangle that lies completely within this histogram.
 5 | 
 6 | See the sample test case for clarity.
 7 | 
 8 | INPUT
 9 | 
10 | First line contains the size of histogram N. (1 <= N <= 106)
11 | Secone line contains N space separated integers denoting the height of the histogram bars. (1 <= Hi <= 106)
12 | 
13 | OUTPUT
14 | 
15 | Print one integer equal to the maximum area of any rectangle within the histogram.
16 | 
17 | Sample Input 0
18 | 
19 | 7
20 | 6 2 5 4 5 1 6
21 | Sample Output 0
22 | 
23 | 12
24 | 
25 | 
26 | 
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <stack>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | long long maxarea(long long a[],long long n)
36 | {
37 |     stack<long long>s;
38 |     long long area=0;
39 |     long long tp;
40 |     long long ar;
41 |     long long i=0;
42 |     while(i<n)
43 |     {
44 |         if(s.empty()||a[s.top()]<=a[i])
45 |             s.push(i++);
46 |         else
47 |         {
48 |             tp=s.top();
49 |             s.pop();
50 |             ar=a[tp]*(s.empty()?i:i-s.top()-1);
51 |             if(area<ar)
52 |                 area=ar;
53 |         }
54 |     }
55 |     while(s.empty()==false)
56 |     {
57 |         tp=s.top();
58 |             s.pop();
59 |             ar=a[tp]*(s.empty()?i:i-s.top()-1);
60 |             if(area<ar)
61 |                 area=ar;
62 |     }
63 |     return area;
64 | }
65 | 
66 | int main() {
67 |     long long n;
68 |     cin>>n;
69 |     long long a[n],i;
70 |     for(i=0;i<n;i++)
71 |         cin>>a[i];
72 |     cout<<maxarea(a,n);
73 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
74 |     return 0;
75 | }
76 | 


--------------------------------------------------------------------------------
/Electronicstore.CPP:
--------------------------------------------------------------------------------
 1 | 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.
 2 | 
 3 | The server at the counter is an algorithmist and not a programmer, hence he asks you to do the job for him.
 4 | 
 5 | Formally, sort an array using bubblesort.
 6 | 
 7 | INPUT
 8 | 
 9 | The first line of input is n (1≤n≤100), the number of customers in the queue
10 | The second line of input is the battery percentages of the n customers (positive numbers less than 100) each separated by a space.
11 | 
12 | OUTPUT
13 | 
14 | Print the battery percentages of the customers in a line after the sorting is completed.
15 | 
16 | Sample Input 0
17 | 
18 | 8
19 | 3 4 5 2 4 10 18 1
20 | Sample Output 0
21 | 
22 | 1 2 3 4 4 5 10 18 
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 |     int n;
36 |     cin>>n;
37 |     int i,arr[n];
38 |     for(i=0;i<n;i++)
39 |         cin>>arr[i];
40 |     int temp,j;
41 |     for(i=0;i<n-1;i++)
42 |     {
43 |         for(j=0;j<((n-i)-1);j++)
44 |         {
45 |             if(arr[j]>arr[j+1])
46 |             {
47 |                 temp=arr[j];
48 |                 arr[j]=arr[j+1];
49 |                 arr[j+1]=temp;
50 |             }
51 |         }
52 |     }
53 |     
54 |     for(i=0;i<n;i++)
55 |         cout<<arr[i]<<" ";
56 |     return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/Disintegrate LL.CPP:
--------------------------------------------------------------------------------
 1 | You are given a doubly linked list and an integer k. Your task is to use the linkedlist and the value k to construct a new linked list as follows :
 2 | 
 3 | Firstly, the prefix of the linkedlist before the element k must appear in reverse order
 4 | Then, the suffix of the linkedlist after the element k must appear in forward order
 5 | Look at the following examples :
 6 | 
 7 | List : 1<==>2<==>3<==>4<==>5<==>6<==>7<==>8 with K = 4
 8 | Answer : 3<==>2<==>1<==>5<==>6<==>7<==>8
 9 | 
10 | List : 1<==>5<==>10<==>25<==>10<==>5<==>1 with K = 25
11 | Answer : 10<==>5<==>1<==>10<==>5<==>1
12 | The following is the structure of a linkedlist node :
13 | 
14 | struct DoubleLinkedListNode {
15 |     int val;
16 |     DoubleLinkedListNode* prev;
17 |     DoubleLinkedListNode* next;
18 | };
19 | Your task is to implement the following function :
20 | 
21 | LinkedListNode* disintegrate(LinkedListNode* head, int k)
22 | Input
23 | Not Needed
24 | 
25 | Output
26 | Not Needed
27 | 
28 | Instructions
29 | You are only allowed to edit the Body of the code
30 | The Head and the Tail of the code must remain as it is
31 | You are not responsible for taking any input/output
32 | You must write the function with names exactly as given above
33 | You must not create any global variables
34 | Sample Input 0
35 | 
36 | 8
37 | 1
38 | 2
39 | 3
40 | 4
41 | 5
42 | 6
43 | 7
44 | 8
45 | 4
46 | Sample Output 0
47 | 
48 | 3
49 | 2
50 | 1
51 | 5
52 | 6
53 | 7
54 | 8
55 | 
56 | 
57 | 
58 | 
59 | #include<stdio.h>
60 | 
61 | int main()
62 | {
63 |     int n,i,k,arr[100],pos;
64 |     scanf("%d",&n);
65 |     for(i=0;i<n;i++)
66 |         scanf("%d",&arr[i]);
67 |     scanf("%d",&k);
68 |     for(i=0;i<n;i++)
69 |     {
70 |         if(arr[i]==k)
71 |         {
72 |             pos=i;
73 |         }
74 |     }
75 |     for(i=pos-1;i>=0;i--)
76 |         printf("%d\n",arr[i]);
77 |     for(i=pos+1;i<n;i++)
78 |         printf("%d\n",arr[i]);
79 | return 0;
80 | }
81 | 


--------------------------------------------------------------------------------
/PaneerLove.CPP:
--------------------------------------------------------------------------------
 1 | Chappu is addicted to Paneer! Nikau wants to keep her happy for n days. In order to be happy in i-th day, she needs to eat exactly a[i] kilograms of Paneer.
 2 | 
 3 | There is a big shop uptown and Nikau wants to buy Paneer for her from there. In i-th day, they sell Paneer for pi dollars per kilogram.
 4 | 
 5 | Nikau knows all numbers a1,...,an and p1,...,pn. In each day, he can buy arbitrary amount of Paneer, also he can keep some Paneer he has for the future.
 6 | 
 7 | Nikau is a little tired from cooking Paneer, so he asked for your help. Help him to minimize the total money he spends to keep Chappu happy for n days.
 8 | 
 9 | Input Format
10 | 
11 | The first line of input contains integer n (1<=n<=10^5), the number of days.
12 | 
13 | In the next n lines, i-th line contains two integers ai and pi (1<=ai, pi<=100), the amount of Paneer Chappu needs and the cost of Paneer in that day.
14 | 
15 | Constraints
16 | 
17 | 1 <= n <= 10^5
18 | 
19 | Output Format
20 | 
21 | Print the minimum money needed to keep Chappu happy for n days, in one line.
22 | 
23 | Sample Input 0
24 | 
25 | 3
26 | 1 3
27 | 2 2
28 | 3 1
29 | Sample Output 0
30 | 
31 | 10
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 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
44 |     int t;
45 |     cin>>t;
46 |     int ai[t],pi[t];
47 |     for(int i=0;i<t;i++)
48 |     {
49 |         cin>>ai[i]>>pi[i];
50 |     }
51 |     int cost=0,min;
52 |     cost=ai[0]*pi[0];
53 |     min=pi[0];
54 |     for(int i=1;i<t;i++)
55 |     {
56 |         if(pi[i]<min)
57 |         {
58 |             min=pi[i];
59 |            cost=cost+ai[i]*pi[i]; 
60 |         }
61 |         else
62 |         {
63 |             cost=cost+ai[i]*min;
64 |         }
65 |     }
66 |     cout<<cost;
67 |     return 0;
68 | }
69 | 
70 | 


--------------------------------------------------------------------------------
/Residueofexecution.CPP:
--------------------------------------------------------------------------------
 1 | There are n people standing in a circle waiting to be executed. The counting out begins at some point in the circle and proceeds around the circle in a fixed direction. In each step, a certain number of people are skipped and the next person is executed. The elimination proceeds around the circle (which is becoming smaller and smaller as the executed people are removed), until only the last person remains, who is given freedom. Given the total number of persons n and a number k which indicates that k-1 persons are skipped and kth person is killed in circle. The task is to choose the place in the initial circle so that you are the last one remaining and so survive.
 2 | 
 3 | For example, if n = 5 and k = 2, then the safe position is 3. Firstly, the person at position 2 is killed, then person at position 4 is killed, then person at position 1 is killed. Finally, the person at position 5 is killed. So the person at position 3 survives.
 4 | 
 5 | If n = 7 and k = 3, then the safe position is 4. The persons at positions 3, 6, 2, 7, 5, 1 are killed in order, and person at position 4 survives.
 6 | 
 7 | INPUT
 8 | Only to integers, N and K.
 9 | 
10 | OUTPUT
11 | One integer, the position that you must occupy in the beginning to avoid getting killed.
12 | 
13 | CONSTRAINTS
14 | 1 ≤ N, K ≤ 105
15 | 
16 | Sample Input 0
17 | 
18 | 5 2
19 | Sample Output 0
20 | 
21 | 3
22 | Sample Input 1
23 | 
24 | 7 3
25 | Sample Output 1
26 | 
27 | 4
28 | 
29 | 
30 | #include <cmath>
31 | #include <cstdio>
32 | #include <vector>
33 | #include <iostream>
34 | #include <algorithm>
35 | using namespace std;
36 | 
37 | int josephus(int n, int k) 
38 | { 
39 |   if (n == 1) 
40 |     return 1; 
41 |   else
42 |     return (josephus(n - 1, k) + k-1) % n + 1; 
43 | } 
44 | int main() {
45 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
46 |     int n,k;
47 |     cin>>n>>k;
48 |     cout<<josephus(n,k);
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/SMS_language.C:
--------------------------------------------------------------------------------
 1 | *Problem-Description*
 2 | SMS language or textese (also known as txt-speak, txtese, chatspeak, txt, txtspk, txtk, txto, texting language, txt lingo, SMSish, txtslang,or txt talk) is a term for the abbreviations and slang commonly used with mobile phone text messaging.
 3 | 
 4 | Some of the abbreviations used are
 5 | 
 6 | s for yes
 7 | u for you
 8 | 2day for today
 9 | y for why
10 | 
11 | Many grandpa's have started sending SMSes to their grand children. But they are not familiar with the SMS lingo.
12 | 
13 | Can you help them by writing a program that would convert a given text in proper English to SMS lingo? Consider only the 4 words listed above.
14 | 
15 | Input Format:
16 | 
17 | Input consists of a single string. Assume that the maximum length of the string is 200 and all letters are in lower-case.
18 | 
19 | Output Format:
20 | 
21 | Output consists of a single string.
22 | 
23 | Sample Input 1:
24 | 
25 | where were you yesterday?
26 | 
27 | Sample Output 1:
28 | 
29 | where were u sterday?
30 | 
31 | Sample Input 2:
32 | 
33 | why is today a working day for you?
34 | 
35 | Sample Output 2:
36 | 
37 | y is 2day a working day for u?
38 | 
39 | 
40 | 
41 | 
42 | 
43 | 
44 | 
45 | 
46 | 
47 | 
48 | #include<stdio.h>
49 | #include<string.h>
50 | 
51 | void replace(char *s1)
52 | {
53 |     char r[4][10]={"yes","you","today","why"};
54 |     char rep[4][5]={"s","u","2day","y"};
55 |     char buff[500];
56 |     int i;
57 |     char *ch;
58 |     for(i=0;i<4;i++)
59 |         if((ch=strstr(s1,r[i])))
60 |         {   
61 |             strncpy(buff,s1,ch-s1);
62 |             buff[ch-s1]=0;
63 |             sprintf(buff+(ch-s1),"%s%s",rep[i],ch+strlen(r[i]));
64 |             s1[0]=0;
65 |             strcpy(s1,buff);
66 |             return replace(s1);
67 |         }
68 |     
69 | }
70 | int main()
71 | {
72 |     char s1[100];
73 |     scanf("%[^\n]%*c", s1);
74 |     replace(s1);
75 |     printf("%s",s1);
76 |     return 0;
77 | }
78 | 


--------------------------------------------------------------------------------
/Algorithms/Maximizing special nodes.CPP:
--------------------------------------------------------------------------------
 1 | You are given a directed acyclic graph. We define a sink node to be a node that has zero edges coming out of it. We define a special node to be a node that has a direct edge to a sink node. 
 2 | You are given a power to reverse the direction of every single edge. 
 3 | You can either choose to use this power or not use this power at all. Your goal is to maximize the number of special nodes.
 4 | 
 5 | Write a program to print the maximum number of special nodes that you can get either by reversing all the edges or by leaving the graph as it is.
 6 | 
 7 | Input
 8 | First line contains the number of nodes N. 
 9 | Next N-1 lines contains the information of edges. 
10 | Each line contains two integers U and V denoting that there is an edge from U to V.
11 | 
12 | Output
13 | Print the maximum number of special nodes that you can get.
14 | 
15 | Sample Input 0
16 | 
17 | 5 6
18 | 1 2
19 | 1 3
20 | 1 4
21 | 2 5
22 | 3 5
23 | 3 5
24 | Sample Output 0
25 | 
26 | 3
27 | Explanation 0
28 | 
29 | In both the reverse graph and the original graph the special nodes remain same : 2, 3 and 4. Hence the answer is 3
30 | 
31 | 
32 | 
33 | 
34 | #include <cmath>
35 | #include <cstdio>
36 | #include <vector>
37 | #include <iostream>
38 | #include <algorithm>
39 | using namespace std;
40 | vector <int> g[1005],rg[1005];
41 | int n;
42 | int solve(vector<int>G[])
43 | {
44 |     int a[1005]={0};
45 |     for(int i=1;i<=n;i++)
46 |     {
47 |         for(auto node:G[i]){
48 |         if(G[node].size()==0)
49 |             a[i]=1;
50 |         }
51 |     }
52 |     int ans=0;
53 |     for(int i=1;i<=n;i++)
54 |         ans+=a[i];
55 |     return ans;
56 | }
57 | 
58 | int main() {
59 |     int e,c=0,c1=0;
60 |     cin>>n>>e;
61 |     for(int i=1;i<=e;i++)
62 |     {
63 |         int x,y;
64 |         cin>>x>>y;
65 |         g[x].push_back(y);
66 |         rg[y].push_back(x);
67 |     }
68 |     int a=solve(g);
69 |     int b=solve(rg);
70 |     cout<<max(a,b);
71 |     return 0;
72 | }
73 | 


--------------------------------------------------------------------------------
/Pstring.CPP:
--------------------------------------------------------------------------------
 1 | A string is called a pString if it can be represented as p concatenated copies of some string. 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.
 2 | 
 3 | You are given a string s, consisting of lowercase English letters and a positive integer p. 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.
 4 | 
 5 | Input Format
 6 | 
 7 | The first input line contains integer p. 
 8 | The second line contains s, all characters in s are lowercase English letters.
 9 | 
10 | Constraints
11 | 
12 | 1 ≤ p ≤ 1000
13 | 1 ≤ |s| ≤ 1000
14 | 
15 | Output Format
16 | 
17 | Print "YES" if it is possible to rearrange the letters in string s in such a way that the result is a pString. Print the result on a single output line. If it is not possible print "NO". (without quotes).
18 | 
19 | Sample Input 0
20 | 
21 | 2
22 | aazz
23 | Sample Output 0
24 | 
25 | YES
26 | Explanation 0
27 | 
28 | aazz can be rearranged to azaz which is a 2String
29 | 
30 | 
31 | 
32 | #include <cmath>
33 | #include <cstdio>
34 | #include <vector>
35 | #include <cstring>
36 | #include <iostream>
37 | #include <algorithm>
38 | using namespace std;
39 | 
40 | 
41 | int main() {
42 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
43 |     int p;
44 |     cin>>p;
45 |     string s;
46 |     cin>>s;
47 |     int b[123];
48 |     for(int i=97;i<=122;i++)
49 |         b[i]=0;
50 |     for(int i=0;i<s.length();i++){
51 |         char c=s.at(i);
52 |         int n=(int)c;
53 |         b[n]++;
54 |     }
55 |     int c=0,k=0;
56 |     for(int i=97;i<=122;i++){
57 |         if(b[i]!=0){
58 |             k++;
59 |             if(b[i]%p==0)
60 |                 c++;
61 |             
62 |         }
63 |     }
64 |     if(c!=k){
65 |         cout<<"NO";
66 |     }
67 |     else
68 |         cout<<"YES";
69 |     return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/Amogh's Homework.CPP:
--------------------------------------------------------------------------------
 1 | Today Amogh learnt about GCD and LCM in his math class. Amogh likes studying, so he started solving all the questions in the homework immediately. However he is stuck on one of them and needs your help.
 2 | 
 3 | We say that a pair of integers (a, b) if good, if GCD(a, b) = x and LCM(a, b) = y, where GCD(a, b) denotes the greatest common divisor of a and b, and LCM(a, b) denotes the least common multiple of a and b.
 4 | 
 5 | Given two integers x and y, you need to find the total number of good pairs of integers (a, b) such that l ≤ a, b ≤ r. Note that pairs (a, b) and (b, a) are considered different if a ≠ b (i.e the pairs are ordered).
 6 | 
 7 | Input Format
 8 | 
 9 | The only line contains four integers l, r, x, y.
10 | 
11 | Constraints
12 | 
13 | (1 ≤ l ≤ r ≤ 1e9) where 1eN stands for Nth power of 10
14 | 
15 | (1 ≤ x ≤ y ≤ 1e9) where 1eN stands for Nth power of 10
16 | 
17 | Output Format
18 | 
19 | In the only line print the only integer — the answer for the problem.
20 | 
21 | Sample Input 0
22 | 
23 | 1 2 1 2
24 | Sample Output 0
25 | 
26 | 2
27 | Sample Input 1
28 | 
29 | 1 12 1 12
30 | Sample Output 1
31 | 
32 | 4
33 | Sample Input 2
34 | 
35 | 50 100 3 30
36 | Sample Output 2
37 | 
38 | 0
39 | 
40 | 
41 | 
42 | #include <bits/stdc++.h>
43 | 
44 | using namespace std;
45 | 
46 | int gcd(int a, int b) {
47 |     while (b) {
48 |         int t = a % b;
49 |         a = b;
50 |         b = t;
51 |     }
52 |     return a;
53 | }
54 | 
55 | int main() {
56 |     int l, r, x, y;
57 |     cin >> l >> r >> x >> y;
58 |     if (y % x != 0){
59 |         cout << 0 << '\n';
60 |         return 0;
61 |     }
62 |     int ans = 0;
63 |     int n = y / x;
64 |     for (int d = 1; d * d <= n; ++d) {
65 |         if (n % d == 0) {
66 |             int c = n / d;
67 |             if (l <= c * x && c * x <= r && l <= d * x && d * x <= r && gcd(c, d) == 1) {
68 |                 if (d * d == n) ++ans;
69 |                 else ans += 2;
70 |             }
71 |         }
72 |     }
73 | 
74 |     cout << ans << '\n';
75 |     return 0;
76 | }
77 | 


--------------------------------------------------------------------------------
/Johny_in_a_matrix.CPP:
--------------------------------------------------------------------------------
 1 | You are given a matrix A of size NxN. Every cell has a value A[i][j] associated with it. Johny is standing currently at position (1,1) and he intends to get to cell (N,N).
 2 | 
 3 | The cost of going from cell (i,j) to cell(x,y) is A[i][j] * A[x][y].
 4 | 
 5 | Johny can either decided to travel in a row-major order or in a column-major order.
 6 | 
 7 | Your task is to find out which method will cost him less. Print "row-major" or "column-major" accordingly.
 8 | 
 9 | Input
10 | First line contains an integer N 
11 | Next N lines each contain N integers each denoting the value of the array A[][]
12 | 
13 | Output
14 | Print either "row-major" or "column-major". If both ways cost the same then print "row-major".
15 | 
16 | Sample Input 0
17 | 
18 | 2
19 | 1 2
20 | 3 4
21 | Sample Output 0
22 | 
23 | column-major
24 | Explanation 0
25 | 
26 | row major cost = 1x2 + 2x3 + 3x4 = 2 + 6 + 12 = 20 
27 | col major cost = 1x3 + 3x2 + 2x4 = 3 + 6 + 8 = 17 
28 | Hence the answer is column-major
29 | 
30 | 
31 | 
32 | #include <cmath>
33 | #include <cstdio>
34 | #include <vector>
35 | #include <iostream>
36 | #include <algorithm>
37 | using namespace std;
38 | 
39 | 
40 | int main() {
41 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
42 |     long long int n,i,j,sum=0,k,rc=0,l,cm=0;
43 |     cin>>n;
44 |     long long int a[n][n],ar[n*n],ar1[n*n];
45 |     for(i=0;i<n;i++){
46 |         for(j=0;j<n;j++){
47 |             cin>>a[i][j];
48 |             ar[k]=a[i][j];
49 |             k++;
50 |         }
51 |     }
52 |     for(i=0;i<(n*n)-1;i++){
53 |         rc=rc+ar[i]*ar[i+1];
54 |     }
55 |     //cout<<rc;
56 |      for(i=0;i<n;i++){
57 |         for(j=0;j<n;j++){
58 |            ar1[l]=a[j][i];
59 |             l++;
60 |         }}
61 |     for(i=0;i<(n*n)-1;i++){
62 |         cm=cm+ar1[i]*ar1[i+1];
63 |     }
64 |     //cout<<cm;
65 |      if(rc>cm){
66 |         cout<<"column-major";
67 |     }
68 |     else{
69 |         cout<<"row-major";
70 |     }
71 |   
72 |     //cout<<sum;
73 |     return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/LL_searching.C:
--------------------------------------------------------------------------------
 1 | Write a program to create a linked list with the given number of elements(follow the normal insertion process i.e., insert node at end evry time).If there are no elements given then the head of the linked list will be null. After completing the insertion of all you will be given an element you have to search for that element in the linked list. Display "yes" if it is found else "no".
 2 | 
 3 | Note: Intially the linked list will be empty
 4 | 
 5 | Input Format
 6 | 
 7 | First Line contains number of elements(n) to be inserted and followed the n+1 elements the (n+1)th element is the element to be searched
 8 | 
 9 | Constraints
10 | 
11 | 0<=n<=100
12 | 
13 | 1<=element<=10000
14 | 
15 | Output Format
16 | 
17 | "yes" or "no"
18 | 
19 | Sample Input 0
20 | 
21 | 4
22 | 1
23 | 2
24 | 3
25 | 4
26 | 4
27 | Sample Output 0
28 | 
29 | yes
30 | 
31 | 
32 | 
33 | #include <stdio.h>
34 | #include <string.h>
35 | #include <math.h>
36 | #include <stdlib.h>
37 | 
38 | struct node{
39 |     int data;
40 |     struct node* next;
41 | };
42 | 
43 | int main() {
44 | 
45 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
46 |     long int t;
47 |     int i,val;
48 |     scanf("%ld",&t);
49 |     struct node* head;
50 |     for(i=0;i<t;i++)
51 |     {
52 |         scanf("%d",&val);
53 |         struct node* temp1=(struct node *)malloc(sizeof(struct node*));
54 |         temp1->data=val;
55 |         temp1->next=NULL;
56 |         if(i==0)
57 |         {
58 |             head=temp1;
59 |         }
60 |         else 
61 |         {
62 |             struct node* temp=head;
63 |             while(temp->next!=NULL)
64 |             {
65 |                 temp=temp->next;
66 |             }
67 |             temp->next=temp1;
68 |         }
69 |     }
70 |     scanf("%d",&val);
71 |     struct node *temp=head;
72 |     while(temp!=NULL)
73 |     {
74 |         if(temp->data==val)
75 |         {
76 |             printf("yes");
77 |             return 0;
78 |         }
79 |         temp=temp->next;
80 |     }
81 |     printf("no");
82 |     return 0;
83 | }
84 | 


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


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


--------------------------------------------------------------------------------
/Maximum xor subset.CPP:
--------------------------------------------------------------------------------
 1 | Given an array of size at most 18, write a program that prints the maximum XOR (Bitwise Exclusive-Or ) of any non-empty subset of the array.
 2 | 
 3 | XOR of two numbers A and B is done by A^B.
 4 | 
 5 | Non-empty subset means a set that has atleast one element and all its elements are present in the original array.
 6 | 
 7 | Input Format
 8 | 
 9 | First line contains a number N, size of the array. Next N lines contain one integer each.
10 | 
11 | Constraints
12 | 
13 | 1 <= N <= 18 1 <= A[i] <= 1000
14 | 
15 | Output Format
16 | 
17 | Output One number, the maximum possible XOR among the XORs of all subsets.
18 | 
19 | Sample Input 0
20 | 
21 | 1
22 | 1
23 | Sample Output 0
24 | 
25 | 1
26 | Sample Input 1
27 | 
28 | 3
29 | 2
30 | 4
31 | 1
32 | Sample Output 1
33 | 
34 | 7
35 | Explanation 1
36 | 
37 | Maximum Xor is obtained when the subset is {1,2,4} as 1^2^4 - 7. A higher value isnt possible.
38 | 
39 | 
40 | 
41 | 
42 | #include<bits/stdc++.h> 
43 | using namespace std;  
44 | #define INT_BITS 32 
45 | int maxSubarrayXOR(int set[], int n) 
46 | { 
47 |     int index = 0; 
48 |     for (int i = INT_BITS-1; i >= 0; i--) 
49 |     { 
50 |         int maxInd = index; 
51 |         int maxEle = INT_MIN; 
52 |         for (int j = index; j < n; j++) 
53 |         {  
54 |             if ( (set[j] & (1 << i)) != 0  
55 |                      && set[j] > maxEle ) 
56 |                 maxEle = set[j], maxInd = j; 
57 |         } 
58 |         if (maxEle == INT_MIN) 
59 |         continue; 
60 |         swap(set[index], set[maxInd]); 
61 |         maxInd = index; 
62 |         for (int j=0; j<n; j++) 
63 |         { 
64 |             if (j != maxInd && 
65 |                (set[j] & (1 << i)) != 0) 
66 |                 set[j] = set[j] ^ set[maxInd]; 
67 |         } 
68 |         index++; 
69 |     } 
70 |     int res = 0; 
71 |     for (int i = 0; i < n; i++) 
72 |         res ^= set[i]; 
73 |     return res; 
74 | }   
75 | int main() 
76 | { 
77 |     int n;
78 |     cin>>n;
79 |     int a[n];
80 |       for(int i =0;i<n;i++)
81 |           cin>>a[i];
82 |     cout << maxSubarrayXOR(a, n); 
83 |     return 0; 
84 | }
85 | 


--------------------------------------------------------------------------------
/Bracket Sequence.CPP:
--------------------------------------------------------------------------------
 1 | A bracket sequence is called regular, if by inserting '+' and '1' into it we can get a correct mathematical expression. For example, sequences '(())()', '()' and '(()(()))' are regular, while ')(', '(()' and '(()))(' are not.
 2 | 
 3 | Since, ((1+(1+1))+(1+1)) is a valid mathematical expression hence, '((())())' is valid sequence.
 4 | 
 5 | You are given a string of '(' and ')' characters. You are to find its longest substring that is a regular bracket sequence. You are to find the number of such substrings as well.
 6 | 
 7 | Input Format
 8 | 
 9 | The first line of the input file contains a non-empty string, consisting of '(' and ')' characters.
10 | 
11 | Constraints
12 | 
13 | Length of given sequence does not exceed .
14 | 
15 | Output Format
16 | 
17 | Print the length of the longest substring that is a regular bracket sequence, and the number of such substrings. If there are no such substrings, write the only line containing "0 1".
18 | 
19 | Sample Input 0
20 | 
21 | )((())))(()())
22 | Sample Output 0
23 | 
24 | 6 2
25 | Sample Input 1
26 | 
27 | ((((()(((
28 | Sample Output 1
29 | 
30 | 2 1
31 | 
32 | 
33 | 
34 | #include <cmath>
35 | #include <cstdio>
36 | #include <vector>
37 | #include <iostream>
38 | #include <algorithm>
39 | #include<bits/stdc++.h>
40 | using namespace std;
41 | 
42 | 
43 | int main() {
44 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
45 |     string s;
46 |     cin>>s;
47 |     stack<int>st;
48 |     st.push(-1);
49 |     vector<int>v;
50 |     int num=INT_MIN;
51 |     for(int i=0;i<s.length();i++){
52 |         if(s[i]=='('){
53 |             st.push(i);
54 |         }
55 |         else{
56 |             st.pop();
57 |             if(!st.empty() && num<=i-st.top()){
58 |                 num = i-st.top();
59 |                 v.push_back(num);
60 |             }
61 |             if(st.empty()){
62 |                 st.push(i);
63 |             }
64 |         }
65 |     }
66 |     int count[1000000] = {0};
67 |     
68 |     for(int i=0;i<v.size();i++){
69 |         count[v[i]]++;
70 |     }
71 |     
72 |     cout<<num<<" "<<count[num];
73 |     return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/ResetButtons.CPP:
--------------------------------------------------------------------------------
 1 | 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.
 2 | 
 3 | 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.
 4 | 
 5 | 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.
 6 | 
 7 | Input Format
 8 | 
 9 | A single line contains integer n (1 ≤ n ≤ 2000) — the number of buttons the lock has.
10 | 
11 | Constraints
12 | 
13 | 1<=n<=2000
14 | 
15 | Output Format
16 | 
17 | In a single line print the number of times Kushal has to push a button in the worst-case scenario.
18 | 
19 | Sample Input 0
20 | 
21 | 2
22 | Sample Output 0
23 | 
24 | 3
25 | Explanation 0
26 | 
27 | 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.
28 | 
29 | 
30 | 
31 | 
32 | 
33 | #include <iostream>
34 | #include <deque>
35 | #include <cstring>
36 | #include <algorithm>
37 | #include <stdio.h>
38 | using namespace std;
39 | int main()
40 | {
41 |     int n;
42 |     while(cin>>n)
43 |     {
44 |         int ans=0;
45 |         for(int i=1;i<n;i++)
46 |         ans+=(n-i)*i;
47 |         cout<<ans+n<<endl;
48 |     }
49 |     return 0;
50 | 
51 | }
52 | 


--------------------------------------------------------------------------------
/Farthest String.CPP:
--------------------------------------------------------------------------------
 1 | We define the Palindromic Distance of a String as the minimum number of characters that need to be modified in order to turn the String into a palindrome. 
 2 | 
 3 | For example :
 4 | 
 5 | "cook" -> "cooc" (Palindrome),
 6 | Hence Distance("cook") = 1. 
 7 | 
 8 | "fluffy" -> "flufff" -> "ffufff" -> "ffffff" (Palindrome), 
 9 | Hence Distance("fluffy") = 3.
10 | 
11 | Now, you are given N number of strings, and your task is to find out which string has the farthest Distance from being a palindrome and print it.
12 | 
13 | INPUT
14 | First line contains number of strings N. 
15 | Next N lines each contain one string.
16 | 
17 | OUTPUT
18 | Print one string that is the farthest out of all strings from being a palindrome.
19 | 
20 | CONSTRAINTS
21 | 1 ≤ N ≤ 103 
22 | Each string has length of atmost 1000 
23 | Strings consists of lowercase english characters only
24 | 
25 | Sample Input 0
26 | 
27 | 7
28 | philosopher
29 | chamber
30 | prisoner
31 | goblet
32 | phoenix
33 | halfbloodprince
34 | deathlyhallows
35 | Sample Output 0
36 | 
37 | halfbloodprince
38 | 
39 | 
40 | 
41 | 
42 | 
43 | #include <cmath>
44 | #include <cstdio>
45 | #include <string>
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,p,m;
54 |     cin>>n;
55 |     
56 |     m=-999999;
57 |     string s[n];
58 |     
59 |     for(int i=0;i<n;i++)
60 |         cin>>s[i];
61 |     
62 |     for(int w=0;w<n;w++)
63 |     {
64 |         
65 |         
66 |         //string h=s[w];
67 |         //cout<<s[w]<<"\n";
68 |         string h;
69 |         h=s[w];
70 |         int i=0;
71 |         int j=h.length()-1;
72 |         
73 |         int c=0;
74 |         
75 |         while(i<j)
76 |         {
77 |             if(h[i]!=h[j])
78 |                 c++;
79 |             i++;
80 |             j--;
81 |         }
82 |         
83 |         
84 |         if(m<c)
85 |         {
86 |             m=c;
87 |             p=w;
88 |         }
89 |         //cout<<p<<" ";
90 |     }
91 |     
92 |     cout<<s[p];
93 |     return 0;
94 | }
95 | 


--------------------------------------------------------------------------------
/Tricky_Treat.CPP:
--------------------------------------------------------------------------------
 1 | 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].
 2 | 
 3 | 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!".
 4 | 
 5 | Hint1 : You can use binary search to find out whether an element is present in the array or not.
 6 | 
 7 | INPUT
 8 | 
 9 | 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)
10 | 
11 | OUTPUT
12 | 
13 | Print M lines of output. ith line being "Happy Halloween!" if C[i] is present in A[N] and "Tricky!" otherwise.
14 | 
15 | Sample Input 0
16 | 
17 | 5
18 | 2 4 6 8 10
19 | 5
20 | 5 4 3 2 1
21 | Sample Output 0
22 | 
23 | Tricky!
24 | Happy Halloween!
25 | Tricky!
26 | Happy Halloween!
27 | Tricky!
28 | 
29 | 
30 | 
31 | #include <cmath>
32 | #include <cstdio>
33 | #include <vector>
34 | #include <iostream>
35 | #include <algorithm>
36 | using namespace std;
37 | int binarysearch(long int arr[],int n,int k)
38 | {
39 |     long int l=0,h=n-1,mid;
40 |     while(l<=h)
41 |     {
42 |         mid=floor((l+h)/2);
43 |         if(arr[mid]==k)
44 |             return 1;
45 |         else if(arr[mid]<k)
46 |             l=mid+1;
47 |         else
48 |             h=mid-1;
49 |     }
50 |     return 0;
51 | }
52 | int main() {
53 |     long int n,m,i;
54 |     cin>>n;
55 |     long int arr[n];
56 |     for(i=0;i<n;i++)
57 |         cin>>arr[i];
58 |     cin>>m;
59 |     long int can[m];
60 |     for(i=0;i<m;i++)
61 |         cin>>can[i];
62 |     for(i=0;i<m;i++)
63 |     {
64 |         if(binarysearch(arr,n,can[i]))
65 |             cout<<"Happy Halloween!"<<endl;
66 |         else
67 |             cout<<"Tricky!"<<endl;
68 |     }
69 |     return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/GCD.CPP:
--------------------------------------------------------------------------------
 1 | In math, GCD, the greatest common divisor is an easy task to calculate for 2 positive numbers.
 2 | 
 3 | A common divisor of two positive numbers is a number which divides both numbers.
 4 | 
 5 | 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.
 6 | 
 7 | 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.
 8 | 
 9 | Input Format
10 | 
11 | The first line has a and b, the two integers as described above.
12 | 
13 | The second line contains one integer n, representing the number of queries.
14 | 
15 | In the n lines that follow, each line contains one query consisting of two integers, low and high.
16 | 
17 | Constraints
18 | 
19 | (1 ≤ a, b ≤ 1e9)
20 | 
21 | (1 ≤ n ≤ 1e4)
22 | 
23 | (1 ≤ low ≤ high ≤ 1e9)
24 | 
25 | Output Format
26 | 
27 | Print n lines.
28 | 
29 | The i-th of them should have the result of the i-th query in the input.
30 | 
31 | If there is no common divisor in the given range for any query, print -1.
32 | 
33 | Sample Input 0
34 | 
35 | 9 27
36 | 3
37 | 1 5
38 | 10 11
39 | 9 11
40 | Sample Output 0
41 | 
42 | 3
43 | -1
44 | 9
45 | 
46 | 
47 | 
48 | 
49 | #include <bits/stdc++.h>
50 | 
51 | using namespace std;
52 | 
53 | int main() {
54 |     int a, b;
55 |     scanf("%d%d", &a, &b);
56 |     int gcd = __gcd(a, b);
57 |     vector <int> div;
58 |     for (int i = 1; i*i <= gcd; ++i) {
59 |         if (gcd%i == 0) {
60 |             div.push_back(i);
61 |             if (i != gcd/i) div.push_back(gcd/i);
62 |         }
63 |     }
64 |     sort(div.begin(), div.end(), greater <int> ());
65 | 
66 |     int Q;
67 |     scanf("%d", &Q);
68 |     while (Q--) {
69 |         int m, n, res = -1;
70 |         scanf("%d%d", &m, &n);
71 |         for (int i : div) {
72 |             if (i >= m && i <= n) {
73 |                 res = i;
74 |                 break;
75 |             }
76 |         }
77 |         printf("%d\n", res);
78 |     }
79 | 
80 | }
81 | 


--------------------------------------------------------------------------------
/Word_index1.CPP:
--------------------------------------------------------------------------------
  1 | Write a C program to find the first occurrence of word in a string using loop
  2 | 
  3 | Refer sample Input and Output:
  4 | Example 1: 
  5 | srm university
  6 | university
  7 | Output 1: university is found at 4
  8 | 
  9 | The String university is found at string index 4. Array Index starts from 0
 10 | 
 11 | Example 2:
 12 | srm university
 13 | universit
 14 | 
 15 | Output 2:
 16 | universit is not found
 17 | 
 18 | 
 19 | 
 20 | APPROACH-1
 21 | 
 22 | #include <stdio.h>
 23 | #include <string.h>
 24 | int main()
 25 | {
 26 |   char str1[100],str2[100];
 27 |   scanf("%[^\n]s",str1);
 28 |   scanf("%s",str2);
 29 |   char *res = strstr(str1,str2);
 30 |   if(res=='\0')
 31 |     printf("%s is not found",str2);
 32 |   else
 33 |   {
 34 |     int index,i;
 35 |     for(i=0;str1[i]!='\0';i++)
 36 |     {
 37 |       if(res==&str1[i])
 38 |       {
 39 |         index=i;
 40 |         break;
 41 |       }
 42 |     }
 43 |     printf("%s is found at %d",str2,index);
 44 |   }
 45 |   return 0;
 46 | }
 47 | 
 48 | 
 49 | 
 50 | 
 51 | APPROACH-2
 52 | 
 53 | 
 54 | 
 55 | #include <stdio.h>
 56 | #include <string.h>
 57 | int main()
 58 | {
 59 |     char str[100], word[100];
 60 |     int i, index, found = 0;
 61 | 
 62 |     scanf("%[^\t\n]s",str);
 63 |      // printf("%s",str);
 64 |       scanf("%s",word);
 65 | 
 66 |      index = 0;
 67 |     while(str[index] != '\0')
 68 |     {
 69 | 
 70 |     if(str[index] == word[0])
 71 |         {
 72 |             i=0;
 73 |             found = 1;
 74 |             while(word[i] != '\0')
 75 |             {
 76 |                 if(str[index + i] != word[i])
 77 |                 {
 78 |                     found = 0;
 79 |                     break;
 80 |                 }
 81 | 
 82 |                 i++;
 83 |             }
 84 |         }
 85 |         
 86 |           if(found == 1)
 87 |         {
 88 |             break;
 89 |         }
 90 | 
 91 |         index++;
 92 |     }
 93 |     
 94 |       if(found == 1)
 95 |     {
 96 |         printf("\n%s is found at %d", word, index);
 97 |     }
 98 |     else
 99 |     {
100 |         printf("\n %s is not found.", word);
101 |     }
102 | 
103 |     return 0;
104 | }
105 | 


--------------------------------------------------------------------------------
/Play_with_strings.C:
--------------------------------------------------------------------------------
 1 | Given are two strings(each not more than 100 characters). We need to find relation between them such that all the characters of the second string must appear in the first string sequentially (not necessarily continuously). The program should :
 2 | Print 1: if the characters in the first string appear in the same sequence as that of the second string.
 3 | Print 2: if the characters in the first string appear in the opposite sequence as that of second string.
 4 | Print 3: if the characters in the first string appear in both ie same as well as opposite sequences of the second string.
 5 | Print 0: if the characters in the first string dont appear in sequence of the second string. 
 6 | The characters in the strings are case-sensitive.
 7 | 
 8 | Input
 9 | The first line should give the number of test cases. For each test case, it takes input two strings.
10 | 
11 | Output
12 | An integer ( 0,1,2 or 3 ) for each of the test cases. 
13 | 
14 | Test Case 1
15 | Input (stdin)
16 | 2
17 | njack njk
18 | anwesha awesa
19 | 
20 | Expected Output
21 | 1
22 | 1
23 | 
24 | Test Case 2
25 | Input (stdin)
26 | 2
27 | wysiwig iwi
28 | abcdef edba
29 | 
30 | Expected Output
31 | 3
32 | 2
33 | 
34 | 
35 | 
36 | 
37 | #include<stdio.h>
38 | #include<string.h>
39 | int main()
40 | {
41 | 	int t,i,j,s1=0,s2=0,c=0;
42 | 	char a[100],b[100];
43 | 	scanf("%d",&t);
44 | 	while(t--)
45 | 	{
46 | 		scanf("%s%s",a,b);
47 | 		j=0;
48 | 		c=0;
49 | 		for(i=0;i<strlen(a);i++)
50 | 		{
51 | 			for(j=j;j<strlen(b);)
52 | 			{
53 | 				if(a[i]==b[j])
54 | 				{
55 | 					c++;
56 | 					j++;
57 | 					break;
58 | 				}
59 | 				else 
60 | 					break;
61 | 			}
62 | 		}
63 | 		if(c==strlen(b))
64 | 			s1=1;
65 | 		c=0;
66 | 		j=0;
67 | 		for(i=strlen(a)-1;i>=0;i--)
68 | 		{
69 | 			for(j=j;j<strlen(b);)
70 | 			{
71 | 				if(a[i]==b[j])
72 | 				{
73 | 					c++;
74 | 					j++;
75 | 					break;
76 | 				}
77 | 				else
78 | 					break;
79 | 			}
80 | 		}
81 | 		if(c==strlen(b))
82 | 			s2=1;
83 | 		if((s1==1)&&(s2==1))
84 | 			printf("%d\n",3);
85 | 		else if(s1==1)
86 | 			printf("%d\n",1);
87 | 		else if(s2==1)
88 | 			printf("%d\n",2);
89 | 		else
90 | 			printf("%d\n",0);
91 | 		s1=s2=0;
92 | 	}
93 | 	return 0;
94 | }
95 |  
96 |  
97 | 


--------------------------------------------------------------------------------
/OrangePartitioning.C:
--------------------------------------------------------------------------------
 1 | Tisha went to her orchard and plucked a bunch of oranges. Now she wants to keep aside some of the oranges to for herself and her children but also sell the biggest ones on the market. She takes a look at the last orange in her hand and decides that she would like to eat it. She seems to think it fair that all the oranges smaller than the orange in her hand can go to her children. All the oranges bigger than this one will be sold on the market. Write a program to help Tisha do this partition. Assume the oranges are neatly stacked in a row.
 2 | 
 3 | Tisha does the following to partition the oranges :
 4 | 
 5 | k = 0
 6 | Check orange number i = 0,1,2,3.. n - 1 : 
 7 | for ith orange :
 8 | 		if (orange[i] is smaller than or equal to orange[n-1]) :
 9 | 			swap orange[i] with orange[k]
10 | 			k++
11 | swap orange[k] with orange[n-1]
12 | Simulate the process used by Tisha and print the resultant array of the size of oranges.
13 | 
14 | INPUT
15 | 
16 | The first line of input is n (1≤n≤100), the number of oranges Tisha plucked from the orchard
17 | The second line of input are the diameters of the oranges you just took (positive numbers) each separated by a space. Assume the last orange (orange[n - 1]) to be the one Tisha took in her hand.
18 | 
19 | OUTPUT
20 | 
21 | Print the sizes of the oranges in a row after the partition has been done
22 | 
23 | Sample Input 0
24 | 
25 | 8
26 | 4 3 8 6 1 1 9 5
27 | Sample Output 0
28 | 
29 | 4 3 1 1 5 6 9 8 
30 | 
31 | 
32 | 
33 | 
34 | #include <stdio.h>
35 | #include <string.h>
36 | #include <math.h>
37 | #include <stdlib.h>
38 | 
39 | int main() {
40 |     int n;
41 |     scanf("%d",&n);
42 |     int a[n];
43 |     for(int i=0;i<n;i++)
44 |         scanf("%d",&a[i]);
45 |     int k=0;
46 |     for(int i=0; i<n-1; i++)
47 |         {
48 |             if (a[i]<= a[n-1])
49 |             {
50 |                 int t = a[i];
51 |                 a[i]= a[k];
52 |                 a[k++] = t;
53 |             }
54 |         }
55 |         int t = a[n-1];
56 |         a[n-1]= a[k];
57 |         a[k] = t;
58 |     for(int i=0;i<n;i++)
59 |         printf("%d ",a[i]);
60 | 
61 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
62 |     return 0;
63 | }
64 | 


--------------------------------------------------------------------------------
/Shopping in clusters.CPP:
--------------------------------------------------------------------------------
 1 | Jaime the Tailor's new customer wants to add n distinct clusters of buttons to her dress, where each cluster is filled with a distinct number of buttons of a certain color.
 2 | 
 3 | The customer also has specific ideas about how much she wants to pay for each cluster in that for some cluster i, she wants to pay at least ai dollars. In addition, she wants each cluster to contain a distinct number of buttons. And, finally, she wants to minimize her total cost.
 4 | 
 5 | Jaime stocks an infinite number of buttons in an infinite number of colors at his shop, and each button costs p dollars. Given n, p, and the amount of money that the customer wants to pay for each respective cluster, help Jaime by finding and printing a long integer denoting the minimum number of buttons he can use to satisfy her request.
 6 | 
 7 | Input Format
 8 | 
 9 | The first line contains two space-separated integers denoting the respective values of n and p.
10 | 
11 | The second line contains n space-separated integers where each integer i denotes the value of ai (i.e., the minimum amount of money she wants to spend on cluster i).
12 | 
13 | Constraints
14 | 
15 | 1 <= n,p,a <= 105
16 | 
17 | Output Format
18 | 
19 | Print a single long integer denoting the minimum number of buttons required for Jaime to satisfy his customer's request.
20 | 
21 | Sample Input 0
22 | 
23 | 3 2
24 | 4 6 6
25 | Sample Output 0
26 | 
27 | 9
28 | Sample Input 1
29 | 
30 | 2 3
31 | 4 5
32 | Sample Output 1
33 | 
34 | 5
35 | 
36 | 
37 | 
38 | 
39 | #include <cmath>
40 | #include <cstdio>
41 | #include <vector>
42 | #include <iostream>
43 | #include <algorithm>
44 | #include<assert.h>
45 | using namespace std;
46 | 
47 | long long arr[100005];
48 | int main() {
49 | /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
50 | 
51 | int n, p;
52 | long long ans;
53 | 
54 | cin>>n>>p;
55 | 
56 | for(int i=0; i<n; i++)
57 | {
58 |    cin>>arr[i];
59 |    arr[i] = ceil((double)arr[i]/(double)p);
60 | }
61 | 
62 | sort(arr, arr+n);
63 | 
64 | ans = (long long)arr[0];
65 | 
66 | for(int i=1; i<n; i++)
67 | {
68 |    if(arr[i]<=arr[i-1])
69 |    arr[i] = arr[i-1]+1;
70 |    ans += (long long)arr[i];
71 | }
72 | 
73 | cout<<ans<<endl;
74 | 
75 | return 0;
76 | }
77 | 


--------------------------------------------------------------------------------
/Nastya studies informatics.CPP:
--------------------------------------------------------------------------------
 1 | Today on Informatics class Nastya learned about GCD and LCM (see links below). Nastya is very intelligent, so she solved all the tasks momentarily and now suggests you to solve one of them as well.
 2 | 
 3 | We define a pair of integers (a, b) good, if GCD(a, b) = x and LCM(a, b) = y, where GCD(a, b) denotes the greatest common divisor of a and b, and LCM(a, b) denotes the least common multiple of a and b.
 4 | 
 5 | You are given two integers x and y. You are to find the number of good pairs of integers (a, b) such that l ≤ a, b ≤ r. Note that pairs (a, b) and (b, a) are considered different if a ≠ b.
 6 | 
 7 | Input
 8 | The only line contains four integers l, r, x, y (1 ≤ l ≤ r ≤ 109, 1 ≤ x ≤ y ≤ 109).
 9 | 
10 | Output
11 | In the only line print the only integer — the answer for the problem.
12 | 
13 | Examples
14 | inputCopy
15 | 1 2 1 2
16 | outputCopy
17 | 2
18 | inputCopy
19 | 1 12 1 12
20 | outputCopy
21 | 4
22 | inputCopy
23 | 50 100 3 30
24 | outputCopy
25 | 0
26 | Note
27 | In the first example there are two suitable good pairs of integers (a, b): (1, 2) and (2, 1).
28 | 
29 | In the second example there are four suitable good pairs of integers (a, b): (1, 12), (12, 1), (3, 4) and (4, 3).
30 | 
31 | In the third example there are good pairs of integers, for example, (3, 30), but none of them fits the condition l ≤ a, b ≤ r.
32 | 
33 | 
34 | 
35 | 
36 | 
37 | #include <bits/stdc++.h>
38 | 
39 | using namespace std;
40 | 
41 | int gcd(int a, int b) {
42 |     while (b) {
43 |         int t = a % b;
44 |         a = b;
45 |         b = t;
46 |     }
47 |     return a;
48 | }
49 | 
50 | signed main() {
51 |     ios_base::sync_with_stdio(false);
52 |     cin.tie(0);
53 | 
54 |     int l, r, x, y;
55 |     cin >> l >> r >> x >> y;
56 |     if (y % x != 0){
57 |         cout << 0 << '\n';
58 |         return 0;
59 |     }
60 |     int ans = 0;
61 |     int n = y / x;
62 |     for (int d = 1; d * d <= n; ++d) {
63 |         if (n % d == 0) {
64 |             int c = n / d;
65 |             if (l <= c * x && c * x <= r && l <= d * x && d * x <= r && gcd(c, d) == 1) {
66 |                 if (d * d == n) ++ans;
67 |                 else ans += 2;
68 |             }
69 |         }
70 |     }
71 | 
72 |     cout << ans << '\n';
73 |     return 0;
74 | }
75 | 
76 | 


--------------------------------------------------------------------------------
/Bag of Gold again.C:
--------------------------------------------------------------------------------
 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 atmost W kgs of gold such that the total value of the gold inside the bag is maximum.
 6 | 
 7 | Unlike last time, this time whenever you choose to pick a sample of gold, you have to take it completely, i.e. you cannot break down samples. You either pick the entire sample of gold, or you dont pick the sample at all.
 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 atmost W kgs of gold.
15 | 
16 | CONSTRAINTS
17 | 1 ≤ N ≤ 103 
18 | 1 ≤ W ≤ 103 
19 | 1 ≤ weights, values ≤ 103 
20 | 
21 | Sample Input 0
22 | 
23 | 1
24 | 3 50
25 | 10 60
26 | 20 100
27 | 30 120
28 | Sample Output 0
29 | 
30 | 220
31 | 
32 | 
33 | 
34 | 
35 | 
36 | #include <stdio.h>
37 | #include <string.h>
38 | #include <math.h>
39 | #include <stdlib.h>
40 | int max(int a, int b) { return (a > b)? a : b; } 
41 |   
42 | // Returns the maximum value that can be put in a knapsack of capacity W 
43 | int knapSack(int W, int wt[], int val[], int n) 
44 | { 
45 |    int i, w; 
46 |    int K[n+1][W+1]; 
47 | 
48 |    for (i = 0; i <= n; i++) 
49 |    { 
50 |        for (w = 0; w <= W; w++) 
51 |        { 
52 |            if (i==0 || w==0) 
53 |                K[i][w] = 0; 
54 |            else if (wt[i-1] <= w) 
55 |                  K[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]],  K[i-1][w]); 
56 |            else
57 |                  K[i][w] = K[i-1][w]; 
58 |        } 
59 |    } 
60 |   
61 |    return K[n][W]; 
62 | } 
63 | int main() 
64 | { 
65 |     int val[10000],wt[10000],n,t,W; 
66 |     scanf("%d",&t);
67 |     for(int i=1;i<=t;++i)
68 |     {
69 |         scanf("%d %d",&n,&W);
70 |         for(int j=0;j<n;++j)
71 |         {
72 |            scanf("%d %d",&wt[j],&val[j]);
73 |         }
74 |         printf("%d\n", knapSack(W, wt, val, n)); 
75 |     }
76 |     
77 |     return 0; 
78 | } 
79 | 


--------------------------------------------------------------------------------
/Datesorting.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 | 
35 | 
36 | #include <stdio.h>
37 | #include <string.h>
38 | #include <math.h>
39 | #include <stdlib.h>
40 | struct Date{
41 |     int d,m,y;
42 | };
43 | int main() {
44 |     int t,i,j;
45 |     scanf("%d",&t);
46 |     struct Date date[t];
47 |     for(i=0;i<t;i++){
48 |         scanf("%d%d%d",&date[i].d,&date[i].m,&date[i].y);
49 |     }
50 |     for(i=0;i<t-1;i++){
51 |         for(j=i+1;j<t;j++){
52 |             if(date[i].y > date[j].y){
53 |                 struct Date temp = date[i];
54 |                 date[i] = date[j];
55 |                 date[j] = temp;
56 |             }
57 |             if(date[i].y == date[j].y){
58 |                 if(date[i].m>date[j].m){
59 |                     struct Date temp = date[i];
60 |                     date[i] = date[j];
61 |                     date[j] = temp;
62 |                 }
63 |             }
64 |             if(date[i].y == date[j].y && date[i].m == date[j].m){
65 |                 if(date[i].d>date[j].d){
66 |                     struct Date temp = date[i];
67 |                     date[i] = date[j];
68 |                     date[j] = temp;
69 |                 }
70 |             }
71 |         }
72 |     }
73 |     for(i=0;i<t;i++){
74 |         printf("%d %d %d\n",date[i].d,date[i].m,date[i].y);
75 |     }
76 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
77 |     return 0;
78 | }
79 | 


--------------------------------------------------------------------------------
/Barua Number.CPP:
--------------------------------------------------------------------------------
 1 | Barua has developed his own Operating System known as "Barua OS" ( BOS ). One day while booting up his system he runs into a bug. You want to impress Barua so you jump in and offer to solve the bug yourself.
 2 | Barua doesn't like binary numbers very much and his operating system uses a new number system called BNS ( Barua Number System ). 
 3 | The following are the properties of a number represented in BNS form :
 4 | 
 5 | The number can only be made up of 2 distinct digits, one or zero.
 6 | The number cannot start with zero.
 7 | The number can have any number of zeroes, but only one instance of the digit one.
 8 | For example 100, 1000, 10000 are Barua Numbers whereas 101, 502, 625 are not Barua Numbers. Unfortunately one decimal number has crept into a list of Barua Numbers and Barua OS cannot find its product. Can you?
 9 | 
10 | Input Format:
11 | 
12 | First line contains an integer N, total number of elements in the list.
13 | 
14 | Next N lines contains a number a[i] <= 10^18.
15 | 
16 | NOTE :
17 | Out of the N numbers, there will be at most 1 decimal number and the remaining numbers will be Barua Numbers.
18 | There may be no decimal numbers at all.
19 | 
20 | Output Format: 
21 | Print one number, the product of all the numbers.
22 | 
23 | Input Constraints:
24 | 
25 | 1 <= N <= 10^6
26 | 
27 | 1 <= A[i] <= 10^18
28 | 
29 | Sample Input 0
30 | 
31 | 4
32 | 100
33 | 121
34 | 10
35 | 100
36 | Sample Output 0
37 | 
38 | 12100000
39 | 
40 | 
41 | 
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 |    long int n;
53 |     cin>>n;
54 |     long int i,ar[n],mul=1;
55 |     for(i=0;i<n;i++)
56 |     {
57 |         cin>>ar[i];
58 |     }
59 |     double num=0;
60 |     for(i=0;i<n;i++)
61 |     {
62 |         long int p=ar[i];
63 |         long int q=0;
64 |         while(p!=1)
65 |         {
66 |             int d=p%10;
67 |             if(d!=0)
68 |             {
69 |                 q=0;
70 |                 mul*=ar[i];
71 |                 break;
72 |             }
73 |             p/=10;
74 |             q++;
75 |         }
76 |         num+=q;
77 |     }
78 |     cout<<mul;
79 |     for(i=0;i<num;i++)
80 |         cout<<"0";
81 |     return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/Two_sum_value.CPP:
--------------------------------------------------------------------------------
 1 | For any given Array A[N], its TwoSum Value with respect to a number K is denoted by the number of ordered pairs {i, j} such that A[i] + A[j] = K. 
 2 | i and j must satisfy the following : 
 3 | 1 <= i <= N and 1 <= j <= N.
 4 | i may be equal to j at times.
 5 | You are given the Array A[N] and the number K.
 6 | Find and print the TwoSum value for the array.
 7 | 
 8 | Hint : You may want to use binary search algorithm for efficient implementation.
 9 | Hint2 : BinarySearch works only on sorted Arrays. So you may want to use library sort (qsort in C and sort in C++) function to sort the array first.
10 | 
11 | INPUT
12 | 
13 | The first line contains a number N(1 <= N <= 10^5), the size of array A[N].
14 | The second line contains N space separated integers denoting the elements of the array A. (1 <= A[i] <= 10^9).
15 | The third line contains one number K(1 <= K <= 10^9), with respect to which the TwoSum value of the array A is to be found.
16 | 
17 | OUTPUT
18 | 
19 | Output one number that is equal to the TwoSum value of the given input array A[N] with respect to K.
20 | 
21 | Sample Input 0
22 | 
23 | 10
24 | 1 2 3 4 5 6 7 8 9 10
25 | 10
26 | Sample Output 0
27 | 
28 | 9
29 | 
30 | 
31 | 
32 | #include <cmath>
33 | #include <cstdio>
34 | #include <vector>
35 | #include <iostream>
36 | #include <algorithm>
37 | using namespace std;
38 | long long int binarysearch(long long int arr[],long long int l,long long int r,long long int x) 
39 | { 
40 |     while (l <= r) 
41 |     { 
42 |         long long int m = l + (r - l) / 2;
43 |         if (arr[m] == x) 
44 |             return 1; 
45 |         if (arr[m] < x) 
46 |             l = m + 1;
47 |         else
48 |             r = m - 1; 
49 |     } 
50 |     return 0; 
51 | } 
52 | long long int print(long long int arr[],long long int n,long long int sum)
53 | {
54 |     long long int i,l=0,r=n-1,c=0,key;
55 |     sort(arr,arr+n);
56 |     for(i=0;i<n;i++)
57 |     {
58 |         key=sum-arr[i];
59 |         if(binarysearch(arr,l,r,key)==1)
60 |             c++;
61 |     }
62 |     return c;
63 | }
64 | int main() {
65 |     long long int n;
66 |     cin>>n;
67 |     long long int i,arr[n];
68 |     for(i=0;i<n;i++)
69 |         cin>>arr[i];
70 |     long long int key;
71 |     cin>>key;
72 |     cout<<print(arr,n,key);
73 |     return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/Algorithms/Bag of gold again.CPP:
--------------------------------------------------------------------------------
 1 | 
 2 | 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.
 3 | 
 4 | You are given N samples of gold, with the ith of them weighing Wi and having value Vi.
 5 | 
 6 | Your task is to fill the bag with atmost W kgs of gold such that the total value of the gold inside the bag is maximum.
 7 | 
 8 | Unlike last time, this time whenever you choose to pick a sample of gold, you have to take it completely, i.e. you cannot break down samples. You either pick the entire sample of gold, or you dont pick the sample at all.
 9 | 
10 | INPUT
11 | First line contains two integers, N and W. 
12 | 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
13 | 
14 | OUTPUT
15 | Print one number, the maximum attainable value when the bag is filled with atmost W kgs of gold.
16 | 
17 | CONSTRAINTS
18 | 1 ≤ N ≤ 103 
19 | 1 ≤ W ≤ 103 
20 | 1 ≤ weights, values ≤ 103 
21 | 
22 | Sample Input 0
23 | 
24 | 1
25 | 3 50
26 | 10 60
27 | 20 100
28 | 30 120
29 | Sample Output 0
30 | 
31 | 220
32 | 
33 | 
34 | 
35 | 
36 | 
37 | #include <stdio.h>
38 | #include <string.h>
39 | #include <math.h>
40 | #include <stdlib.h>
41 | int max(int a, int b) { return (a > b)? a : b; } 
42 |   
43 | // Returns the maximum value that can be put in a knapsack of capacity W 
44 | int knapSack(int W, int wt[], int val[], int n) 
45 | { 
46 |    int i, w; 
47 |    int K[n+1][W+1]; 
48 | 
49 |    for (i = 0; i <= n; i++) 
50 |    { 
51 |        for (w = 0; w <= W; w++) 
52 |        { 
53 |            if (i==0 || w==0) 
54 |                K[i][w] = 0; 
55 |            else if (wt[i-1] <= w) 
56 |                  K[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]],  K[i-1][w]); 
57 |            else
58 |                  K[i][w] = K[i-1][w]; 
59 |        } 
60 |    } 
61 |   
62 |    return K[n][W]; 
63 | } 
64 | int main() 
65 | { 
66 |     int val[10000],wt[10000],n,t,W; 
67 |     scanf("%d",&t);
68 |     for(int i=1;i<=t;++i)
69 |     {
70 |         scanf("%d %d",&n,&W);
71 |         for(int j=0;j<n;++j)
72 |         {
73 |            scanf("%d %d",&wt[j],&val[j]);
74 |         }
75 |         printf("%d\n", knapSack(W, wt, val, n)); 
76 |     }
77 |     
78 |     return 0; 
79 | } 
80 | 


--------------------------------------------------------------------------------
/LoopedList.C:
--------------------------------------------------------------------------------
 1 | You are not allowed to make any changes to the code other than the find_loop function body.
 2 | 
 3 | In the function, you will be given a head node to a linked list.
 4 | 
 5 | Two types of linked lists are :
 6 | Terminating Lists :
 7 | 
 8 | 1 -> 2 -> 7 -> 8 -> 9 -> NULL
 9 | Non-Terminating Lists(Loop in the list) :
10 | 
11 | 1 -> 2 -> 5 -> 15 -> 7--------
12 | 	 ^	 	     |
13 | 	 |                   |
14 | 	 ---- 3 <- 10 <- 9<--
15 | In the second type of list, you can traverse forever and never reach the end.
16 | 
17 | Modify the find_loop function so that given the head of the linked list, it returns 1 if the list has a loop and 0 otherwise.
18 | 
19 | Your code's memory consumption must not be dependant on the size of the linked list.
20 | 
21 | Input Format
22 | 
23 | Not Needed
24 | 
25 | Constraints
26 | 
27 | None
28 | 
29 | Output Format
30 | 
31 | Not Needed
32 | 
33 | 
34 | 
35 | 
36 | #include "stdio.h"
37 | #include "stdlib.h"
38 | #include "math.h"
39 | #include "string.h"
40 | 
41 | struct Node{
42 | 	int value;
43 | 	struct Node* next;
44 | };
45 | typedef struct Node Node;
46 | Node links[105];
47 | 
48 | void add_link(int from, int to){
49 | 	links[from].next = &links[to];
50 | }
51 | void set_value(int index, int val){
52 | 	links[index].value = val;
53 | }
54 | 
55 | 
56 | //BODY BEGINS HERE
57 | 
58 | int find_loop(struct Node* head){
59 |     /***
60 |     Your Code Here
61 |     It must return 1 if a loop exists and zero otherwise.
62 |     ***/    
63 |     struct Node *slow = head;
64 |     struct Node *fast = head;
65 |     while(fast != NULL && fast->next != NULL)
66 |     {
67 |         slow = slow->next;
68 |         fast = fast->next->next;
69 |         if (slow==fast)
70 |             return 1;
71 |     }
72 |     return 0;
73 | }
74 | 	/***
75 | 	Your Code Here
76 |     
77 | 	It must return 1 if a loop exists and zero otherwise.
78 | 	***/	
79 | 
80 | //BODY ENDS HERE
81 | 
82 | //TAIL BEGINS HERE
83 | int main(){
84 | 	int i,n,m,tmp,tmp1,tmp2;
85 | 	scanf("%d %d", &n, &m);
86 | 	for(i = 0; i < n; i++){
87 | 		scanf("%d", &tmp);
88 | 		set_value(i, tmp);
89 | 	}
90 | 	for(i = 0; i < m; i++){
91 | 		scanf("%d %d", &tmp1, &tmp2);
92 | 		add_link(tmp1,tmp2);
93 | 	}
94 | 	if(find_loop(&links[0]) == 1) printf("Loop Found");
95 | 	else printf("No Loop Found");
96 | 	return 0;
97 | }
98 | 


--------------------------------------------------------------------------------
/One teacher Two classes.CPP:
--------------------------------------------------------------------------------
 1 | Jessy, the P.E instructor for Middle Vale High School has to arrange his students in line for aerobics. Thankfully, his class of students already came to the court in a line of increasing order of heights. Not so thankfully, James, another P.E instructor is on leave again. So she has to take care of his class right now as well. The second class of students also came in a line of increasing order of heights. But Jessy feels that is useless since she has to make both classes stand together in a single line for her exercises. But you, the janitor (and also a computer science graduate with no other job), sees that this is the right place to use the merge technique. So write a program to help Jessy arrange the students in ascending order of their heights.
 2 | 
 3 | Formally, given two sorted arrays, merge them into one sorted array and print the result.
 4 | 
 5 | INPUT
 6 | 
 7 | The first line of input is n (1
 8 | 
 9 | OUTPUT
10 | 
11 | Print the heights of the students in a row after both the lines have been merged.
12 | 
13 | Sample Input 0
14 | 
15 | 5
16 | 2 4 6 8 10
17 | 5
18 | 1 3 5 7 9
19 | Sample Output 0
20 | 
21 | 1 2 3 4 5 6 7 8 9 10 
22 | 
23 | 
24 | 
25 | 
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | void mergeArrays(long long int arr1[],long long int arr2[],long long int n1, 
33 |                              long long int n2,long long int arr3[]) 
34 | { 
35 |     int i = 0, j = 0, k = 0; 
36 |     while (i<n1 && j <n2) 
37 |     { 
38 |         if (arr1[i] < arr2[j]) 
39 |             arr3[k++] = arr1[i++]; 
40 |         else
41 |             arr3[k++] = arr2[j++]; 
42 |     } 
43 |     while (i < n1) 
44 |         arr3[k++] = arr1[i++]; 
45 |     while (j < n2) 
46 |         arr3[k++] = arr2[j++]; 
47 | } 
48 | 
49 | int main() {
50 |     long long int i,n,m;
51 |     cin>>n;
52 |     long long int a[n];
53 |     for(i=0;i<n;i++)
54 |         cin>>a[i];
55 |     cin>>m;
56 |     long long int b[m];
57 |     for(i=0;i<m;i++)
58 |         cin>>b[i];
59 |      long long int c[n+m]; 
60 |     mergeArrays(a, b, n, m, c); 
61 |     for (int i=0; i < n+m; i++) 
62 |         cout << c[i] << " ";
63 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/Pyramidbynumericals.CPP:
--------------------------------------------------------------------------------
 1 | Identify the logic behind the series
 2 | 
 3 | 6 28 66 120 190 276....
 4 | 
 5 | 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.
 6 | 
 7 | The Pyramid construction rules are as follows
 8 | 1. First number in the series should be at the top of the Pyramid
 9 | 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.
10 | 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.
11 | 
12 | Example
13 | 
14 | If input is 2, output will be
15 | 
16 |  00006
17 | 00028 00066
18 | 
19 | If input is 3, output will be
20 | 
21 |   00006
22 |  00028 00066
23 | 00120 00190 00276
24 | Input Format
25 | 
26 | First line of input will contain number N that corresponds to the width of the bottom-most layer of the Pyramid
27 | 
28 | Constraints
29 | 
30 | 0 < N <= 14
31 | 
32 | Output Format
33 | 
34 | The Pyramid constructed out of numbers in the series as per stated construction rules
35 | 
36 | Sample Input 0
37 | 
38 | 2
39 | Sample Output 0
40 | 
41 |  00006
42 | 00028 00066
43 | Sample Input 1
44 | 
45 | 3
46 | Sample Output 1
47 | 
48 |   00006
49 |  00028 00066
50 | 00120 00190 00276
51 | 
52 | 
53 | 
54 | 
55 | #include <stdio.h>
56 | #include <string.h>
57 | #include <math.h>
58 | #include <stdlib.h>
59 | 
60 | int main() {
61 | 
62 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
63 |     int i,j,n,k=2;
64 |     scanf("%d",&n);
65 |     int space=n-1;
66 |     for(i=1;i<=n;i++)
67 |     {
68 |         for(j=1;j<=space;j++)
69 |            printf(" ");
70 |         for(j=1;j<=i;j++)
71 |         {
72 |             printf("%1.5d ",(k*(2*k-1)));
73 |             
74 |             k=k+2;
75 |             
76 |             
77 |         }
78 |         space--;
79 |         printf("\n");
80 |         
81 |     }
82 |     return 0;
83 | }
84 | 


--------------------------------------------------------------------------------
/Into the forest.C:
--------------------------------------------------------------------------------
 1 | A tree is defined as a group of nodes such that for every pair of nodes in the tree it is possible to reach from one node to another. Note that this definition is applicable when the edges are bidirectional.
 2 | 
 3 | Size of a tree is defined as the number of nodes in a tree.
 4 | 
 5 | You are given a forest. A forest is a collection of multiple trees. Your task is to gather information about this forest.
 6 | 
 7 | Formally, you are supposed to find out three characteristics : 
 8 | * Size of the biggest tree in the forest * Size of the smallest tree in the forest * Number of trees in the forest
 9 | 
10 | Input
11 | First line contains two integers N and M where N denotes the number of nodes and M denotes the number of edges. 
12 | The nodes are numbered from 1 to N. 
13 | Next M lines each contain a pair of integers U and V denoting that there is an edge between the node with index U and the node with index V.
14 | 
15 | Output
16 | Print three integers, the max size of a tree, the min size of a tree and the number of trees in the forest
17 | 
18 | Notes
19 | 1 ≤ N, M< ≤ 1000
20 | There may be multiple edges or self edges
21 | Sample Input 0
22 | 
23 | 5 3
24 | 1 2
25 | 2 3
26 | 4 5
27 | Sample Output 0
28 | 
29 | 3 2 2
30 | 
31 | 
32 | 
33 | 
34 | 
35 | 
36 | #include <stdio.h>
37 | #include <string.h>
38 | #include <math.h>
39 | #include <stdlib.h>
40 | int *v;
41 | int min=1001,max=0,c=1,n;
42 | void dfs(int i,int a[][n])
43 | {
44 |     v[i]=1;
45 |     for(int j=0;j<n;j++)
46 |     {
47 |         if(v[j]==0&&a[i][j]==1){
48 |             c++;
49 |             dfs(j,a);
50 |           }
51 |     }
52 |     if(c<min)min=c;
53 |     if(c>max)max=c;
54 |     
55 | }
56 | int main() {
57 |     int m;
58 |     scanf("%d%d",&n,&m);
59 |     v=(int *)malloc(sizeof(int)*n);
60 |     for(int i=0;i<n;i++)
61 |         v[i]=0;
62 |     int a[n][n];
63 |     for(int i=0;i<n;i++)
64 |         for(int j=0;j<n;j++)
65 |             a[i][j]=0;
66 |     for(int i=0;i<m;i++)
67 |     {
68 |         int x,y;
69 |         scanf("%d%d",&x,&y);
70 |         
71 |         a[x-1][y-1]=1;
72 |         a[y-1][x-1]=1;
73 |     }
74 |     int x=0;
75 |     for(int i=0;i<n;i++)
76 |     {
77 |         if(v[i]==0){c=1;dfs(i,a);x++;}
78 |     }
79 |     if(c<min)min=c;
80 |     if(c>max)max=c;
81 |     if(x==1)min=max;
82 |     printf("%d %d %d",max,min,x);
83 |         return 0;
84 | }
85 | 


--------------------------------------------------------------------------------
/Intothewater.CPP:
--------------------------------------------------------------------------------
 1 | Aditi takes place in a bike race. The race takes place along the roads at the shores of the Hussain Sagar Lake. As everyone knows, the boundaries of the Hussain Sagar Lake consists only of straight lines that are either horizontal with respect to the equator or vertical as seen from the space.
 2 | 
 3 | Assume a 2D co-ordinate system with the hussain sagar lake being a polygon in it with all its side either parallel to the X-axis or the Y-axis. The starting point of the race is the southernmost position of the boundary. Since all sections are straight, Aditi is always travelling in one of the four directions : East, West, North or South. Every turn is a 90 degree turn i.e. every two consecutive roads will be perpendicular to each other.
 4 | 
 5 | Aditi is still naive so she is not very confident at some turns. Name, Aditi feels insecure at a turn there is a possibility that she can fall into the Hussain Sagar Lake. In formal words, Aditi considers a turn dangerous if she can fall directly into the water upon ignoring the turn.
 6 | 
 7 | Help Aditi get ready for the competition -- determine the number of dangerous turns.
 8 | 
 9 | Input Format
10 | 
11 | The first line contains integer N, the number of straight sections of the boundary.
12 | Next N+1 lines contains pairs of integers (xi, yi). The first of these points is the starting position. The ith straight section begins at point (xi, yi) and ends at (xi+1, yi+1).
13 | It is guaranteed that :
14 | 
15 | The first section is directed towards north.
16 | The southernmost point is the starting point.
17 | The last point coincides with the first point.
18 | Any pairs of straight lines share no points except the neighbouring tracks that share one end point.
19 | No pair of points except the first and the last is same.
20 | Constraints
21 | 
22 | 4 <= n <= 100
23 | -10000 <= xi,yi <= 10000
24 | 
25 | Output Format
26 | 
27 | Print a single integer — the number of dangerous turns on the track.
28 | 
29 | Sample Input 0
30 | 
31 | 6
32 | 0 0
33 | 0 1
34 | 1 1
35 | 1 2
36 | 2 2
37 | 2 0
38 | 0 0
39 | Sample Output 0
40 | 
41 | 1
42 | 
43 | 
44 | 
45 | #include <stdio.h>
46 | #include <string.h>
47 | #include <math.h>
48 | #include <stdlib.h>
49 | 
50 | int main() {
51 | 
52 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
53 |     int n;
54 |     cin>>n;
55 |     cout<<(n-4)/2;
56 |     return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/Algorithms/Ebola curve.CPP:
--------------------------------------------------------------------------------
 1 | An antidote has been developed for the ebola crisis. This antidote is conjuctive, i.e. If it is given to a person, then the person who is connected to this person will also be cured. Two people X and Y are connected if X and Y are adjacent or if there exists a person Z such that X and Z are connected and Z and Y are connected.
 2 | 
 3 | So, for every connected group of people we need one antidote. This antidotes strength must be equal to the highest infected person in the group.
 4 | 
 5 | Your task is to calculate the number of antidotes of different strengths needed.
 6 | 
 7 | Input
 8 | First line contains the size of the grid N. 
 9 | Next contains the NxN grid.
10 | 
11 | Output
12 | Print 4 integers, the number of antidotes required of strength 2, 3, 4 and 5.
13 | 
14 | Sample Input 0
15 | 
16 | 5
17 | 0 0 0 1 5
18 | 1 1 0 1 1
19 | 3 1 0 0 0
20 | 1 1 0 1 1
21 | 4 4 0 3 1
22 | Sample Output 0
23 | 
24 | 0 1 1 1 
25 | 
26 | 
27 | 
28 | #include<bits/stdc++.h>
29 | using namespace std;
30 | 
31 | int vis(vector<vector<int> > &a,vector<vector<bool> > &v,int i,int j){
32 |     v[i][j]=1;
33 |     int mx=a[i][j];
34 |     if(i-1>=0 && !v[i-1][j] && a[i-1][j]) mx=max(mx,vis(a,v,i-1,j));
35 |     if(j-1>=0 && !v[i][j-1] && a[i][j-1]) mx=max(mx,vis(a,v,i,j-1));
36 |     if(i+1<v.size() && !v[i+1][j] && a[i+1][j]) mx=max(mx,vis(a,v,i+1,j));
37 |     if(j+1<v.size() && !v[i][j+1] && a[i][j+1]) mx=max(mx,vis(a,v,i,j+1));
38 |     
39 |     if(i-1>=0 && j-1>=0 && !v[i-1][j-1] && a[i-1][j-1]) mx=max(mx,vis(a,v,i-1,j-1));
40 |     if(j-1>=0 && i+1<v.size() && !v[i+1][j-1] && a[i+1][j-1]) mx=max(mx,vis(a,v,i+1,j-1));
41 |     if(i+1<v.size() && j+1<v.size() && !v[i+1][j+1] && a[i+1][j+1]) mx=max(mx,vis(a,v,i+1,j+1));
42 |     if(j+1<v.size() && i-1>=0 && !v[i-1][j+1] && a[i-1][j+1]) mx=max(mx,vis(a,v,i-1,j+1));
43 |     return mx;
44 | }
45 | 
46 | int main() {
47 |     int n;  cin>>n;
48 |     vector<vector<int> > a(n,vector<int> (n));
49 |     for(int i=0;i<n;i++)
50 |         for(int j=0;j<n;j++)    cin>>a[i][j];
51 |     
52 |     vector<vector<bool> > v(n,vector<bool> (n,0));
53 |     vector<int> c(6,0);
54 |     for(int i=0;i<n;i++){
55 |         for(int j=0;j<n;j++){
56 |             if(!v[i][j] && a[i][j]){
57 |                 int mx=vis(a,v,i,j);
58 |                 c[mx]++;
59 |             }
60 |         }
61 |     }
62 |     for(int i=2;i<6;i++)
63 |         cout<<c[i]<<' ';
64 |     return 0;
65 | }
66 | 


--------------------------------------------------------------------------------
/Great_Pattern.CPP:
--------------------------------------------------------------------------------
  1 | Your task is simple, write a program in Java to print the following pattern :
  2 | 
  3 | N = 1
  4 | 1
  5 | 
  6 | N = 2
  7 |   1
  8 | 1 2 1
  9 |   1
 10 |   
 11 | N = 3
 12 |     1
 13 |   1 2 1
 14 | 1 2 3 2 1
 15 |   1 2 1
 16 |     1
 17 |     
 18 | and so on..
 19 | INPUT
 20 | Input consists of many test cases. 
 21 | First line contains the number of test case T. 
 22 | Each of the test case lines consists of one number N for that test case.
 23 | 
 24 | OUTPUT
 25 | Print the pattern corresponding to the N value of each test case. 
 26 | Print a blank line between two test case outputs.
 27 | 
 28 | CONSTRAINTS
 29 | 1 ≤ T, N ≤ 10
 30 | 
 31 | Sample Input 0
 32 | 
 33 | 3
 34 | 1
 35 | 2
 36 | 3
 37 | Sample Output 0
 38 | 
 39 | 1
 40 | 
 41 |   1
 42 | 1 2 1
 43 |   1
 44 |   
 45 |     1
 46 |   1 2 1
 47 | 1 2 3 2 1
 48 |   1 2 1
 49 |     1
 50 | Contest ends in 39 minutes 24 seconds
 51 | Submissions: 277
 52 | Max Score: 50
 53 | Rate This Challenge:
 54 | 
 55 |     
 56 | 
 57 | 
 58 | 
 59 | 
 60 | 
 61 | #include <cmath>
 62 | #include <cstdio>
 63 | #include <vector>
 64 | #include <iostream>
 65 | #include <algorithm>
 66 | using namespace std;
 67 | 
 68 | 
 69 | int main() {
 70 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
 71 |     int n,i,j,k,l,t,test;
 72 |     cin>>test;
 73 |     while(test--){
 74 |         cin>>n;
 75 |         int space = 2*(n-1);
 76 |         for(i=1;i<=n;i++){
 77 |             t=0;
 78 |             for(k=1;k<=space;k++){
 79 |                 cout<<" ";
 80 |             }
 81 | 
 82 |             for(j=1;j<=i;j++){  
 83 |                 cout<<j<<" ";
 84 |                 t++;
 85 |             }
 86 |             for(l=t-1;l>=1;l--){
 87 |                 cout<<l<<" ";
 88 |             }
 89 |             space-=2;
 90 |             cout<<endl;
 91 |         }
 92 |      //   int len=i;
 93 |         space = 2;
 94 | 
 95 |         for(int i=n-1;i>=1;i--){
 96 |             t=0;
 97 |             for(k=1;k<=space;k++){
 98 |                 cout<<" ";
 99 |             }
100 |             for(j=1;j<=i;j++){  
101 |                 cout<<j<<" ";
102 |                 t++;
103 |             }
104 |             for(l=t-1;l>=1;l--){
105 |                 cout<<l<<" ";
106 |             }
107 |             space+=2;
108 |             cout<<endl;
109 |         }
110 |         cout<<endl;
111 |     }
112 |     return 0;
113 | }
114 | 


--------------------------------------------------------------------------------
/Tilak has fun with the Lights.CPP:
--------------------------------------------------------------------------------
 1 | There are n lights in a row such that they are numbered 1 to n from left to right. Initially some of the lights are switched on. Tilak intends to switch all the lights on. At every step he can switch a light on (this light should be switched off at that moment) if and only if there's at least one adjacent light which is already switched on.
 2 | 
 3 | He knows the initial state of each of the lights and he's wants to know how many different ways exist to switch all the lights on. Please find the required number of ways modulo 1000000007 (1e9 + 7). (where 1eN means Nth power of 10)
 4 | 
 5 | Input Format
 6 | 
 7 | The first line of the input contains two integers n and m where n is the number of lights in the sequence and m is the number of lights which are initially switched on.
 8 | 
 9 | The second line contains m distinct integers, each between 1 to n inclusive, denoting the indices of lights which are initially switched on.
10 | 
11 | Constraints
12 | 
13 | (1 ≤ n ≤ 1000)
14 | 
15 | ( 1 ≤ m ≤ n)
16 | 
17 | Output Format
18 | 
19 | In the only line of the output print the number of different possible ways to switch on all the lights modulo 1000000007 (1e9 + 7). (where 1eN means Nth power of 10)
20 | 
21 | Sample Input 0
22 | 
23 | 3 1
24 | 1
25 | Sample Output 0
26 | 
27 | 1
28 | Sample Input 1
29 | 
30 | 4 2
31 | 1 4
32 | Sample Output 1
33 | 
34 | 2
35 | Sample Input 2
36 | 
37 | 11 2
38 | 4 8
39 | Sample Output 2
40 | 
41 | 6720
42 | 
43 | 
44 | 
45 | #include <iostream>
46 | #include <cstdio>
47 | #include <algorithm>
48 | 
49 | #define N 1100
50 | #define M 1000000007
51 | 
52 | using namespace std;
53 | 
54 | long long n, m, a[N], f[N][N], p[N], ans = 1, s;
55 | 
56 | int main(){
57 |     cin >> n >> m;
58 |     for (int i = 0; i < m; i++) cin >> a[i];
59 | 
60 |     for (int i = 0; i <= n + 1; i++) f[0][i] = 1;
61 |     for (int i = 1; i <= n + 1; i++)
62 |         for (int j = 1; j <= n + 1; j++)
63 |             f[i][j] = (f[i - 1][j] + f[i][j - 1]) % M;
64 |     p[0] = 1;
65 |     for (int i = 1; i <= n; i++) p[i] = (p[i - 1] * 2) % M;
66 | 
67 |     sort(a, a + m);
68 |     s = a[0] - 1;
69 |     for (int i = 1; i < m; i++){
70 |         int l = a[i] - a[i - 1] - 1;
71 |         if (l == 0) continue;
72 |         ans = (ans * f[l][s + 1]) % M;
73 |         ans = (ans * p[l - 1]) % M;
74 |         s += l;
75 |     }
76 |     ans = (ans * f[n - a[m - 1]][s + 1]) % M;
77 | 
78 |     cout << ans;
79 | }
80 | 


--------------------------------------------------------------------------------
/Gas Stations.CPP:
--------------------------------------------------------------------------------
 1 | There are N gas stations along a circular route, where the amount of gas at station i is gas[i].
 2 | 
 3 | 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.
 4 | 
 5 | Print the minimum starting gas station’s index if you can travel around the circuit once, otherwise print -1.
 6 | 
 7 | 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.
 8 | 
 9 | Input Format
10 | 
11 | First line contains the number of gas stations N.
12 | Second line contains N integers, the ith of them denoting gas[i].
13 | Third line contains N integers, the ith of them denoting cost[i].
14 | 
15 | Constraints
16 | 
17 | 1 <= N <= 105
18 | 
19 | Output Format
20 | 
21 | Print the minimum starting gas station’s index if you can travel around the circuit once, otherwise print -1.
22 | 
23 | Sample Input 0
24 | 
25 | 2
26 | 1 2
27 | 2 1
28 | Sample Output 0
29 | 
30 | 1
31 | 
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 |     int n;
44 |     cin>>n;
45 |     long long int gas[n],cost[n];
46 |     for(int i=0;i<n;i++)
47 |         cin>>gas[i];
48 |     for(int i=0;i<n;i++)
49 |         cin>>cost[i];
50 |     int k=0;
51 |     while(k<n)
52 |     {
53 |         if(gas[k]<cost[k])
54 |         {
55 |             k++;
56 |             continue;
57 |         }
58 |         long long int g=0,c=0,l;
59 |         for(l=k;l<n;l++)
60 |         {
61 |         g+=gas[l];
62 |         c+=cost[l];
63 |         if(g<c)
64 |         {
65 |             break;
66 |         }
67 |         }
68 |         if(l!=n)
69 |         {
70 |             k++;
71 |             continue;
72 |         }
73 |         for(l=0;l<k;l++)
74 |         {
75 |             g+=gas[l];
76 |             c+=cost[l];
77 |             if(g<c)
78 |             {
79 |                 break;
80 |             }
81 |         }
82 |         if(l!=k)
83 |         {
84 |             k++;
85 |             continue;
86 |         }
87 |         cout<<k;
88 |         break;
89 |     }
90 |     if(k==n)
91 |         cout<<"-1";
92 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
93 |     return 0;
94 | }
95 | 
96 | 
97 | 
98 | 
99 | 


--------------------------------------------------------------------------------
/EmployeeSheet.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 | 
48 | 
49 | #include <cmath>
50 | #include <cstdio>
51 | #include <vector>
52 | #include <iostream>
53 | #include <algorithm>
54 | #include <string.h>
55 | using namespace std;
56 | 
57 | struct Employee{
58 |     char name[55];
59 |     int salary;
60 | };
61 | 
62 | int main() {
63 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
64 |     int n,i,j;
65 |     struct Employee a[1000],temp;
66 |     cin>>n;
67 |     for(i=0;i<n;i++)
68 |         cin>>a[i].name>>a[i].salary;
69 |     for(i=0;i<n;i++){
70 |         for(j=i+1;j<n;j++){
71 |             if(a[i].salary > a[j].salary){
72 |                 temp = a[i];
73 |                 a[i] = a[j];
74 |                 a[j] = temp;
75 |             }else if(a[i].salary == a[j].salary && strcmp(a[i].name,a[j].name)>0){
76 |                 temp = a[i];
77 |                 a[i] = a[j];
78 |                 a[j] = temp;
79 |             }else
80 |                 continue;
81 |         }
82 |     }
83 |     for(i=0;i<n;i++){
84 |         cout<<a[i].name<<" "<<a[i].salary<<endl;
85 |     }
86 |     return 0;}
87 | 


--------------------------------------------------------------------------------
/Dylan and array(Arrays without local maximum).CPP:
--------------------------------------------------------------------------------
 1 | Ivan unexpectedly saw a present from one of his previous birthdays. It is array of n numbers from 1 to 200. Array is old and some numbers are hard to read. Ivan remembers that for all elements at least one of its neighbours ls not less than it, more formally:
 2 | 
 3 | a1≤a2,
 4 | 
 5 | an≤an−1 and
 6 | 
 7 | ai≤max(ai−1,ai+1) for all i from 2 to n−1.
 8 | 
 9 | Ivan does not remember the array and asks to find the number of ways to restore it. Restored elements also should be integers from 1 to 200. Since the number of ways can be big, print it modulo 998244353.
10 | 
11 | Input
12 | First line of input contains one integer n (2≤n≤105) — size of the array.
13 | 
14 | Second line of input contains n integers ai — elements of array. Either ai=−1 or 1≤ai≤200. ai=−1 means that i-th element can't be read.
15 | 
16 | Output
17 | Print number of ways to restore the array modulo 998244353.
18 | 
19 | Examples
20 | input
21 | 3
22 | 1 -1 2
23 | output
24 | 1
25 | input
26 | 2
27 | -1 -1
28 | output
29 | 200
30 | Note
31 | In the first example, only possible value of a2 is 2.
32 | 
33 | In the second example, a1=a2 so there are 200 different values because all restored elements should be integers between 1 and 200.
34 | 
35 | 
36 | #include <bits/stdc++.h>
37 | using namespace std;
38 | const int maxn = 1e5+5;
39 | const int mod = 998244353;
40 | int a[maxn];
41 | long long dp[maxn][205][3];
42 | int main() {
43 | 	int n;
44 | 	scanf("%d", &n);
45 | 	for(int i = 0; i < n; ++i)
46 | 		scanf("%d", &a[i]);
47 | 	if(a[0] != -1) 
48 | 		dp[0][a[0]][0] = 1;
49 | 	else {
50 | 		for(int i = 1; i <= 200; ++i)
51 | 			dp[0][i][0] = 1;
52 | 	}
53 | 	for(int i = 1; i < n; ++i) {
54 | 		int sum = 0;
55 | 		for(int j = 1; j <= 200; ++j) {
56 | 			if(a[i] == -1 || j == a[i]) {
57 | 				dp[i][j][0] = sum;
58 | 			}
59 | 			
60 | 			sum = (sum+dp[i-1][j][1]+dp[i-1][j][0]+dp[i-1][j][2])%mod;
61 | 		}
62 | 		sum = 0;
63 | 		for(int j = 1; j <= 200; ++j) {
64 | 			if(a[i] == -1 || j == a[i]) {
65 | 				dp[i][j][1] = (dp[i-1][j][0]+dp[i-1][j][1]+dp[i-1][j][2])%mod;
66 | 			}
67 | 			
68 | 		}
69 | 		for(int j = 200; j >= 1; --j) {
70 | 			if(a[i] == -1 || j == a[i]) {
71 | 				dp[i][j][2] = sum;
72 | 			}
73 | 			sum = (sum+dp[i-1][j][2]+dp[i-1][j][1])%mod;
74 | 		}
75 | 	}
76 | 	long long ans = 0;
77 | 	for(int i = 1; i <= 200; ++i) {
78 | 		ans = (ans+dp[n-1][i][1]+dp[n-1][i][2])%mod;
79 | 	}
80 | 	printf("%lld\n", ans);
81 | 	return 0;
82 | }
83 | 


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


--------------------------------------------------------------------------------
/PrimeOfPrimes.CPP:
--------------------------------------------------------------------------------
 1 | A number is super prime if the sum of all its divisors except itself is a prime number. 
 2 | A prime number is a number which can only be divided by two numbers, 1 and itself. 
 3 | 1 is neither prime nor composite. 
 4 | For this task, you are to write a program to find out whether a given number is super prime or not. 
 5 | See the sample case for clarity
 6 | 
 7 | Input
 8 | Input consists of multiple test cases. 
 9 | First line contains T the number of test cases. 
10 | Then T lines follow. Each test case contains one integer only, N.
11 | 
12 | Output
13 | For every test case print "yes" if N is a super prime and "no" otherwise.
14 | 
15 | Notes
16 | 1 ≤ T ≤ 10000
17 | 1 ≤ N, ≤ 106
18 | Your code must be efficient and optimal
19 | Sample Input 0
20 | 
21 | 4
22 | 1
23 | 2
24 | 4
25 | 6
26 | Sample Output 0
27 | 
28 | no
29 | no
30 | yes
31 | no
32 | Explanation 0
33 | 
34 | 1 : sum = 0 : not prime 
35 | 2 : sum = 1 : not prime 
36 | 4 : sum = 1 + 2 = 3 : prime 
37 | 6 : sum = 1 + 2 + 3 = 6 : not prime
38 | 
39 | 
40 | 
41 | #include <stdio.h>
42 | #include <string.h>
43 | #include <math.h>
44 | #include <stdlib.h>
45 | 
46 | int divSum(int num) 
47 | { 
48 |     // Final result of summation of divisors 
49 |     int result = 0; 
50 |   
51 |     // find all divisors which divides 'num' 
52 |     for (int i=2; i<=sqrt(num); i++) 
53 |     { 
54 |         // if 'i' is divisor of 'num' 
55 |         if (num%i==0) 
56 |         { 
57 |             // if both divisors are same then add 
58 |             // it only once else add both 
59 |             if (i==(num/i)) 
60 |                 result += i; 
61 |             else
62 |                 result += (i + num/i); 
63 |         } 
64 |     } 
65 |   
66 |     // Add 1 to the result as 1 is also a divisor 
67 |     return (result + 1); 
68 | } 
69 | 
70 | int isprime(long long int x) 
71 | {
72 |     long long int i;
73 |     if(x==0 || x==1) return 0; 
74 |     else {
75 |     for (int i=2; i*i<=x; i++) 
76 |         if (x%i == 0) 
77 |             return 0; 
78 |     return 1; 
79 |          }
80 | } 
81 | 
82 | int main() {
83 | 
84 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
85 |     long int t;
86 |     scanf("%ld", &t);
87 |     while(t--){
88 |         int a;
89 |         scanf("%d", &a);
90 |         int sum = divSum(a);
91 |         if(isprime(sum))
92 |             printf("yes\n");
93 |         else
94 |             printf("no\n");
95 |     }
96 |     return 0;
97 | }
98 | 


--------------------------------------------------------------------------------
/Jason fights the monster.CPP:
--------------------------------------------------------------------------------
 1 | Jason is trapped in a forest with n hungry monsters and must use his trusty blaster to defend himself! Each monster i has a health value,h(i) .
 2 | Jason can discharge his blaster at a monster once per second and reduce its health points by hit units. Once a monster's health points become <=0, it dies.
 3 | Given the health values for each monster and an integer, t, can you determine the maximum number of monsters he can kill in t seconds? Assume Jason always hits his target!
 4 | 
 5 | Input Format
 6 | 
 7 | The first line consists of three space-separated integers describing the respective values of n,hit , and t. 
 8 | The second line consists of  space-separated integers describing the values of h(0),h(1),...,h(n-1).
 9 | 
10 | Constraints
11 | 
12 | Output Format
13 | 
14 | Print an integer denoting the maximum number of monsters Jason can kill in  seconds.
15 | 
16 | Sample Input 0
17 | 
18 | 7 8 6
19 | 16 19 7 11 23 8 16
20 | Sample Output 0
21 | 
22 | 4
23 | Explanation 0
24 | 
25 | We want to find the maximum number of monsters we can kill in t=6 seconds using a blaster that does hit=8 units of damage per second. The diagram below depicts the array of initial health values, :
26 | h=[16,19,7,11,23,8,16]
27 | The optimal approach is as follows:
28 | 
29 | Shoot monster 2 so h=7-8=-1, monster 2 dies, and  becomes [16,19,-1,11,23,8,16]:
30 | Shoot monster 5 so h=8-8=0, monster  dies, and  becomes [16,19,-1,11,23,0,16]:
31 | Shoot monster 3 so h=11-8=3, monster  dies, and  becomes [16,19,-1,3,23,0,16]:
32 | Shoot monster 3 so h=3-8=-5, monster  dies, and  becomes [16,19,-1,-5,23,0,16]:
33 | Shoot monster 0 so h=16-8=8, monster  dies, and  becomes [8,19,-1,-5,23,0,16]:
34 | Shoot monster 0 so h=8-8=0, monster  dies, and  becomes [0,19,-1,-5,23,0,16]:
35 | 
36 | Thus, we print 4 as the maximum number of monsters we can kill in the given time period.
37 | 
38 | 
39 | 
40 | 
41 | #include <bits/stdc++.h>
42 | 
43 | using namespace std;
44 | 
45 | const int maxn = 100005;
46 | 
47 | int a[maxn],n,l,t;
48 | 
49 | int main()
50 | {
51 |     scanf("%d%d%d", &n, &l, &t);
52 |     for(int i = 1;i <= n;i ++) scanf("%d", &a[i]);
53 |     sort(a + 1,a + n + 1);
54 |     int ans = 0;
55 |     for(int i = 1;i <= n;i ++)
56 |     {
57 |         int ned = a[i] / l;
58 |         if (l * ned < a[i]) ++ ned;
59 |         t -= ned;
60 |         if (t < 0) break;
61 |         ans ++;
62 |     }
63 |     printf("%d\n", ans);
64 |     return 0;
65 | }
66 | 
67 | 
68 | 
69 | 
70 | 
71 | 
72 | 
73 | 
74 | 


--------------------------------------------------------------------------------
/KefaHatesCoins.C:
--------------------------------------------------------------------------------
 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 | 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.
12 | 
13 | 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.
14 | 
15 | INPUT
16 | First line contains two numbers N and M.
17 | Second line contains the array A of size N.
18 | Third line contains the array P of size M.
19 | 
20 | INPUT
21 | Print M lines of output, for every gift two integers on a new line. 
22 | The two integers should denote the values of X and K while buying that gift optimally.
23 | If it is not possible to buy a particular gift with available coins, print "-1 -1"
24 | 
25 | CONSTRAINTS
26 | 1 ≤ N, M ≤ 105 
27 | 1 ≤ Ai, Pi ≤ 105 
28 | 
29 | Sample Input 0
30 | 
31 | 10 5
32 | 1 2 3 4 5 1 2 3 4 5
33 | 6
34 | 6
35 | 6
36 | 6
37 | 6
38 | Sample Output 0
39 | 
40 | 4 6
41 | 2 6
42 | 2 8
43 | 2 10
44 | -1 -1
45 | 
46 | 
47 | 
48 | 
49 | #include <stdio.h>
50 | #include <string.h>
51 | #include <math.h>
52 | #include <stdlib.h>
53 | int cmp(const void *a,const void *b){
54 |     return(*(int*)a-*(int*)b);
55 | }
56 | int main() {
57 | int m,n;
58 |     scanf("%d%d",&n,&m);
59 |     int a[n];
60 |     for(int i=0;i<n;i++){
61 |         scanf("%d",&a[i]);
62 |     }
63 |     qsort(a,n,sizeof(int),cmp);
64 |     int v;
65 |     for(int i=0,j=0;i<m;i++){
66 |         scanf("%d",&v);
67 |         int s=0,f=0,c=0;
68 |         while(s<v){
69 |             if(j==n){
70 |                 f=1;
71 |                 break;
72 |             }
73 |             s=s+a[j];
74 |             j++;
75 |             c++;
76 |             
77 |         }
78 |         if(f==1){
79 |             printf("%d %d\n",-1,-1);
80 |         }
81 |         else
82 |             printf("%d %d\n",c,s);
83 |     }
84 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
85 |     return 0;
86 | }
87 | 


--------------------------------------------------------------------------------
/Tisha_and_Orange_Sorting.CPP:
--------------------------------------------------------------------------------
 1 | Tisha and her Orange Sorting
 2 | 
 3 | You have seen Tisha and he oranges in the previous question. Her eldest son on the other hand, sees what his mother does and decides to help her sort out the oranges in increasing order of size. He is also quick to realize that they should be following the quicksort algorithm and finds this pseudocode from this Data Structures text book. Assume the oranges are neatly stacked in a row.
 4 | 
 5 | Quicksort Pseudocode :
 6 | 
 7 | Quicksort(arr, l, r) : 
 8 | 	if (l < r) : 
 9 | 		p = partition(arr, l, r)
10 | 		print(p)
11 | 		print(arr from l to r)
12 | 		Quicksort(arr, l, p - 1)
13 | 		Quicksort(arr, p + 1, r)
14 | INPUT
15 | 
16 | The first line of input is n (1≤n≤100), the number of oranges Tisha plucked from the orchard 
17 | The second line of input are the diameters of the oranges you just took (positive numbers) each separated by a space. Assume the first orange in the row to be the pivot element each time.
18 | 
19 | OUTPUT
20 | 
21 | Print the sizes of the oranges in a row after the sorting has been done
22 | 
23 | Sample Input 0
24 | 
25 | 10
26 | 2 4 6 8 10 1 3 5 7 9
27 | Sample Output 0
28 | 
29 | 8
30 | 2 4 6 8 1 3 5 7 9 10 
31 | 6
32 | 2 4 6 1 3 5 7 8 
33 | 4
34 | 2 4 1 3 5 6 
35 | 2
36 | 2 1 3 4 
37 | 0
38 | 1 2 
39 | 
40 | 
41 | 
42 | 
43 | 
44 | #include <cmath>
45 | #include <cstdio>
46 | #include <vector>
47 | #include <iostream>
48 | #include <algorithm>
49 | using namespace std;
50 | void swap(int *a, int *b){ 
51 |     int temp = *a; 
52 |     *a = *b; 
53 |     *b = temp; 
54 | } 
55 | int partition (int a[], int l, int r) 
56 | { 
57 |     int x = a[r];
58 |     int i = (l - 1); 
59 |     for (int j = l; j <= r-1; j++) 
60 |     { 
61 |         if (a[j] <= x) 
62 |         { 
63 |             i++; 
64 |             swap (&a[i], &a[j]); 
65 |         } 
66 |     } 
67 |     swap (&a[i + 1],&a[r]); 
68 |     return (i + 1); 
69 | } 
70 | void Quicksort(int a[], int l, int r)
71 | {
72 |     int i,p;
73 |     if (l < r)
74 |     {
75 |         p = partition(a, l, r);
76 |         cout<<p<<endl;
77 |         for(i=l;i<=r;i++)
78 |         {
79 |             cout<<a[i]<<" ";
80 |         }
81 |         cout<<endl;
82 |         Quicksort(a, l, p - 1);
83 |         Quicksort(a, p + 1, r);
84 |         }
85 | }
86 | int main() {
87 |     int n;
88 |     cin>>n;
89 |     int a[n],i;
90 |     for(i=0;i<n;i++)
91 |         cin>>a[i];
92 |       Quicksort(a,0,n-1);
93 |    
94 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
95 |     return 0;
96 | }
97 | 


--------------------------------------------------------------------------------
/TurningBinaryMatrix.CPP:
--------------------------------------------------------------------------------
 1 | Consider a binary matrix A of size N X N.
 2 | Now, consider the following matrices : 
 3 | A90 - obtained by rotating A clockwise by 90 degrees.
 4 | A180 - obtained by rotating A clockwise by 180 degrees.
 5 | A270 - obtained by rotating A clockwise by 270 degrees.
 6 | 
 7 | Note : Binary matrix implies that every element will be either 0 or 1.
 8 | 
 9 | Your task is to construct another binary matrix B of size N X N such that :
10 | B(i,j) = 1 iff either A(i,j) = 1 OR A90(i,j) = 1 OR A180(i,j) = 1 OR A270(i,j) = 1
11 | B(i,j) = 0 otherwise
12 | 
13 | 
14 | INPUT
15 | 
16 | First line contains the size of the matrix N (1 ≤ N ≤ 100)
17 | Next N lines contain N integers each (Only 0 or 1) denoting the matrix A
18 | 
19 | 
20 | OUTPUT
21 | 
22 | Print N X N integers, denoting the matrix B.
23 | 
24 | Sample Input 0
25 | 
26 | 4
27 | 0 0 0 0
28 | 0 0 0 0
29 | 0 0 1 0
30 | 1 0 0 0
31 | Sample Output 0
32 | 
33 | 1 0 0 1
34 | 0 1 1 0
35 | 0 1 1 0
36 | 1 0 0 1
37 | 
38 | 
39 | 
40 | #include <cmath>
41 | #include <cstdio>
42 | #include <vector>
43 | #include <iostream>
44 | #include <algorithm>
45 | using namespace std;
46 | int arr[2];
47 | void rotate(int i,int j, int n, int angle){
48 |     if(angle==0){
49 |         arr[0]=i;
50 |         arr[1]=j;
51 |     }
52 |     else{
53 |         arr[0]=n-j-1;
54 |         arr[1]=i;
55 |         rotate(arr[0],arr[1],n,angle-90);
56 |     }
57 | }
58 | int main() {
59 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
60 |     int n,i,j;
61 |     cin>>n;
62 |     int mat[n][n];
63 |     for(i=0;i<n;i++){
64 |         for(j=0;j<n;j++){
65 |             cin>>mat[i][j];
66 |         }
67 |     }
68 |     int barr[n][n];
69 |     for(i=0;i<n;i++){
70 |         for(j=0;j<n;j++){
71 |             int ax,ay,bx,by,cx,cy;
72 |             rotate(i,j,n,90);
73 |             ax=arr[0];
74 |             ay=arr[1];
75 |             rotate(i,j,n,180);
76 |             bx=arr[0];
77 |             by=arr[1];
78 |             rotate(i,j,n,270);
79 |             cx=arr[0];
80 |             cy=arr[1];
81 |             //cout<<ax<<" "<<ay<<" "<<bx<<" "<<by<<" "<<cx<<" "<<cy<<endl;
82 |             if(mat[i][j]==1||mat[ax][ay]==1||mat[bx][by]==1||mat[cx][cy]==1){
83 |                 barr[i][j]=1;
84 |             }
85 |             else{
86 |                 barr[i][j]=0;
87 |             }
88 |         }
89 |         
90 |     }
91 |     for(i=0;i<n;i++){
92 |         for(j=0;j<n;j++){
93 |             cout<<barr[i][j]<<" ";
94 |         }
95 |         cout<<endl;
96 |     }
97 |     return 0;
98 | }
99 | 


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