├── 3rd largest element
├── Adding two array
├── After Element of Minimum Index
├── Array Sort 2
├── COIN SIMPLE
├── Count Distinct Elements
├── Counting Even elements
├── Delete An Element 1
├── Dutch national flag problem
├── Extra Element
├── Farmer Goat
├── Find Count
├── Find Sick Cow
├── Find minimum element 1
├── Find next minimum element.
├── Find out the pairs of Bullocks
├── Find square numbers 1
├── Greater than previous Elements
├── Half reverse
├── Half reverse and add
├── Highest Hill
├── John's pair
├── Least non prime number
├── Maximum Elements of Kth element
├── Maximum division of minimum
├── Merge Two Array
├── Merge Two Arrays 6
├── Minimum at sliding Widow
├── Monica's Problem
├── Number of Occurrences 1
├── Number of occurrences 1
├── Occurrence of elements
├── Odd occurrences
├── Print After Rotate
├── Print Array
├── Print Given Range
├── Print after Finding the element
├── Print as given
├── Print without Duplication
├── Remove Duplicate Elements 2
├── Replace Elements 1
├── Reverse Array
├── Reverse Entire Array
├── Reverse first and second half
├── Rotate an array 2
├── Rotate and print elements
├── Search and Print
├── Smaller then previous elements
├── Sort Array 8 frequent method
├── Sort and Sum alternatively
├── Sort array alternately
├── Sorting array elements by frequency
├── Sorting in max and min order
├── Square Numbers 1
├── Sum of Two numbers 46
├── Sum of all elements 1
├── Swap array elements
├── Union of Two Array
├── first half in ascending order and second half in descending order
├── merge two array and sort
├── minimum of all the greater numbers
├── missing Number
└── without n how to take array elements


/3rd largest element:
--------------------------------------------------------------------------------
 1 | Need to write a program to print the 3rd largest element.
 2 | 
 3 | Input Format
 4 | 
 5 | 7
 6 | 7 23 45 2 9 56 8
 7 | 
 8 | Constraints
 9 | 
10 | 1<=n<=20
11 | 
12 | Output Format
13 | 
14 | 23
15 | 
16 | Sample Input 0
17 | 
18 | 6
19 | 2 9 8 7 6 1
20 | Sample Output 0
21 | 
22 | 7
23 | ----------------------------------------------------------------------------------------------------------------------------------
24 | 
25 | #include <stdio.h>
26 | #include <string.h>
27 | #include <math.h>
28 | #include <stdlib.h>
29 | 
30 | int main() {
31 |     int n,i,j,temp;
32 |     scanf("%d",&n);
33 |     int a[n];
34 |     for(i=0;i<n;i++)//input
35 |         scanf("%d",&a[i]);
36 |     
37 |     for(i=0;i<n-1;i++)//sort
38 |     { 
39 |         for(j=i+1;j<n;j++)
40 |         { 
41 |             if(a[i]>a[j])
42 |             {
43 |                 temp=a[i];
44 |                 a[i]=a[j];
45 |                 a[j]=temp;
46 |             }
47 |         }
48 |     }
49 |     
50 |     printf("%d",a[n-3]);
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Adding two array:
--------------------------------------------------------------------------------
  1 | Given 2 huge numbers as separate digits, store them in array and process them and
  2 | calculate the sum of 2 numbers and store the result in an array and print the sum.
  3 | 
  4 | Input Format
  5 | 
  6 | 12
  7 | 9
  8 | 9 2 8 1 3 5 6 7 3 1 1 6
  9 | 7 8 4 6 2 1 9 9 7
 10 | 
 11 | Constraints
 12 | 
 13 | 4<=n<=15
 14 | 
 15 | Output Format
 16 | 
 17 | 9 2 8 9 2 0 2 9 5 1 1 3
 18 | 
 19 | Sample Input 0
 20 | 
 21 | 6
 22 | 5
 23 | 3 4 2 6 5 7
 24 | 1 2 3 4 5
 25 | Sample Output 0
 26 | 
 27 | 3 5 5 0 0 2
 28 | 
 29 | ----------------------------------------------------------------------------------------------------------------
 30 | #include <cmath>
 31 | #include <cstdio>
 32 | #include <vector>
 33 | #include <iostream>
 34 | #include <algorithm>
 35 | using namespace std;
 36 | 
 37 | void rev(int a[],int n)
 38 | {
 39 |     int l=0,r=n-1;
 40 |     while(l<r)
 41 |     {
 42 |         int t=a[l];
 43 |         a[l]=a[r];
 44 |         a[r]=t;
 45 |         l++,r--;
 46 |     }
 47 | }
 48 | 
 49 | 
 50 | 
 51 | int add(int a[],int b[],int ans[] ,int n1,int n2)
 52 | {
 53 |     int carry=0;
 54 |     int size=n1<n2?n2:n1;
 55 |    
 56 |     for(int i=0;i<size;i++)
 57 |     {
 58 |         int t1= i<n1 ? a[i]:0;
 59 |         int t2= i<n2 ? b[i]:0;
 60 |         int t3=t1+t2+carry;
 61 |         
 62 |         carry=t3/10;
 63 |         ans[i]=t3%10;
 64 |     }
 65 |     if(carry>0)
 66 |         ans[size]=carry;
 67 |     return carry;
 68 | }
 69 | 
 70 | 
 71 | int main() {
 72 |     int n1,n2,i;
 73 |     cin>>n1>>n2;
 74 |     int a[n1],b[n2];
 75 |     for(i=0;i<n1;i++)
 76 |         cin>>a[i];
 77 |     for(i=0;i<n2;i++)
 78 |         cin>>b[i];
 79 |     
 80 |     rev(a,n1);
 81 |     rev(b,n2);
 82 |     
 83 |     
 84 |     int size=n1<n2?n2:n1;
 85 |       int ans[size];
 86 |     int carry=add(a,b,ans,n1,n2);
 87 |     
 88 |    
 89 |     
 90 |     if(carry>0)
 91 |         size++;
 92 |     
 93 |     rev(ans,size);
 94 |     
 95 |     for(i=0;i<size;i++)
 96 |         cout<<ans[i]<<" ";
 97 |     
 98 |     return 0;
 99 | }
100 | =============================================================================================
101 | public class Main {
102 |     public static void main(String[] args) {
103 |       Scanner z = new Scanner(System.in);
104 |         int n=z.nextInt();
105 |       int a[]=new int[n];
106 |       for(int i=0;i<n;i++)
107 |         a[i]=z.nextInt();
108 |       
109 |       int m=z.nextInt();
110 |       int b[]=new int[m];
111 |       for(int i=0;i<m;i++)
112 |         b[i]=z.nextInt();
113 |       int i=n-1,j=m-1;
114 |       String s="";
115 |       int c=0;
116 |       while(i>=0&&j>=0)
117 |       {
118 |         int t=a[i]+b[j]+c;
119 |         s += t%10;
120 |         c=t/10;
121 |         i--;
122 |         j--;
123 |       }
124 |       while(i>=0)
125 |       {
126 |         int t=a[i]+c;
127 |         s += t%10;
128 |         c=t/10;
129 |         i--;
130 |       }
131 |       while(j>=0)
132 |       {
133 |         int t=a[j]+c;
134 |         s += t%10;
135 |         c=t/10;
136 |         j--;
137 |       }
138 |       if(c>0)
139 |         s+=c;
140 |       System.out.println(s);
141 |       
142 |       int ans[]=new int[s.length()];
143 |       for(i=0;i<s.length();i++)
144 |       {
145 |         ans[s.length()-1-i] = (int)(s.charAt(i)-'0');
146 |       }
147 |       for(i=0;i<s.length();i++)
148 |         System.out.print(ans[i]);
149 |     }
150 | }
151 | 


--------------------------------------------------------------------------------
/After Element of Minimum Index:
--------------------------------------------------------------------------------
 1 | Find the minimum element's index first from the given array.
 2 | Then print the next index's element from the array.
 3 | 
 4 | Input Format
 5 | 
 6 | 6
 7 | 5 6 3 7 2 8
 8 | 
 9 | Constraints
10 | 
11 | 4<=n<=12
12 | 1<=E<=9
13 | 
14 | Output Format
15 | 
16 | 8
17 | 
18 | Sample Input 0
19 | 
20 | 7
21 | 1 2 3 4 5 6 7
22 | Sample Output 0
23 | 
24 | 2
25 | 
26 | -----------------------------------------------------------------------------------------------------------------
27 | #include <stdio.h>
28 | #include <string.h>
29 | #include <math.h>
30 | #include <stdlib.h>
31 | #include <limits.h>
32 | 
33 | int fun(int a[],int n)
34 | {
35 |     int min=INT_MAX;
36 |     int ind=0;
37 |     for(int i=0;i<n;i++)
38 |     {
39 |         if(a[i]<min)
40 |         {
41 |             min=a[i];
42 |             ind=i;
43 |         }
44 |     }
45 |     return ind;
46 | }
47 | int main() {
48 |     int n;
49 |     scanf("%d",&n);
50 |     int a[n];
51 |     for(int i=0;i<n;i++)
52 |         scanf("%d",&a[i]);
53 |     int ind=fun(a,n);
54 |         printf("%d",a[ind+1]);
55 |     
56 |     return 0;
57 | }
58 | 


--------------------------------------------------------------------------------
/Array Sort 2:
--------------------------------------------------------------------------------
 1 | Need to write a program to sort the given array
 2 | 
 3 | Input Format
 4 | 
 5 | 7
 6 | 5 8 3 1 4 9 6
 7 | 
 8 | Constraints
 9 | 
10 | 1<=n<=20
11 | 
12 | Output Format
13 | 
14 | 1 3 4 5 6 8 9
15 | 
16 | Sample Input 0
17 | 
18 | 6
19 | 5 4 3 8 7 1
20 | Sample Output 0
21 | 
22 | 1 3 4 5 7 8
23 | ---------------------------------------------------------------------------------------------------------
24 | #include<stdio.h>
25 | int main() {
26 |     int n,i,j;
27 |     scanf("%d",&n);
28 |     int a[n];
29 |     for(i=0;i<n;i++)
30 |         scanf("%d",&a[i]);
31 |     for(i=0;i<n-1;i++)
32 |     {
33 |         for(j=i+1;j<n;j++)
34 |         {
35 |             if(a[i]>a[j])
36 |             {
37 |             int temp=a[i];
38 |             a[i]=a[j];
39 |             a[j]=temp;
40 |             }
41 |         }
42 |     }
43 |     for(i=0;i<n;i++)
44 |         printf("%d ",a[i]);
45 |     }
46 | 


--------------------------------------------------------------------------------
/COIN SIMPLE:
--------------------------------------------------------------------------------
 1 | Given an amount, find the minimum number of notes of different denominations that sum up to the given amount. Starting from the highest denomination note, try to accommodate as many notes as possible for a given amount.
 2 | We may assume that we have infinite supply of notes of values
 3 | {2000, 500, 200, 100, 50, 20, 10, 5, 1}
 4 | 
 5 | Input Format
 6 | 
 7 | 800
 8 | 
 9 | Output Format
10 | 
11 | 500 : 1
12 | 200 : 1
13 | 100 : 1
14 | 
15 | Sample Input 0
16 | 
17 | 2350
18 | Sample Output 0
19 | 
20 | 2000 : 1
21 | 200 : 1
22 | 100 : 1
23 | 50 : 1
24 | ==========================================================
25 | import java.io.*;
26 | import java.util.*;
27 | import java.text.*;
28 | import java.math.*;
29 | import java.util.regex.*;
30 | 
31 | public class Solution {
32 | 
33 |     public static void main(String[] args) {
34 |         Scanner z= new Scanner(System.in);
35 |         int a[]=new int[9];
36 |         a[0]=1;
37 |         a[1]=5;
38 |         a[2]=10;
39 |         a[3]=20;
40 |         a[4]=50;
41 |         a[5]=100;
42 |         a[6]=200;
43 |         a[7]=500;
44 |         a[8]=2000;
45 |         int pos = 8;
46 |         int c = 0;
47 |         int n = z.nextInt();
48 |         while(n!=0)
49 |         {
50 |             if(a[pos]<=n)
51 |             {
52 |                 n=n-a[pos];
53 |                 c++;
54 |             }
55 |             else
56 |             {
57 |                 if(c!=0)
58 |                     System.out.println(a[pos]+" : "+c);
59 |                 c=0;
60 |                 pos--;
61 |             }
62 |         }
63 |         if(c!=0)
64 |             System.out.println(a[pos]+" : "+c);
65 |     }
66 | }
67 | 


--------------------------------------------------------------------------------
/Count Distinct Elements:
--------------------------------------------------------------------------------
 1 | Need to write a program to count the no. of distinct elements
 2 | 
 3 | Input Format
 4 | 
 5 | 12
 6 | 1 2 3 4 7 2 3 7 9 8 10 6
 7 | 
 8 | Constraints
 9 | 
10 | 6<=n<=20
11 | 
12 | Output Format
13 | 
14 | 6
15 | 
16 | Sample Input 0
17 | 
18 | 6
19 | 1 2 3 4 2 3
20 | Sample Output 0
21 | 
22 | 2
23 | Explanation 0
24 | 
25 | 2 presents 2 times, 3 present 2 times. Here 1 and 4 alone distinct elements. So the count is 2
26 | =======================================================================================================================
27 | #include<stdio.h>
28 | int main(){
29 |   int n,i,j,c=0,fc=0;
30 |  scanf("%d",&n);
31 |  int a[n];
32 |  for(i=0;i<n;i++)
33 |    scanf("%d",&a[i]);
34 |     
35 |     for(i=0;i<n;i++)
36 |     { c=0;
37 |      for(j=0;j<n;j++)
38 |      {
39 |          if(a[i]==a[j])
40 |             c++;
41 |      }  
42 |      if(c==1)
43 |         fc++;
44 |  }    
45 |     printf("%d",fc);
46 | }  
47 | 


--------------------------------------------------------------------------------
/Counting Even elements:
--------------------------------------------------------------------------------
 1 | Need to write a program to count the number of even elements.
 2 | 
 3 | Input Format
 4 | 
 5 | 7
 6 | 9 8 7 6 9 5 2
 7 | 
 8 | Constraints
 9 | 
10 | 5<=n<=20
11 | 
12 | Output Format
13 | 
14 | 3
15 | 
16 | Sample Input 0
17 | 
18 | 7
19 | 1 2 3 4 5 6 8
20 | Sample Output 0
21 | 
22 | 4
23 | ============================================================================
24 | #include <stdio.h>
25 | #include <string.h>
26 | #include <math.h>
27 | #include <stdlib.h>
28 | 
29 | int main() {
30 | int n,e=0;
31 |     scanf("%d",&n);
32 |     int a[n];
33 |     for(int i=0;i<n;i++)
34 |     {
35 |         scanf("%d",&a[i]);
36 |         if(a[i]%2==0)
37 |             e++;
38 |     }
39 |     printf("%d",e);     
40 |     return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/Delete An Element 1:
--------------------------------------------------------------------------------
 1 | Write a program to delete an element from the given array.
 2 | 
 3 | Input Format
 4 | 
 5 | 6
 6 | 5 6 3 9 8 7
 7 | 9
 8 | 
 9 | Constraints
10 | 
11 | Input should be an array
12 | 
13 | Output Format
14 | 
15 | 5 6 3 8 7
16 | 
17 | Sample Input 0
18 | 
19 | 8
20 | 5 6 7 1 3 2 9 8
21 | 9
22 | Sample Output 0
23 | 
24 | 5 6 7 1 3 2 8
25 | ==========================================
26 | int main() {
27 |     int n,key;
28 |     scanf("%d",&n);
29 |     int a[n];
30 |     for(int i=0;i<n;i++)
31 |         scanf("%d",&a[i]);
32 |     
33 |     scanf("%d",&key);
34 |     
35 |     for(int i=0;i<n;i++)
36 |     {
37 |         if(key==a[i])
38 |         {
39 |             for(int j=i;j<n-1;j++)
40 |             {
41 |                 a[j]=a[j+1];
42 |             }
43 |             n--;
44 |             break;
45 |         }
46 |     }
47 |     for(int i=0;i<n;i++)
48 |         printf("%d ",a[i]);
49 |        
50 | return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/Dutch national flag problem:
--------------------------------------------------------------------------------
 1 | 
 2 | import java.io.*;
 3 | 
 4 | class PM {
 5 | 
 6 | 	static void fun(String a[], int n)
 7 | 	{
 8 | 		int lo = 0;
 9 | 		int hi = n - 1;
10 | 		int mid = 0;
11 |         String temp = "";
12 | 	
13 | 		while (mid <= hi) {
14 | 			switch (a[mid]) {
15 | 				
16 | 			case "R" : {
17 | 				temp = a[lo];
18 | 				a[lo] = a[mid];
19 | 				a[mid] = temp;
20 | 				lo++;
21 | 				mid++;
22 | 				break;
23 | 			}
24 | 	
25 | 			case "W":
26 | 				mid++;
27 | 				break;
28 | 				
29 | 			case "B": {
30 | 				temp = a[mid];
31 | 				a[mid] = a[hi];
32 | 				a[hi] = temp;
33 | 				hi--;
34 | 				break;
35 | 			}
36 | 			}
37 | 		}
38 | 	}
39 | 
40 | 	static void print(String a[], int n)
41 | 	{
42 | 		for (int i = 0; i < n; i++)
43 | 			System.out.print(a[i] + " ");
44 | 	}
45 | 
46 | 	public static void main(String[] args)
47 | 	{
48 |         Scanner z=new Scanner(System.in);
49 |         String[] s=z.nextLine().split(" ");
50 |         int n=s.length;
51 |        // System.out.print(s);
52 | 		fun(s,n);
53 | 		print(s,n);
54 | 	}
55 | }
56 | 


--------------------------------------------------------------------------------
/Extra Element:
--------------------------------------------------------------------------------
 1 | Find the extra element and its index
 2 |  
 3 | Input Format
 4 | 
 5 | 5
 6 | 4
 7 | 10 20 30 12 5
 8 | 10 5 30 20
 9 | 
10 | Constraints
11 | 
12 | 3<=n<=10
13 | 
14 | Output Format
15 | 
16 | 12
17 | 3
18 | 
19 | Sample Input 0
20 | 
21 | 4
22 | 5
23 | -1 0 3 2
24 | 3 4 0 -1 2
25 | Sample Output 0
26 | 
27 | 4
28 | 1
29 | ============================================================================================================================
30 | #include <stdio.h>
31 | #include <string.h>
32 | #include <math.h>
33 | #include <stdlib.h>
34 | 
35 | void fun(int a[],int b[],int n,int m,int key)
36 | {
37 |     int i=0,f=0,j=0,ind=-1;
38 |    while(i<n||j<m)
39 |    {
40 |        if(a[i++]==key||b[j++]==key)
41 |        {
42 |            f++;
43 |            ind=i-1;
44 |        }
45 |            
46 |    }
47 |     if(f==1)
48 |         printf("%d\n%d",key,ind);
49 | }
50 | int main() {
51 |     int n,m,i;
52 |     scanf("%d%d",&n,&m);
53 |     int a[n];
54 |     int b[m];
55 |     for(i=0;i<n;i++)
56 |         scanf("%d",&a[i]);
57 |     for(i=0;i<m;i++)
58 |         scanf("%d",&b[i]);
59 |     
60 |     for(i=0;i<n;i++)
61 |     {
62 |         fun(a,b,n,m,a[i]);
63 |     }
64 |                
65 |     for(i=0;i<m;i++)
66 |     {
67 |         fun(a,b,n,m,b[i]);
68 |     }             
69 |     return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/Farmer Goat:
--------------------------------------------------------------------------------
 1 | Raja is a Farmer, Since he is in need of some amount, he wants to sell a goat which is the smallest height among the group of his goats.
 2 | 
 3 | Input Format
 4 | 
 5 | His goat heights are given:
 6 | 5 6 3 2 9 8
 7 | 
 8 | Constraints
 9 | 
10 | Goats heights should not be more than 10 units
11 | 
12 | Output Format
13 | 
14 | 2
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | 8 3 4 2 7
20 | Sample Output 0
21 | 
22 | 2
23 | ========================================================================
24 | #include <stdio.h>
25 | #include <string.h>
26 | #include <math.h>
27 | #include <stdlib.h>
28 | #include <limits.h>
29 | int main() {
30 |   int n,i,ans=INT_MAX;
31 |     scanf("%d",&n);
32 |     int a[n];
33 |     for(i=0;i<n;i++)
34 |     {
35 |         scanf("%d",&a[i]);
36 |     }
37 |     
38 |     for(i=0;i<n;i++)
39 |     {
40 |         if(ans>a[i])
41 |             ans=a[i];
42 |     }
43 |     printf("%d",ans);
44 | }
45 |  
46 | 


--------------------------------------------------------------------------------
/Find Count:
--------------------------------------------------------------------------------
 1 | Given an array and a threshold value find the output.
 2 | 
 3 | Input Format
 4 | 
 5 | 6
 6 | 5 8 10 13 6 2
 7 | 3
 8 | 
 9 | Explanation:
10 | Number parts counts
11 | 5 {3,2} 3
12 | 8 {3,3,2} 4
13 | 10 {3,3,3,1} 4
14 | 13 {3,3,3,3,1} 5
15 | 6 {3,3} 2
16 | 2 {2} 2
17 | 
18 | Constraints
19 | 
20 | 4<=n<=10
21 | 
22 | Output Format
23 | 
24 | 20
25 | 
26 | Sample Input 0
27 | 
28 | 5
29 | 6 5 8 3 9
30 | 2
31 | Sample Output 0
32 | 
33 | 17
34 | ------------------------------------------------------------------------------------------------------------------
35 | #include <cmath>
36 | #include <cstdio>
37 | #include <vector>
38 | #include <iostream>
39 | #include <algorithm>
40 | using namespace std;
41 | 
42 | int main() {
43 |     
44 |     int n,key,sum=0,i;
45 |     scanf("%d",&n);
46 |     int a[n];
47 |     for(i=0;i<n;i++)
48 |         scanf("%d",&a[i]);
49 |     
50 |     scanf("%d",&key);
51 |     
52 |     for(i=0;i<n;i++)
53 |     {
54 |        sum+=a[i]/key;
55 |         sum+=a[i]%key;
56 |     }
57 |     printf("%d",sum);
58 |     return 0;
59 | }
60 | 


--------------------------------------------------------------------------------
/Find Sick Cow:
--------------------------------------------------------------------------------
 1 | Raja is farmer, he has to find the sick cow among the group of cows to treat it. Each cow will have its own identification number which will be in between 1 and 9. Search the cow based on the given identification number, Need to find out the tied position.
 2 | 
 3 | Input Format
 4 | 
 5 | Raja's cows:
 6 | 7
 7 | 4 6 2 7 9 5 3
 8 | 9
 9 | 
10 | Constraints
11 | 
12 | Cow's identification number should not be more than 10
13 | 
14 | Output Format
15 | 
16 | 4
17 | 
18 | Sample Input 0
19 | 
20 | 5
21 | 7 6 5 4 3
22 | 5
23 | Sample Output 0
24 | 
25 | 2
26 | =======================================================================================
27 | #include <stdio.h>
28 | #include <string.h>
29 | #include <math.h>
30 | #include <stdlib.h>
31 | 
32 | int main() {
33 | 
34 |     int n,i,key;
35 |     scanf("%d",&n);
36 |     int a[n];
37 |     for(i=0;i<n;i++)
38 |         scanf("%d",&a[i]);
39 |     scanf("%d",&key);
40 |     for(i=0;i<n;i++){
41 |         if(a[i]==key){
42 |             printf("%d",i);
43 |             break;
44 |         }
45 |     }
46 | }
47 |     
48 | 


--------------------------------------------------------------------------------
/Find minimum element 1:
--------------------------------------------------------------------------------
 1 | Need to write a program to find out the least element.
 2 | 
 3 | Input Format
 4 | 
 5 | 6
 6 | 6 9 3 4 2 7
 7 | 
 8 | Constraints
 9 | 
10 | 1<=n<=20
11 | 
12 | Output Format
13 | 
14 | 2
15 | 
16 | Sample Input 0
17 | 
18 | 7
19 | 3 9 7 6 1 5 2
20 | Sample Output 0
21 | 
22 | 1
23 | ---------------------------------------------------------------------------
24 | #include <stdio.h>
25 | #include <string.h>
26 | #include <math.h>
27 | #include <stdlib.h>
28 | #include <limits.h>
29 | int main() {
30 |   int n,i,ans=INT_MAX;
31 |     scanf("%d",&n);
32 |     int a[n];
33 |     for(i=0;i<n;i++)
34 |     {
35 |         scanf("%d",&a[i]);
36 |     }
37 |     
38 |     for(i=0;i<n;i++)
39 |     {
40 |         if(ans>a[i])
41 |             ans=a[i];
42 |     }
43 |     printf("%d",ans);
44 | }
45 |  
46 | 


--------------------------------------------------------------------------------
/Find next minimum element.:
--------------------------------------------------------------------------------
 1 | Given an array, find the next maximum element for each element in the array.
 2 | 
 3 | Input Format
 4 | 
 5 | 7
 6 | 2 3 7 1 8 5 11
 7 | 
 8 | Constraints
 9 | 
10 | 3<=n<=10
11 | 
12 | Output Format
13 | 
14 | 2>1,3>2,7>5,1>,8>7,5>3,11>8,
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | 3 2 6 7 1
20 | Sample Output 0
21 | 
22 | 3>2,2>1,6>3,7>6,1>,
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 |     int n,i;
35 |     cin>>n;
36 |     int a[n],b[n];
37 |     for(i=0;i<n;i++)
38 |     {
39 |         cin>>a[i];
40 |         b[i]=a[i];
41 |     }
42 |     sort(b, b + n);
43 |     for(i=0;i<n;i++)
44 |     {
45 |         
46 |         for(int j=0;j<n;j++)
47 |         {
48 |             if(a[i]==b[j])
49 |             {
50 |                 if(a[i]==1)
51 |                     cout<<a[i]<<">,";
52 |                 else
53 |                 cout<<a[i]<<">"<<b[j-1]<<",";
54 |             }
55 |         }
56 |     }
57 |     
58 |    
59 |     
60 |     return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/Find out the pairs of Bullocks:
--------------------------------------------------------------------------------
 1 | A farmer Praveen has Bullocks in shelter-1 and shelter-2.
 2 | He has some debt needs to pay to bank, so he plans to sell his bullock.
 3 | He sells pairs not as a single Bullock, so that he get more money than selling as a single bullock.
 4 | 
 5 | Input Format
 6 | 
 7 | Bullocks in shelter-1 and shelter-2.
 8 | Shelter-1: 2 4 1 3 6 5 8 7
 9 | Shelter-2: 4 1 6 4 1 5 6 1 4
10 | 
11 | Constraints
12 | 
13 | 1<=H<=20
14 | Here H is the unit height of the bullocks
15 | 
16 | Output Format
17 | 
18 | 1 - 2
19 | 4 - 2
20 | 5 - 1
21 | 6 - 1
22 | 
23 | In 4 unit height, he has 2 pairs
24 | In 1 unit height, he has 1 pairs and so on..
25 | The result should be in ascending order of height.
26 | 
27 | Sample Input 0
28 | 
29 | 5
30 | 1 4 3 2 5
31 | 7
32 | 3 4 2 6 8 1 9
33 | Sample Output 0
34 | 
35 | 1 - 1
36 | 2 - 1
37 | 3 - 1
38 | 4 - 1
39 | ===============================================================================================================
40 | import java.io.*;
41 | import java.util.*;
42 | 
43 | public class Solution {
44 |     static int max(int a[],int n)
45 |     {
46 |         int m=Integer.MIN_VALUE;
47 |         for(int i=0;i<n;i++)
48 |             if(a[i]>m)
49 |                 m=a[i];
50 |         return m;
51 |     }
52 | 
53 |     public static void main(String[] args) {
54 |         
55 |         Scanner z = new Scanner(System.in);
56 |         int n = z.nextInt();
57 |         int a[] = new int[n];
58 |         for(int i=0;i<n;i++)
59 |             a[i] = z.nextInt();
60 |         int m = z.nextInt();
61 |         int b[] = new int[m];
62 |         for(int i=0;i<m;i++)
63 |             b[i] = z.nextInt();
64 |         int mx1 = max(a,n);
65 |         int mx2 = max(b,m);
66 |         int mx = Math.max(mx1,mx2);
67 |         int f[]=new int[mx+1];
68 |         for(int i=0;i<n;i++)
69 |             f[a[i]]++;
70 |         for(int i=0;i<m;i++)
71 |             f[b[i]]++;
72 |         for(int i=0;i<mx+1;i++)
73 |         {
74 |             if(f[i]>1)
75 |             {
76 |                System.out.println(i+" - "+f[i]/2);
77 |             }
78 |         }
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/Find square numbers 1:
--------------------------------------------------------------------------------
 1 | Given two numbers a and b both < 200 we have to find the square numbers which lie
 2 | between a and b(inclusive)
 3 | 
 4 | Input Format
 5 | 
 6 | a = 25
 7 | b = 100
 8 | 
 9 | Constraints
10 | 
11 | a and b should be <200
12 | 
13 | Output Format
14 | 
15 | 25 36 49 64 81 100
16 | 
17 | Sample Input 0
18 | 
19 | 100
20 | 200
21 | Sample Output 0
22 | 
23 | 100 121 144 169 196
24 | -----------------------------------------------------------------------------------------------------------
25 | #include <stdio.h>
26 | #include <string.h>
27 | #include <math.h>
28 | #include <stdlib.h>
29 |     void square(int a, int b) {
30 |     int n = sqrt(a);
31 |     while(n*n <= b) {
32 |         printf("%d ", n*n);
33 |         n++;
34 |     }
35 | }
36 | 
37 | int main() {
38 |     int a, b;
39 |     scanf("%d%d", &a,&b);
40 |     square(a, b);
41 |     
42 | }
43 | 


--------------------------------------------------------------------------------
/Greater than previous Elements:
--------------------------------------------------------------------------------
 1 | You’re given an array. Print the elements of the array which are greater than its
 2 | previous elements in the array.
 3 | 
 4 | Input Format
 5 | 
 6 | 7
 7 | 2 -3 -4 5 9 7 8
 8 | 
 9 | Constraints
10 | 
11 | 4<=n<=10
12 | 
13 | Output Format
14 | 
15 | 2 5 9
16 | 
17 | Sample Input 0
18 | 
19 | 6
20 | 1 3 4 -5 2 6
21 | Sample Output 0
22 | 
23 | 1 3 4 6
24 | -------------------------------------------------------------------------------------------------------------------------------------------
25 | #include <stdio.h>
26 | #include <string.h>
27 | #include <math.h>
28 | #include <stdlib.h>
29 | #include <limits.h>
30 | int main() {
31 |     int n,i,max=INT_MIN;
32 |     scanf("%d",&n);
33 |     int a[n];
34 |     for(i=0;i<n;i++)
35 |         scanf("%d",&a[i]);
36 |     for(i=0;i<n;i++)
37 |     {
38 |         if(max<a[i])
39 |         {
40 |             max=a[i];
41 |             printf("%d ",max);
42 |         }
43 |         
44 |     }
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/Half reverse:
--------------------------------------------------------------------------------
 1 | Need to write a program to reverse half of the given array
 2 | 
 3 | Input Format
 4 | 
 5 | 5
 6 | 4 5 3 8 1
 7 | 
 8 | Constraints
 9 | 
10 | 1<=n<=20
11 | 
12 | Output Format
13 | 
14 | 4 5 1 8 3
15 | 
16 | Sample Input 0
17 | 
18 | 6
19 | 4 3 2 1 6 7
20 | Sample Output 0
21 | 
22 | 4 3 2 7 6 1
23 | 
24 | ----------------------------------------------------------------------------------------------------------------------
25 | 
26 | 
27 | #include <stdio.h>
28 | #include <string.h>
29 | #include <math.h>
30 | #include <stdlib.h>
31 | 
32 | int main() {
33 |     int n,L,r,temp;
34 |     scanf("%d",&n);
35 |     int a[n];
36 |     for(int i=0;i<n;i++)
37 |         scanf("%d",&a[i]);
38 |     int half=n/2;
39 |     L=half;
40 |     r=n-1;
41 |     while(L<r)
42 |     {
43 |         temp=a[L];
44 |         a[L]=a[r];
45 |         a[r]=temp;
46 |         L++;
47 |         r--;
48 |     }
49 |     for(int i=0;i<n;i++)
50 |         printf("%d ",a[i]);
51 | }
52 | 


--------------------------------------------------------------------------------
/Half reverse and add:
--------------------------------------------------------------------------------
 1 | Need to write a program to reverse the half of the elements from an array and add the odd index's elements and print it.
 2 | 
 3 | Input Format
 4 | 
 5 | 7
 6 | 1 2 3 4 5 6 7
 7 | 
 8 | Constraints
 9 | 
10 | 1<=n<=10
11 | n is the number of elements
12 | 1<=H<=20
13 | H is the elements size.
14 | 
15 | Output Format
16 | 
17 | 1 2 3 4 7 6 5
18 | 12
19 | Here the second half is reveresed
20 | 
21 | Sample Input 0
22 | 
23 | 6
24 | 7 6 5 4 3 2
25 | Sample Output 0
26 | 
27 | 7 6 5 2 3 4
28 | 12
29 | -------------------------------------------------------------------------------------------------------
30 | #include <stdio.h>
31 | #include <string.h>
32 | #include <math.h>
33 | #include <stdlib.h>
34 | 
35 | int main() {
36 |     int n,L,r,temp,sum=0,i;
37 |     scanf("%d",&n);
38 |     int a[n];
39 |     for(i=0;i<n;i++)
40 |         scanf("%d",&a[i]);
41 |     int half=ceil(n/2);
42 |     L=half;
43 |     r=n-1;
44 |     while(L<r)
45 |     {
46 |         temp=a[L];
47 |         a[L]=a[r];
48 |         a[r]=temp;
49 |         L++;
50 |         r--;
51 |     }
52 |     for(i=0;i<n;i++)
53 |         printf("%d ",a[i]);
54 |     i=1;
55 |     while(i<n)
56 |     {
57 |        sum+=a[i];
58 |         i=i+2;
59 |     }
60 |      printf("\n%d ",sum);
61 | }
62 | 


--------------------------------------------------------------------------------
/Highest Hill:
--------------------------------------------------------------------------------
 1 | Need to write a program to findout the highest hill from the given height of the differnt hills.
 2 | 
 3 | Input Format
 4 | 
 5 | Hills hights are: 6 9 23 45 24 13
 6 | 
 7 | Constraints
 8 | 
 9 | Height should not be more than 100
10 | 
11 | Output Format
12 | 
13 | 45
14 | 
15 | Sample Input 0
16 | 
17 | 7
18 | 23 45 22 12 56 44 13
19 | Sample Output 0
20 | 
21 | 56
22 | ==================================================================
23 | #include <stdio.h>
24 | #include <string.h>
25 | #include <math.h>
26 | #include <stdlib.h>
27 | #include <limits.h>
28 | int main() {
29 |   int n,i,ans=INT_MIN;
30 |     scanf("%d",&n);
31 |     int a[n];
32 |     for(i=0;i<n;i++)
33 |     {
34 |         scanf("%d",&a[i]);
35 |     }
36 |     
37 |     for(i=0;i<n;i++)
38 |     {
39 |         if(ans<a[i])
40 |             ans=a[i];
41 |     }
42 |     printf("%d",ans);
43 | }
44 |  
45 | 


--------------------------------------------------------------------------------
/John's pair:
--------------------------------------------------------------------------------
 1 | John works at a clothing store. He has a large pile of socks that he must pair by color for sale.
 2 | Given an array of integers representing the color of each sock, determine how many pairs of socks with matching colors there are.
 3 | 
 4 | Input Format
 5 | 
 6 | The first line contains an integer the number of socks represented in The second line contains
 7 | space-separated integers describing the colors of the socks in the pile.
 8 | 
 9 | Constraints
10 | 
11 | Need to count the pairs
12 | 
13 | Output Format
14 | 
15 | Return the total number of matching pairs of socks that John can sell.
16 | 
17 | Sample Input 0
18 | 
19 | 9
20 | 10 20 20 10 10 30 50 10 20
21 | Sample Output 0
22 | 
23 | 3
24 | -------------------------------------------------------------------------------------------------------------------------------------------------------
25 | #include <stdio.h>
26 | #include <string.h>
27 | #include <math.h>
28 | #include <stdlib.h>
29 | 
30 | 
31 |     int sockMerchant(int n, int ar[]) {
32 |     int pairs = 0;
33 |     int colors[101] = {0};
34 |     for (int i = 0; i < n; i++) {
35 |         colors[ar[i]]++;
36 |     }
37 |     for (int i = 1; i <= 100; i++) {
38 |         pairs += colors[i] / 2;
39 |     }
40 |     return pairs;
41 | }
42 | 
43 | int main() {
44 |     int n;
45 |     scanf("%d", &n);
46 |     int ar[n];
47 |     for (int i = 0; i < n; i++) {
48 |         scanf("%d", &ar[i]);
49 |     }
50 |     int result = sockMerchant(n, ar);
51 |     printf("%d\n", result);
52 |     return 0;
53 | }
54 | 
55 | 


--------------------------------------------------------------------------------
/Least non prime number:
--------------------------------------------------------------------------------
  1 | Find the least non-prime number that can be added with first array element that makes
  2 | them divisible by second array elements at respective index (check for non-prime
  3 | numbers under 1000, if doesn't exist return -1 as answer) & (Consider 1 as prime
  4 | number)
  5 | 
  6 | Input Format
  7 | 
  8 | 2
  9 | 2
 10 | 20 16
 11 | 7 5
 12 | 
 13 | Constraints
 14 | 
 15 | 4<=n<=10
 16 | 
 17 | Output Format
 18 | 
 19 | 8
 20 | 4
 21 | 
 22 | Sample Input 0
 23 | 
 24 | 3
 25 | 3
 26 | 5 4 10
 27 | 3 4 7
 28 | Sample Output 0
 29 | 
 30 | 4
 31 | 4
 32 | 4
 33 | ----------------------------------------------------------------------------------------------------
 34 | #include <stdio.h>
 35 | #include <string.h>
 36 | #include <math.h>
 37 | #include <stdlib.h>
 38 | 
 39 |     int is_prime(int n) {
 40 | 
 41 |     if (n <= 1) {
 42 | 
 43 |         return 0;
 44 | 
 45 |     }
 46 | 
 47 |     for (int i = 2; i * i <= n; i++) {
 48 | 
 49 |         if (n % i == 0) {
 50 | 
 51 |             return 0;
 52 | 
 53 |         }
 54 | 
 55 |     }
 56 | 
 57 |     return 1;
 58 | 
 59 | }
 60 | 
 61 | int find_least_non_prime(int a, int b) {
 62 | 
 63 |     int i;
 64 | 
 65 |     for (i = 4; i < 1000; i++) {
 66 | 
 67 |         if (!is_prime(i) && (a + i) % b == 0) {
 68 | 
 69 |             return i;
 70 | 
 71 |         }
 72 | 
 73 |     }
 74 | 
 75 |     return -1;
 76 | 
 77 | }
 78 | int main () {
 79 | 
 80 |     int n1,n2;
 81 | 
 82 |     scanf("%d%d",&n1,&n2);
 83 | 
 84 |     int arr1[n1];
 85 | 
 86 |     for(int i=0;i<n1;i++){
 87 | 
 88 |         scanf("%d",&arr1[i]);
 89 | 
 90 |     }
 91 | 
 92 |     int arr2[n2];
 93 | 
 94 |     for(int i=0;i<n2;i++){
 95 | 
 96 |         scanf("%d",&arr2[i]);
 97 | 
 98 |     }
 99 | 
100 |     int n = sizeof(arr1) / sizeof(arr1[0]);
101 | 
102 |     int res[n];
103 | 
104 |     for (int i = 0; i < n; i++) {
105 | 
106 |         int ans = find_least_non_prime(arr1[i], arr2[i]);
107 | 
108 |         res[i] = ans;
109 | 
110 |     }
111 | 
112 |     for (int i = 0; i < n; i++) {
113 | 
114 |         printf("%d\n", res[i]);
115 | 
116 |     }
117 |   
118 |     return 0;
119 | }
120 | 


--------------------------------------------------------------------------------
/Maximum Elements of Kth element:
--------------------------------------------------------------------------------
  1 | Maximum Elements of Kth element
  2 | 
  3 | 
  4 | Write a program to print the elements on the basis of highest of kth elements.
  5 | 
  6 | Input Format
  7 | 
  8 | 9
  9 | 3 2 5 6 3 4 5 1 9
 10 | 2
 11 | 
 12 | Constraints
 13 | 
 14 | 4<=n<=10
 15 | 
 16 | Output Format
 17 | 
 18 | 5 6 9 3 4 5 1 3 2
 19 | 
 20 | Explanation:
 21 | 3+2 = 5
 22 | 5+6 = 11
 23 | 3+4 = 7
 24 | 5+1 = 6
 25 | 9 = 9 This is the remaining element, this also includes
 26 | 
 27 | So the highest sum is 11, so the first 2 elements are 5 6 and second highest is 9 and
 28 | its corresponding elements are 8 1 and so on.
 29 | The k value can be anything, take into note.
 30 | 
 31 | Sample Input 0
 32 | 
 33 | 6
 34 | 1 2 3 4 5 6
 35 | 2
 36 | Sample Output 0
 37 | 
 38 | 5 6 3 4 1 2
 39 | ---------------------------------------------------------------------------------------------------------------------
 40 | #include <cmath>
 41 | #include <cstdio>
 42 | #include <vector>
 43 | #include <iostream>
 44 | #include <algorithm>
 45 | using namespace std;
 46 | 
 47 | int fun(int m,int a[],int size)
 48 | {
 49 |     int ind=0,i;
 50 |     for(i=0;i<size;i++)
 51 |     {
 52 |         if(a[i]>m)
 53 |         {
 54 |            m=a[i];
 55 |             ind=i;
 56 |         }
 57 |     }   
 58 |     a[ind]=-1;
 59 |     return ind;
 60 | }
 61 | 
 62 | int main() {
 63 |    int n,i=0,key,ans=0,j,t=0;
 64 |     cin>>n;
 65 |     int size=ceil(n/2.0);
 66 |     int a[n],b[size];
 67 |     for(i=0;i<n;i++)
 68 |         cin>>a[i];
 69 |     
 70 |     cin>>key;
 71 |     i=0;
 72 |     while(i<n)
 73 |     {
 74 |         j=0,ans=0;
 75 |         while(j<key&&(i+j)<n)
 76 |         {
 77 |             ans+=a[i+j];
 78 |             
 79 |             j++;
 80 |         } 
 81 |         b[t++]=ans;
 82 |         i=i+2;
 83 |     }
 84 |     
 85 |     for(i=0;i<size;i++)
 86 |     {
 87 |         ans=fun(-1,b,size);
 88 |         j=0;
 89 |         ans=ans*key;
 90 |         while(j<key&&ans<n)
 91 |         {
 92 |             cout<<a[ans++]<<" ";
 93 |             j++;
 94 |         }
 95 |        
 96 |     }
 97 |  
 98 |     return 0;
 99 | }
100 | 


--------------------------------------------------------------------------------
/Maximum division of minimum:
--------------------------------------------------------------------------------
 1 | Write a program to find maximum and minimum elements from the given array. Print the division of max with min value.
 2 | 
 3 | Input Format
 4 | 
 5 | 6
 6 | 3 2 4 5 7 6
 7 | 
 8 | Constraints
 9 | 
10 | All should be numbers
11 | 
12 | Output Format
13 | 
14 | 3
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | 8 7 3 2 9
20 | Sample Output 0
21 | 
22 | 4
23 | Explanation 0
24 | 
25 | Maximum Element: 9 Minimum Element: 2 Result = 9/2 = 4
26 | ===========================================================================
27 | #include <stdio.h>
28 | #include <string.h>
29 | #include <math.h>
30 | #include <stdlib.h>
31 | #include <limits.h>
32 | int max(int a[],int n)
33 | {
34 |     int max=INT_MIN;
35 |     for(int i=0;i<n;i++)
36 |         if(a[i]>max)
37 |             max=a[i];
38 |     return max;
39 | }
40 | int min(int a[],int n)
41 | {
42 |     int min=INT_MAX;
43 |     for(int i=0;i<n;i++)
44 |         if(a[i]<min)
45 |             min=a[i];
46 |     return min;
47 | }
48 | int main() {
49 |     int n;
50 |     scanf("%d",&n);
51 |     int a[n];
52 |     for(int i=0;i<n;i++)
53 |         scanf("%d",&a[i]);
54 |     
55 |     int maxx=max(a,n);
56 |     int minn=min(a,n);
57 |     printf("%d",maxx/minn);
58 |     return 0;
59 |     
60 | }
61 | 


--------------------------------------------------------------------------------
/Merge Two Array:
--------------------------------------------------------------------------------
 1 | Write a program to merge the two sorted arrays.
 2 | 
 3 | Input Format
 4 | 
 5 | 5
 6 | 1 2 3 6 9
 7 | 4
 8 | 2 4 5 10
 9 | 
10 | Constraints
11 | 
12 | 3<=n<=10
13 | Please dont use Hashing Method.
14 | 
15 | Output Format
16 | 
17 | 1 2 3 4 5 6 9 10
18 | 
19 | Sample Input 0
20 | 
21 | 4
22 | 1 3 5 7
23 | 6
24 | 2 4 6 8 9 12
25 | Sample Output 0
26 | 
27 | 1 2 3 4 5 6 7 8 9 12
28 | -------------------------------------------------------------------------------------------------------
29 | #include <stdio.h>
30 | #include <string.h>
31 | #include <math.h>
32 | #include <stdlib.h>
33 | 
34 | int main() {
35 | 
36 |     int n1,c=1,i,j;
37 |     scanf("%d",&n1);
38 |     int a[n1];
39 |     for(i=0;i<n1;i++)
40 |         scanf("%d",&a[i]);
41 |     
42 |     int n2;
43 |     scanf("%d",&n2);
44 |     int b[n2];
45 |     for(i=0;i<n2;i++)
46 |         scanf("%d",&b[i]);
47 |     
48 |     int ans[n1+n2];
49 |     int fans[n1+n2];
50 |     
51 |     
52 |     for(i=0;i<n1;i++)
53 |         ans[i]=a[i];
54 |     int z=n1;
55 |     for(i=0;i<n2;i++)
56 |         ans[z++]=b[i];
57 |     
58 |     fans[0]=ans[0];
59 |     
60 |     
61 |     
62 |     
63 |     for(i=1;i<(n1+n2);i++)
64 |     {
65 |         for(j=0;j<i;j++)
66 |         {
67 |             if(ans[i]==ans[j])
68 |                 break;
69 |         }
70 |         if(i==j)
71 |         { 
72 |             fans[c++]=ans[i];
73 |         }
74 |             
75 |     }
76 |   
77 |     
78 |     for(i=0;i<c-1;i++)
79 |     {
80 |         for(j=i+1;j<c;j++)
81 |         {
82 |             if(fans[i]>fans[j])
83 |             {
84 |                 int temp=fans[i];
85 |                 fans[i]=fans[j];
86 |                 fans[j]=temp;
87 |             }
88 |         }
89 |     }
90 |       for(i=0;i<c;i++)
91 |         printf("%d ",fans[i]);
92 | }
93 | 


--------------------------------------------------------------------------------
/Merge Two Arrays 6:
--------------------------------------------------------------------------------
  1 | Need to write a program to merge two sorted arrays without duplicates
  2 | 
  3 | Input Format
  4 | 
  5 | 5
  6 | 1 2 3 6 9 
  7 | 4
  8 | 2 4 5 10
  9 | 
 10 | Constraints
 11 | 
 12 | 3<=n<=20
 13 | 
 14 | Output Format
 15 | 
 16 | 1 2 3 4 5 6 9 10
 17 | 
 18 | Sample Input 0
 19 | 
 20 | 6
 21 | 3 5 6 9 13 16
 22 | 5
 23 | 4 5 7 10 11
 24 | Sample Output 0
 25 | 
 26 | 3 4 5 6 7 9 10 11 13 16
 27 | ----------------------------------------------------------------------------
 28 | #include <stdio.h>
 29 | #include <string.h>
 30 | #include <math.h>
 31 | #include <stdlib.h>
 32 | 
 33 | int main() {
 34 | 
 35 |     int n1,c=1,i,j;
 36 |     scanf("%d",&n1);
 37 |     int a[n1];
 38 |     for(i=0;i<n1;i++)
 39 |         scanf("%d",&a[i]);
 40 |     
 41 |     int n2;
 42 |     scanf("%d",&n2);
 43 |     int b[n2];
 44 |     for(i=0;i<n2;i++)
 45 |         scanf("%d",&b[i]);
 46 |     
 47 |     int ans[n1+n2];
 48 |     int fans[n1+n2];
 49 |     
 50 |     
 51 |     for(i=0;i<n1;i++)
 52 |         ans[i]=a[i];
 53 |     int z=n1;
 54 |     for(i=0;i<n2;i++)
 55 |         ans[z++]=b[i];
 56 |     
 57 |     fans[0]=ans[0];
 58 |     
 59 |     
 60 |     
 61 |     
 62 |     for(i=1;i<(n1+n2);i++)
 63 |     {
 64 |         for(j=0;j<i;j++)
 65 |         {
 66 |             if(ans[i]==ans[j])
 67 |                 break;
 68 |         }
 69 |         if(i==j)
 70 |         { 
 71 |             fans[c++]=ans[i];
 72 |         }
 73 |             
 74 |     }
 75 |   
 76 |     
 77 |     for(i=0;i<c-1;i++)
 78 |     {
 79 |         for(j=i+1;j<c;j++)
 80 |         {
 81 |             if(fans[i]>fans[j])
 82 |             {
 83 |                 int temp=fans[i];
 84 |                 fans[i]=fans[j];
 85 |                 fans[j]=temp;
 86 |             }
 87 |         }
 88 |     }
 89 |       for(i=0;i<c;i++)
 90 |         printf("%d ",fans[i]);
 91 | }
 92 | ----------------------------------------------------------------------------------------
 93 | #include <stdio.h>
 94 | #include <string.h>
 95 | #include <math.h>
 96 | #include <stdlib.h>
 97 | #define M 5
 98 | #define N 4
 99 | int main() {
100 |      int arr1[100], arr2[100], merged[200], size1, size2, i, j, k;
101 |     scanf("%d", &size1);
102 |     for(i = 0; i < size1; i++)
103 |     {
104 |         scanf("%d", &arr1[i]);
105 |     }
106 |     scanf("%d", &size2);
107 |     for(i = 0; i < size2; i++)
108 |     {
109 |         scanf("%d", &arr2[i]);
110 |     }
111 |     i = j = k = 0;
112 |     while(i < size1 && j < size2)
113 |     {
114 |         if(arr1[i] < arr2[j])
115 |         {
116 |             merged[k] = arr1[i];
117 |             i++;
118 |         }
119 |         else if(arr1[i] > arr2[j])
120 |         {
121 |             merged[k] = arr2[j];
122 |             j++;
123 |         }
124 |         else
125 |         {
126 |             merged[k] = arr1[i];
127 |             i++;
128 |             j++;
129 |         }
130 | 
131 |         k++;
132 |     }
133 |     while(i < size1)
134 |     {
135 |         merged[k] = arr1[i];
136 |         i++;
137 |         k++;
138 |     }
139 |     while(j < size2)
140 |     {
141 |         merged[k] = arr2[j];
142 |         j++;
143 |         k++;
144 |     }
145 |     for(i = 0; i < k; i++)
146 |     {
147 |         if(i > 0 && merged[i] == merged[i - 1])
148 |         {
149 |             continue;
150 |         }
151 | 
152 |         printf("%d ", merged[i]);
153 |    
154 | }
155 | 
156 |     return 0;
157 | } 
158 | 


--------------------------------------------------------------------------------
/Minimum at sliding Widow:
--------------------------------------------------------------------------------
 1 | Consider a sliding window of size k equals 2. Let the array be [3,4,2,7,6,8,2,7] the
 2 | output should print 2 as the first output as first window contains {3,4,2} and second
 3 | window contains {4,2,7} and so on
 4 | 
 5 | Input Format
 6 | 
 7 | 7
 8 | 5 2 9 7 1 5 9
 9 | 3
10 | 
11 | Constraints
12 | 
13 | 4<=n<=12
14 | 1<=E<=9
15 | 
16 | Output Format
17 | 
18 | 2 2 1 1 1
19 | 
20 | Sample Input 0
21 | 
22 | 9
23 | 1 2 3 4 5 6 7 8 9
24 | 3
25 | Sample Output 0
26 | 
27 | 1 2 3 4 5 6 7
28 | ---------------------------------------------------------------------------------------------------
29 | #include <stdio.h>
30 | #include <string.h>
31 | #include <math.h>
32 | #include <stdlib.h>
33 | #include<limits.h>
34 | 
35 | int main() {
36 |    int n;
37 |     scanf("%d", &n);
38 |     int a[n];
39 |     for (int i = 0; i < n; i++) {
40 |         scanf("%d", &a[i]);
41 |     }
42 |     int k;
43 |     scanf("%d", &k);
44 |     for (int i = 0; i <= n - k; i++) {
45 |         int min= INT_MAX;
46 | 
47 |         for (int j = i; j < i + k; j++) {
48 |             if (a[j] < min) {
49 |                 min= a[j];
50 |             }
51 |         }
52 |         printf("%d ", min);
53 |     }
54 |     return 0;
55 | }
56 | 
57 | 


--------------------------------------------------------------------------------
/Monica's Problem:
--------------------------------------------------------------------------------
 1 | Monica wants to buy a keyboard and a USB drive from her favorite electronics store. The store has several models of each. Monica wants to spend as much as possible for the 2 items, given her budget.
 2 | Given the price lists for the store’s keyboards and USB drives, and Monica’s budget, find and print the amount of money Monica will spend. If she doesn’t have enough money to both a keyboard and a USB drive, print -1 instead. She will buy only the two required items.
 3 | For example, suppose she has b=60 to spend. Three keyboards cost, keyboards=[40,50,70]. Three USB drives cost drives=[5,8,12]. She could purchase a 40 keyboards + 12 USB drives =52 or a 50 keyboards + 8 USB drives =58. She chooses the latter. She can’t buy more than 2 items so she can’t spend exactly 60.
 4 | 
 5 | Input Format 
 6 | 
 7 | 3
 8 | 3
 9 | 40 50 70
10 | 5 8 12
11 | 60
12 | 
13 | Constraints
14 | 
15 | She should buy 2 items
16 | 
17 | Output Format
18 | 
19 | 58
20 | 
21 | Sample Input 0
22 | 
23 | 4
24 | 4
25 | 1 2 3 7
26 | 5 6 7 9
27 | 15
28 | Sample Output 0
29 | 
30 | 14
31 | ================================================================================
32 | #include <stdio.h>
33 | #include <string.h>
34 | #include <math.h>
35 | #include <stdlib.h>
36 | #include <limits.h>
37 | int main() {
38 | 
39 |     int n,m,max=INT_MIN,i,j;
40 |     scanf("%d%d",&n,&m);
41 |     int a[n];
42 |     int b[m];
43 |     for(i=0;i<n;i++)
44 |         scanf("%d",&a[i]);
45 |     for(i=0;i<n;i++)
46 |         scanf("%d",&b[i]);
47 |     int key;
48 |     scanf("%d",&key);
49 |     
50 |     for(i=0;i<n;i++)
51 |     { 
52 |         for(j=0;j<m;j++)
53 |         {
54 |             if(a[i]+b[j]>max&&a[i]+b[j]<key)
55 |                 max=a[i]+b[j];
56 |         }
57 |     }
58 |     if(max==INT_MIN)
59 |         printf("-1");
60 |     else
61 |         printf("%d",max);
62 |     return 0;
63 | }
64 | 


--------------------------------------------------------------------------------
/Number of Occurrences 1:
--------------------------------------------------------------------------------
 1 | Given an array with n elements print the number of occurrences of that number each
 2 | number in that array. The order of number does matter. You cannot reorder the
 3 | elements.
 4 | 
 5 | Input Format
 6 | 
 7 | 9
 8 | 2 1 3 2 2 5 8 9 8
 9 | 
10 | Constraints
11 | 
12 | 5<=n<=10
13 | 
14 | Output Format
15 | 
16 | 2 – 3
17 | 1 – 1
18 | 3 – 1
19 | 5 – 1
20 | 8 – 2
21 | 9 – 1
22 | 
23 | Sample Input 0
24 | 
25 | 6
26 | 6 7 7 6 3 2
27 | Sample Output 0
28 | 
29 | 6 - 2
30 | 7 - 2
31 | 3 - 1
32 | 2 - 1
33 | --------------------------------------------------------------------------------------------------
34 | #include <cmath>
35 | #include <cstdio>
36 | #include <vector>
37 | #include <iostream>
38 | #include <algorithm>
39 | using namespace std;
40 | 
41 | int fun(int a[],int n,int key)
42 | {
43 |     int c=0;
44 |     for(int i=0;i<n;i++)
45 |     {
46 |         if(a[i]==key)
47 |         {
48 |             c++;
49 |             a[i]=-1;
50 |         }    
51 |     }
52 |     return c;
53 | }
54 | 
55 | int main() {
56 |     int n,i;
57 |     scanf("%d",&n);
58 |     int a[n];
59 |     for(i=0;i<n;i++)
60 |         scanf("%d",&a[i]);
61 |     for(i=0;i<n;i++)
62 |     {
63 |         if(a[i]!=-1)
64 |         {
65 |             printf("%d - ",a[i]);
66 |             int c=fun(a,n,a[i]);
67 |             printf("%d\n",c);
68 |         }
69 |     }
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/Number of occurrences 1:
--------------------------------------------------------------------------------
 1 | Given a array with n elements print the number of occurrences of that number each number in that array.
 2 | 
 3 | Input Format
 4 | 
 5 | 9
 6 | 2 1 3 2 2 5 8 9 8
 7 | 
 8 | Constraints
 9 | 
10 | 4<=n<=20
11 | 
12 | Output Format
13 | 
14 | 1 - 1
15 | 2 - 3
16 | 3 - 1
17 | 5 - 1
18 | 8 - 2
19 | 9 - 1
20 | 
21 | Sample Input 0
22 | 
23 | 10
24 | 3 5 4 1 4 3 7 6 7 2
25 | Sample Output 0
26 | 
27 | 1 - 1
28 | 2 - 1
29 | 3 - 2
30 | 4 - 2
31 | 5 - 1
32 | 6 - 1
33 | 7 - 2
34 | -------------------------------------------------------------------------------------------------------------------
35 | #include <stdio.h>
36 | #include <string.h>
37 | #include <math.h>
38 | #include <stdlib.h>
39 | 
40 | int main() {
41 |     int n,i,j;
42 |     scanf("%d",&n);
43 |     int a[n];
44 |      int vis[n];
45 |     for(i=0;i<n;i++)
46 |         scanf("%d",&a[i]);
47 |     
48 |     for(i=0;i<n;i++)
49 |         vis[i]=-1;
50 |     
51 |     for(i=0;i<n-1;i++)
52 |     {
53 |         for(j=i+1;j<n;j++)
54 |         {
55 |             if(a[i]>a[j])
56 |             {
57 |                 int temp=a[i];
58 |                 a[i]=a[j];
59 |                 a[j]=temp;
60 |             }
61 |         }
62 |     }
63 |     
64 |     for(i=0;i<n;i++)
65 |     {
66 |         if(vis[i]==0)
67 |             continue;
68 |         
69 |         int c=1;
70 |         for(j=i+1;j<n;j++)
71 |         {
72 |             if(a[i]==a[j])
73 |             {
74 |                 vis[j]=0;
75 |                 c++;
76 |             }
77 |         }
78 |         printf("%d - %d\n",a[i],c);
79 |     }
80 | }
81 |     
82 |     
83 |     
84 | 


--------------------------------------------------------------------------------
/Occurrence of elements:
--------------------------------------------------------------------------------
 1 | Find the occurrence of a number and display the values in ascending order of the given input
 2 | 
 3 | Input Format
 4 | 
 5 | 9
 6 | 3 4 3 4 1 2 3 1 2
 7 | 
 8 | Constraints
 9 | 
10 | 6<=n<=12
11 | 
12 | Output Format
13 | 
14 | 2 2 3 2
15 | 
16 | 
17 | Explanation:
18 | 1 = 2 times
19 | 2 = 2 times
20 | 3 = 3 times
21 | 4 = 2 times
22 | so, 2 2 3 2 is the answer.
23 | 
24 | Sample Input 0
25 | 
26 | 8
27 | 4 3 5 3 4 5 3 3
28 | Sample Output 0
29 | 
30 | 4 2 2
31 | ================================================================================================
32 | #include <stdio.h>
33 | #include <string.h>
34 | #include <math.h>
35 | #include <stdlib.h>
36 | #include <limits.h>
37 | int max1(int a[],int n)
38 | {
39 |     int max=INT_MIN;
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         if(a[i]>max)
43 |             max=a[i];
44 |     }
45 |     return max;
46 | }
47 | int main() {
48 | 
49 |     int n;
50 |     scanf("%d",&n);
51 |     int a[n];
52 |     for(int i=0;i<n;i++)
53 |         scanf("%d",&a[i]);
54 |     int max=max1(a,n);
55 |     int f[max+1];
56 |     for(int i=0;i<=max;i++)
57 |     {
58 |         f[i]=0;
59 |     }
60 |     for(int i=0;i<n;i++)
61 |     {
62 |         f[a[i]]++;
63 |     }
64 |     for(int i=1;i<=max;i++)
65 |     {
66 |         if(f[i]!=0)
67 |             printf("%d ",f[i]);
68 |     }
69 |     return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/Odd occurrences:
--------------------------------------------------------------------------------
 1 | Given an unsorted array that contains even number of occurrences for all numbers except
 2 | two numbers. Find the two numbers which have odd occurrences in O(n) time complexity
 3 | and O(1) extra space.
 4 | 
 5 | Input Format
 6 | 
 7 | 8
 8 | 12 23 34 12 12 23 12 45
 9 | 
10 | Constraints
11 | 
12 | Given input should be an array
13 | 
14 | Output Format
15 | 
16 | 34 45
17 | 
18 | Sample Input 0
19 | 
20 | 10
21 | 4 4 100 5000 4 4 4 4 100 100
22 | Sample Output 0
23 | 
24 | 100 5000
25 | 
26 | ===================================================================================================================================
27 | #include <stdio.h>
28 | int find_odd_occurrences(int a[], int n,int key) 
29 | {
30 |     int c=0;
31 |    for(int i=0;i<n;i++)
32 |    {
33 |        if(a[i]==key)
34 |        {
35 |            c++;
36 |            a[i]=-1;
37 |        }
38 |    }
39 |  return c;
40 | }
41 | 
42 | int main() {
43 |     int n;
44 |     scanf("%d", &n);
45 | 
46 |     int a[n];
47 |     for (int i = 0; i < n; i++) {
48 |         scanf("%d", &a[i]);
49 |     }
50 |     for(int i=0;i<n;i++)
51 |     {
52 |         if(a[i]==-1)
53 |             continue;
54 |         int key=a[i];
55 |         int c=find_odd_occurrences(a, n,key);
56 |         if(c%2!=0)
57 |             printf("%d ",key);
58 |     }
59 |     return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/Print After Rotate:
--------------------------------------------------------------------------------
 1 | Write a program to Rotate kth times of the given array.
 2 | then print the given index range elements.
 3 | 
 4 | Input Format
 5 | 
 6 | 7
 7 | 1 2 3 4 5 6 7
 8 | 2
 9 | 3 5
10 | 
11 | Constraints
12 | 
13 | 4<=n<=12
14 | 1<=E<=9
15 | 
16 | Output Format
17 | 
18 | 2 3 4
19 | 
20 | Sample Input 0
21 | 
22 | 5
23 | 5 4 3 6 1
24 | 1
25 | 1 3
26 | Sample Output 0
27 | 
28 | 5 4 3
29 | ---------------------------------------------------------------------------------------------------------------------------
30 | #include <stdio.h>
31 | #include <string.h>
32 | #include <math.h>
33 | #include <stdlib.h>
34 | 
35 | void fun(int a[],int n,int k,int s,int e){
36 |     for(int i =0;i<k;i++){
37 |         int k = a[n-1];
38 |         for(int j=n-1;j>=0;j--){
39 |             a[j+1] = a[j];
40 |         }
41 |         a[0] = k;
42 |     }
43 |     for(int i=s;i<=e;i++){
44 |         printf("%d ",a[i]);
45 |     }
46 | }
47 | 
48 | int main() {
49 | 
50 |     int n;
51 |     scanf("%d",&n);
52 |     int a[n];
53 |     for(int i=0;i<n;i++){
54 |         scanf("%d",&a[i]);
55 |     }
56 |     int x,y,z;
57 |     scanf("%d%d%d",&x,&y,&z);
58 |     fun(a,n,x,y,z);
59 |     return 0;
60 | }
61 | 
62 | 
63 |    
64 | 


--------------------------------------------------------------------------------
/Print Array:
--------------------------------------------------------------------------------
 1 | 
 2 | Need to write a program print the array as given input.
 3 | 
 4 | Input Format
 5 | 
 6 | 6
 7 | 5 6 4 3 8 9
 8 | 
 9 | Constraints
10 | 
11 | 1<=n<=20
12 | 
13 | Output Format
14 | 
15 | 5 6 4 3 8 9
16 | 
17 | Sample Input 0
18 | 
19 | 5
20 | 9 8 6 5 7
21 | Sample Output 0
22 | 
23 | 9 8 6 5 7
24 | -----------------------------------------------------------------------------------------------------------------
25 | #include<stdio.h>
26 | int main() {
27 |     int n,i;
28 |     scanf("%d",&n);
29 |     int a[n];
30 |     for(i=0;i<n;i++)
31 |         scanf("%d",&a[i]);
32 |     for(i=0;i<n;i++)
33 |         printf("%d ",a[i]);
34 | }
35 | 


--------------------------------------------------------------------------------
/Print Given Range:
--------------------------------------------------------------------------------
 1 | Need to write a program to print the elements between the given range.
 2 | 
 3 | Input Format
 4 | 
 5 | 7
 6 | 4 5 3 7 6 9 1
 7 | 2 5
 8 | 
 9 | Constraints
10 | 
11 | 1<=n<=20
12 | 
13 | Output Format
14 | 
15 | 3 7 6 9
16 | 
17 | Sample Input 0
18 | 
19 | 7
20 | 2 3 1 4 9 8 7
21 | 1 4
22 | Sample Output 0
23 | 
24 | 3 1 4 9
25 | ===================================================================================
26 | #include<stdio.h>
27 | int main() {
28 |     int n,i;
29 |     scanf("%d",&n);
30 |     int a[n];
31 |     for(i=0;i<n;i++)
32 |         scanf("%d",&a[i]);
33 |     
34 |     int key1,key2;
35 |     scanf("%d %d",&key1,&key2);
36 |     
37 |     for(i=key1;i<=key2;i++)
38 |         printf("%d ",a[i]);
39 | }
40 | ===========================================================================================================================
41 | import java.io.*;
42 | import java.util.*;
43 | 
44 | public class Solution {
45 | 
46 |     public static void main(String[] args) {
47 |         Scanner z=new Scanner(System.in);
48 |         int n=z.nextInt();
49 |         int a[]=new int[n];
50 |         for(int i=0;i<n;i++)
51 |             a[i]=z.nextInt();
52 |         int s=z.nextInt();
53 |         int e=z.nextInt();
54 |         
55 |         for(int i=s;i<=e;i++)
56 |             System.out.print(a[i]+" ");
57 |     }
58 |     
59 | }
60 | 


--------------------------------------------------------------------------------
/Print after Finding the element:
--------------------------------------------------------------------------------
 1 | Write a program to find the given element's index and print the next index's element
 2 | 
 3 | Input Format
 4 | 
 5 | 12
 6 | 1 2 3 4 5 6 7 8 9 10 11 12
 7 | 5
 8 | 
 9 | Constraints
10 | 
11 | 10<=n<=20
12 | 1<=E<=100
13 | 
14 | Output Format
15 | 
16 | 6
17 | 
18 | Sample Input 0
19 | 
20 | 15
21 | 1 3 4 6 7 9 10 12 13 15 17 20 23 25 27
22 | 17
23 | Sample Output 0
24 | 
25 | 20
26 | --------------------------------------------------------------------------------------------------------------------------------------------
27 | #include <stdio.h>
28 | #include <string.h>
29 | #include <math.h>
30 | #include <stdlib.h>
31 | 
32 | int main() {
33 |     int n,i,key;
34 |     scanf("%d",&n);
35 |     int a[n];
36 |     for(i=0;i<n;i++)
37 |         scanf("%d",&a[i]);
38 |     scanf("%d",&key);
39 |     
40 |     for(i=0;i<n;i++)
41 |     {
42 |         if(a[i]==key)
43 |         {
44 |             printf("%d",a[i+1]);
45 |             break;
46 |         }
47 |     }
48 |     
49 |    
50 |     return 0;
51 | }
52 | -----------------------------------------------------------------------------------------------------------------------------------
53 | #include <stdio.h>
54 | #include <string.h>
55 | #include <math.h>
56 | #include <stdlib.h>
57 | 
58 | void fun(int n,int key,int a[])
59 | {
60 |     for(int i=0;i<n;i++)
61 |     {
62 |         if(a[i]==key)
63 |         {
64 |             printf("%d",a[i+1]);
65 |             break;
66 |         }
67 |     }
68 |     
69 | }
70 | 
71 | int main() {
72 |     int n,i,key;
73 |     scanf("%d",&n);
74 |     int a[n];
75 |     for(i=0;i<n;i++)
76 |         scanf("%d",&a[i]);
77 |     scanf("%d",&key);
78 |     fun(n,key,a);
79 |     
80 |    
81 |     return 0;
82 | }
83 | 


--------------------------------------------------------------------------------
/Print as given:
--------------------------------------------------------------------------------
 1 | Need to write a program to print the array as given
 2 | 
 3 | Input Format
 4 | 
 5 | 7
 6 | 
 7 | Constraints
 8 | 
 9 | 1<=n<=20
10 | 
11 | Output Format
12 | 
13 | 3 6 9 12 15 18 21
14 | 
15 | Sample Input 0
16 | 
17 | 5
18 | Sample Output 0
19 | 
20 | 3 6 9 12 15
21 | --------------------------------------------------------------------------------------------
22 | #include <stdio.h>
23 | #include <string.h>
24 | #include <math.h>
25 | #include <stdlib.h>
26 | 
27 | int main() {
28 | 
29 |   int n,i;
30 |     scanf("%d",&n);
31 |     int a[n];
32 |     for(i=0;i<n;i++)
33 |         a[i]=3*(i+1);
34 |     for(i=0;i<n;i++)
35 |         printf("%d ",a[i]);
36 | }
37 |     
38 | 


--------------------------------------------------------------------------------
/Print without Duplication:
--------------------------------------------------------------------------------
 1 | Given an array of numbers. Print the numbers without duplication.
 2 | 
 3 | Input Format
 4 | 
 5 | 4
 6 | 1 1 2 4
 7 | 
 8 | Constraints
 9 | 
10 | 4<=n<=20
11 | 
12 | Output Format
13 | 
14 | 1 2 4
15 | 
16 | Sample Input 0
17 | 
18 | 7
19 | 2 2 6 5 2 6 7
20 | Sample Output 0
21 | 
22 | 2 6 5 7
23 | -------------------------------------------------------------------------
24 | #include<stdio.h>
25 | int main(){
26 |   int n,i,j;
27 |  scanf("%d",&n);
28 |  int a[n];
29 |  for(i=0;i<n;i++)
30 |    scanf("%d",&a[i]);
31 |     
32 |     printf("%d ",a[0]);
33 |     
34 |  for(i=1;i<n;i++)
35 |  {
36 |      for(j=0;j<i;j++)
37 |      {
38 |          if(a[i]==a[j])
39 |             break;
40 |      }  
41 |      if(i==j)
42 |         printf("%d ",a[i]);
43 |  }    
44 | }  
45 | 


--------------------------------------------------------------------------------
/Remove Duplicate Elements 2:
--------------------------------------------------------------------------------
 1 | Need to write a program to remove duplicate elements from given array.
 2 | 
 3 | Input Format
 4 | 
 5 | 8
 6 | 3 2 4 2 7 6 3 8
 7 | 
 8 | Constraints
 9 | 
10 | 5<=n<=20
11 | 
12 | Output Format
13 | 
14 | 4 7 6 8
15 | 
16 | Sample Input 0
17 | 
18 | 8
19 | 3 2 4 2 7 6 3 8
20 | Sample Output 0
21 | 
22 | 4 7 6 8
23 | =====================================================================
24 | #include<stdio.h>
25 | int main(){
26 |   int n,i,j,c=0;
27 |  scanf("%d",&n);
28 |  int a[n];
29 |  for(i=0;i<n;i++)
30 |    scanf("%d",&a[i]);
31 |     
32 |     for(i=0;i<n;i++)
33 |     { c=0;
34 |      for(j=0;j<n;j++)
35 |      {
36 |          if(a[i]==a[j])
37 |             c++;
38 |      }  
39 |      if(c==1)
40 |         printf("%d ",a[i]);
41 |  }    
42 | }  
43 | 


--------------------------------------------------------------------------------
/Replace Elements 1:
--------------------------------------------------------------------------------
 1 | 
 2 | Replace every element with the smallest element on right side. Given an array of
 3 | integers, replace every element with the next smallest element (smallest element on
 4 | the right side) in the array. Since there is no element next to the last element,
 5 | replace it with -1.
 6 | 
 7 | Input Format
 8 | 
 9 | 6
10 | 16 17 2 3 5 4
11 | 
12 | Constraints
13 | 
14 | 3<=n<=10
15 | 
16 | Output Format
17 | 
18 | 2 2 3 4 4 -1
19 | 
20 | Sample Input 0
21 | 
22 | 7
23 | 1 2 3 4 5 6 7
24 | Sample Output 0
25 | 
26 | 2 3 4 5 6 7 -1
27 | ---------------------------------------------------------------------------------------------------------------------------------------------------------------
28 | 
29 | 2 array
30 | 
31 | import java.io.*;
32 | import java.util.*;
33 | import java.text.*;
34 | import java.math.*;
35 | import java.util.regex.*;
36 | 
37 | public class Solution {
38 |     public static void main(String args[] ) throws Exception {
39 |         Scanner z=new Scanner(System.in);
40 |         int n,t=0;
41 |         n=z.nextInt();
42 |         int a[]=new int[n];
43 |         int b[]=new int[n];
44 |         for(int i=0;i<n;i++)
45 |             a[i]=z.nextInt();
46 |         
47 |         b[n-1]=-1;
48 |         b[n-2]=a[n-1];
49 |         
50 |         for(int i=n-2;i>0;i--)
51 |         {
52 |             if(b[i]<a[i])
53 |                 b[i-1]=b[i];
54 |             else
55 |                 b[i-1]=a[i];
56 |         }
57 |         for(int i=0;i<n;i++)
58 |             System.out.print(b[i]+" ");
59 |     }
60 | }
61 | 
62 | -----------------------------------------------------------------------------------------
63 | 1 array
64 | 
65 | import java.io.*;
66 | import java.util.*;
67 | import java.text.*;
68 | import java.math.*;
69 | import java.util.regex.*;
70 | 
71 | public class Solution {
72 |     public static void main(String args[] ) throws Exception {
73 |         Scanner z=new Scanner(System.in);
74 |         int n,t=0;
75 |         n=z.nextInt();
76 |         int a[]=new int[n+1];
77 |         for(int i=0;i<n;i++)
78 |             a[i]=z.nextInt();
79 |         a[n]=-1;
80 |         for(int i=n-2;i>0;i--)
81 |         {
82 |             if(a[i]>a[i+1])
83 |                 a[i]=a[i+1];
84 |         }
85 |         for(int i=1;i<=n;i++)
86 |             System.out.print(a[i]+" ");
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/Reverse Array:
--------------------------------------------------------------------------------
 1 | void rev(int a[],int n)
 2 | {
 3 |     int i=0;
 4 |     int j=n-1;
 5 |     while(i<j)
 6 |     {
 7 |         int t=a[i];
 8 |         a[i]=a[j];
 9 |         a[j]=t;
10 |         i++,j--;
11 |     }
12 | }
13 | int main() {
14 | 
15 |     int n;
16 |     scanf("%d",&n);
17 |     int a[n];
18 |     for(int i=0;i<n;i++)
19 |         scanf("%d",&a[i]);
20 |   
21 |     rev(a,n);
22 |     
23 |     for(int i=0;i<n;i++)
24 |         printf("%d ",a[i]);
25 |     
26 |     return 0;
27 | }
28 | =============================================================================
29 | Write a program to reverse the given array
30 | 
31 | Input Format
32 | 
33 | 8
34 | 1 2 3 4 5 6 7 8
35 | 
36 | Constraints
37 | 
38 | input should be an array
39 | 
40 | Output Format
41 | 
42 | 8 7 6 5 4 3 2 1
43 | 
44 | Sample Input 0
45 | 
46 | 5
47 | 4 3 6 7 8
48 | Sample Output 0
49 | 
50 | 8 7 6 3 4
51 | 


--------------------------------------------------------------------------------
/Reverse Entire Array:
--------------------------------------------------------------------------------
 1 | Need to write a program to reverse the entire Array
 2 | 
 3 | Input Format
 4 | 
 5 | 5
 6 | 7 6 5 2 3
 7 | 
 8 | Constraints
 9 | 
10 | 1<=n<=20
11 | 
12 | Output Format
13 | 
14 | 3 2 5 6 7
15 | 
16 | Sample Input 0
17 | 
18 | 6
19 | 4 3 2 7 8 1
20 | Sample Output 0
21 | 
22 | 1 8 7 2 3 4
23 | ----------------------------------------------------------------------------------------------------------------------------------------
24 | 
25 | 2 Array
26 | 
27 | #include<stdio.h>
28 | int main() {
29 |     int n,i,j;
30 |     scanf("%d",&n);
31 |     int a[n],b[n];
32 |     for(i=0;i<n;i++)
33 |         scanf("%d",&a[i]);
34 |     i=0,j=n-1;
35 |     while(i<n&&j>=0)
36 |     {
37 |         b[i]=a[j];
38 |         j--;
39 |         i++;
40 |     }
41 |     for(i=0;i<n;i++)
42 |         printf("%d ",b[i]);
43 | }
44 | ----------------------------------------------------------------------------------------------------------------------------------------
45 | Single Array
46 | 
47 | #include<stdio.h>
48 | int main() {
49 |     int n,temp,i,j;
50 |     scanf("%d",&n);
51 |     int a[n];
52 |     for(i=0;i<n;i++)
53 |         scanf("%d",&a[i]);
54 |     i=0,j=n-1;
55 |     while(i<j)
56 |     {
57 |         temp=a[i];
58 |         a[i]=a[j];
59 |         a[j]=temp;
60 |         j--;
61 |         i++;
62 |     }
63 |     for(i=0;i<n;i++)
64 |         printf("%d ",a[i]);
65 | }
66 | ============================================================================================================================
67 | public class Main {
68 |     static void rev(int a[],int s,int e)
69 |     {
70 |         if(s>e)
71 |             return;
72 |         int t=a[s];
73 |         a[s]=a[e];
74 |         a[e]=t;
75 |         rev(a,s+1,e-1);
76 |     }
77 |     static void dis(int a[],int n)
78 |     {
79 |         for(int i=0;i<n;i++)
80 |             System.out.println(a[i]);
81 |     }
82 |     public static void main(String[] args) {
83 |         Scanner z=new Scanner (System.in);
84 |         int n=z.nextInt();
85 |         int a[]=new int[n];
86 |         for(int i=0;i<n;i++)
87 |             a[i]=z.nextInt();
88 |         rev(a,0,n-1);
89 |         dis(a,n);
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/Reverse first and second half:
--------------------------------------------------------------------------------
  1 | Need to write a program left and right half separately
  2 | 
  3 | Input Format
  4 | 
  5 | 7
  6 | 1 2 3 4 5 6 7
  7 | 
  8 | Constraints
  9 | 
 10 | 1<=n<=20
 11 | 
 12 | Output Format
 13 | 
 14 | 3 2 1 4 7 6 5
 15 | 
 16 | Sample Input 0
 17 | 
 18 | 6
 19 | 1 2 3 4 5 6
 20 | Sample Output 0
 21 | 
 22 | 3 2 1 6 5 4
 23 | ============================================================================================================================
 24 | #include <stdio.h>
 25 | #include <string.h>
 26 | #include <math.h>
 27 | #include <stdlib.h>
 28 | void fun(int a[],int l,int r)
 29 | {
 30 |     while(l<r)
 31 |     {
 32 |         int temp=a[l];
 33 |         a[l]=a[r];
 34 |         a[r]=temp;
 35 |         l++;
 36 |         r--;
 37 |     }
 38 | }
 39 | int main() {
 40 | 
 41 |     int n,i;
 42 |     scanf("%d",&n);
 43 |     int a[n];
 44 |     for(i=0;i<n;i++)
 45 |         scanf("%d",&a[i]);
 46 |     
 47 |     int l=0;
 48 |     int r=(n/2)-1;
 49 |     fun(a,l,r) ;         //first half
 50 |         
 51 |     l=ceil(n/2.0);
 52 |     r=n-1;
 53 |     fun(a,l,r);         //second half
 54 |     
 55 |     for(i=0;i<n;i++)
 56 |         printf("%d ",a[i]);     //print
 57 |     
 58 |     return 0;
 59 | }
 60 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 61 | 
 62 | #include <stdio.h>
 63 | #include <string.h>
 64 | #include <math.h>
 65 | #include <stdlib.h>
 66 | 
 67 | int main() {
 68 | 
 69 |     int n,i;
 70 |     scanf("%d",&n);
 71 |     int a[n];
 72 |     for(i=0;i<n;i++)
 73 |         scanf("%d",&a[i]);
 74 |     int half=n/2;
 75 |     int l=0;
 76 |     int r=half-1;
 77 |     while(l<r)
 78 |     {
 79 |         int temp=a[l];
 80 |         a[l]=a[r];
 81 |         a[r]=temp;
 82 |         l++;
 83 |         r--;
 84 |     }
 85 |     half=ceil(n/2.0);
 86 |     l=half;
 87 |     r=n-1;
 88 |      while(l<r)
 89 |     {
 90 |         int temp=a[l];
 91 |         a[l]=a[r];
 92 |         a[r]=temp;
 93 |         l++;
 94 |         r--;
 95 |     }
 96 |     for(i=0;i<n;i++)
 97 |         printf("%d ",a[i]);
 98 |     
 99 |     return 0;
100 | }
101 | 
102 | 


--------------------------------------------------------------------------------
/Rotate an array 2:
--------------------------------------------------------------------------------
 1 | Write a program to rotate an array elements by kth elements.
 2 | 
 3 | Input Format
 4 | 
 5 | 6
 6 | 2 3 4 7 6 1
 7 | 2
 8 | 
 9 | Constraints
10 | 
11 | Input should be an array
12 | 
13 | Output Format
14 | 
15 | 6 1 2 3 4 7
16 | 
17 | Sample Input 0
18 | 
19 | 5
20 | 5 4 3 2 1
21 | 3
22 | Sample Output 0
23 | 
24 | 3 2 1 5 4
25 | ----------------------------------------------------------------------------------------------------------------------
26 | #include <stdio.h>
27 | #include <string.h>
28 | #include <math.h>
29 | #include <stdlib.h>
30 | 
31 | int main() {
32 | 
33 |     int n,i,k;
34 |     scanf("%d",&n);
35 |     int a[n];
36 |     
37 |     for(int i=0;i<n;i++)
38 |         scanf("%d",&a[i]);
39 |     scanf("%d",&k);
40 |     
41 |     
42 |     while(k>0)
43 |     {
44 |        int t1=a[n-1];
45 |         for(i=n-2;i>=0;i--)
46 |         {
47 |             a[i+1]=a[i];
48 |         }
49 |         k--;
50 |         a[0]=t1;
51 |     }
52 |         
53 |     
54 |     
55 |     for(i=0;i<n;i++){
56 |         printf("%d ",a[i]);
57 |     }
58 |  return 0;
59 | }
60 | 
61 | -----------------------------------------------------------------------------------------------------------------------
62 | #include <stdio.h>
63 | #include <string.h>
64 | #include <math.h>
65 | #include <stdlib.h>
66 |     void rotation(int a[],int n,int k){
67 |     int i,j,t;
68 |     for(j=0;j<k;j++){
69 |         t=a[n-1];
70 |         for(i=n-2;i>=0;i--){
71 |             a[i+1]=a[i];
72 |         }
73 |         a[0]=t;
74 |     }
75 | }
76 | int main() {
77 | 
78 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
79 |     int n,i,k;
80 |     scanf("%d",&n);
81 |     int a[n];
82 |     for(int i=0;i<n;i++){
83 |         scanf("%d",&a[i]);
84 |     } scanf("%d",&k);
85 |     rotation(a,n,k);
86 |     for(i=0;i<n;i++){
87 |         printf("%d ",a[i]);
88 |     }
89 |  return 0;
90 | }
91 | 


--------------------------------------------------------------------------------
/Rotate and print elements:
--------------------------------------------------------------------------------
 1 | Write a program to rotate the array and print the elements
 2 | 
 3 | Input Format
 4 | 
 5 | 7
 6 | 3 6 5 8 7 1 9
 7 | 2
 8 | 2 4
 9 | 
10 | Constraints
11 | 
12 | Elements should be less than 10
13 | 
14 | Output Format
15 | 
16 | 3 6 5
17 | 
18 | Sample Input 0
19 | 
20 | 5
21 | 1 2 3 4 5
22 | 2
23 | 2 3
24 | Sample Output 0
25 | 
26 | 1 2
27 | Explanation 0
28 | 
29 | After 2 rotation the array becomes 4 5 1 2 3. We need to print the elements from the index of 2 to 3. So the result will be 1 2
30 | ------------------------------------------------------------------------------------------------------------------------------------------
31 | #include <stdio.h>
32 | #include <string.h>
33 | #include <math.h>
34 | #include <stdlib.h>
35 | 
36 | int main() {
37 |     int n,i,j,k,sr,er;
38 |     scanf("%d",&n);
39 |     int a[n];
40 |     for(i=0;i<n;i++)
41 |         scanf("%d",&a[i]);
42 |     scanf("%d",&k);
43 |     scanf("%d%d",&sr,&er);
44 |     int n1=n-k;
45 |    
46 |     for(i=n-k;i<n;i++)
47 |     {
48 |         for(j=i;j>i-n1;j--)
49 |         {
50 |             int temp=a[j];
51 |             a[j]=a[j-1];
52 |             a[j-1]=temp;
53 |         }
54 |     }
55 |     for(i=sr;i<=er;i++)
56 |         printf("%d ",a[i]);
57 | }
58 | 


--------------------------------------------------------------------------------
/Search and Print:
--------------------------------------------------------------------------------
  1 | Write a program to Search the elements and print elements between those indexes.
  2 | 
  3 | Input Format
  4 | 
  5 | 8
  6 | 3 8 7 6 9 1 3 5
  7 | 8
  8 | 1
  9 | 
 10 | Constraints
 11 | 
 12 | Elements should be less than 10
 13 | 
 14 | Output Format
 15 | 
 16 | 7 6 9
 17 | 
 18 | Sample Input 0
 19 | 
 20 | 7
 21 | 1 2 3 4 5 6 7
 22 | 3
 23 | 5
 24 | Sample Output 0
 25 | 
 26 | 4
 27 | Explanation 0
 28 | 
 29 | key 3 is at the index of 2 and the another key 5 is at the index of 4. So need to print between these indices.
 30 | So here, we have only 4. So the output will be 4.
 31 | ----------------------------------------------------------------------------------------------------------------------------------
 32 | #include <stdio.h>
 33 | #include <string.h>
 34 | #include <math.h>
 35 | #include <stdlib.h>
 36 | 
 37 | int main() {
 38 |     int n,i1=0,i2=0;
 39 |     scanf("%d",&n);
 40 |     int a[n];
 41 |     for(int i=0;i<n;i++)
 42 |         scanf("%d",&a[i]);
 43 |     
 44 |     int start;
 45 |     scanf("%d",&start);
 46 | 
 47 |     int end;
 48 |     scanf("%d",&end);
 49 | 
 50 |     for(int i=0;i<n;i++)
 51 |     {
 52 |         if(a[i]==start)
 53 |             i1=i;
 54 |         if(a[i]==end)
 55 |             i2=i; 
 56 |     }
 57 |     for(int i=i1+1;i<i2;i++)
 58 |         printf("%d ",a[i]);
 59 |     return 0;
 60 | }
 61 | -------------------------------------------------------------------------------------------------------------------------------------------
 62 | #include <stdio.h>
 63 | #include <string.h>
 64 | #include <math.h>
 65 | #include <stdlib.h>
 66 |    
 67 | findIndex(int a[],int n,int start)
 68 | 
 69 | {
 70 | 
 71 |     int index=-1;
 72 | 
 73 |    
 74 | 
 75 |     for(int i=0;i<n;i++)
 76 | 
 77 |     {
 78 | 
 79 |         if(a[i]==start)
 80 | 
 81 |         {
 82 | 
 83 |             index=i;
 84 | 
 85 |             break;
 86 | 
 87 |         }
 88 | 
 89 |     }
 90 | 
 91 |     return index;
 92 | 
 93 | }
 94 | 
 95 | int main() {
 96 | 
 97 |     int n;
 98 | 
 99 |     scanf("%d",&n);
100 | 
101 |     int a[n];
102 | 
103 |     for(int i=0;i<n;i++)
104 | 
105 |     {
106 | 
107 |         scanf("%d",&a[i]);
108 | 
109 |     }
110 | 
111 |     int start;
112 | 
113 |     scanf("%d",&start);
114 | 
115 |     int end;
116 | 
117 |     scanf("%d",&end);
118 | 
119 |     int i=findIndex(a,n,start);
120 | 
121 |     int j=findIndex(a,n,end);
122 | 
123 |         for(int k=i+1;k<j;k++)
124 | 
125 |         {
126 | 
127 |             printf("%d ",a[k]);
128 | 
129 |         }
130 | 
131 | return 0;
132 | 
133 | }
134 | 


--------------------------------------------------------------------------------
/Smaller then previous elements:
--------------------------------------------------------------------------------
 1 | You’re given an array. Print the elements of the array which are smaller than its
 2 | previous elements in the array.
 3 | 
 4 | Input Format
 5 | 
 6 | 7
 7 | 2 -3 -4 5 9 -1 -8
 8 | 
 9 | Constraints
10 | 
11 | 3<=n<=10
12 | 
13 | Output Format
14 | 
15 | 2 -3 -4 -8
16 | 
17 | Sample Input 0
18 | 
19 | 6
20 | 4 3 5 2 -2 8
21 | Sample Output 0
22 | 
23 | 4 3 2 -2
24 | ------------------------------------------------------------------------------------------------------------------------
25 | #include <stdio.h>
26 | #include <string.h>
27 | #include <math.h>
28 | #include <stdlib.h>
29 | 
30 | int main() {
31 | int n;
32 |     scanf("%d",&n);
33 |     int a[n];
34 |     for(int i=0;i<n;i++)
35 |     {
36 |         scanf("%d",&a[i]);
37 |     }
38 |     int min=a[0];
39 |     printf("%d ",min);
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         if(a[i]<min)
43 |         {
44 |             min=a[i];
45 |             printf("%d ",min);
46 |         }
47 |     }
48 | 
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/Sort Array 8 frequent method:
--------------------------------------------------------------------------------
  1 | Sort the array elements in descending order according to their frequency of occurrence
  2 | 
  3 | Input Format
  4 | 
  5 | 11
  6 | 2 2 3 4 5 12 2 3 3 3 12
  7 | 
  8 | Constraints
  9 | 
 10 | 5<=n<=20
 11 | 
 12 | Output Format
 13 | 
 14 | 3 3 3 3 2 2 2 12 12 4 5
 15 | 
 16 | Sample Input 0
 17 | 
 18 | 10
 19 | 3 3 2 2 2 5 5 5 8 7
 20 | Sample Output 0
 21 | 
 22 | 2 2 2 5 5 5 3 3 7 8
 23 | ======================================================================================================================================================
 24 | #include<stdio.h>
 25 | int maximum(int A[],int n){
 26 |     int max=A[0];
 27 |     for(int i=1;i<n;i++){
 28 |         if(A[i]>max){
 29 |             max=A[i];
 30 |         }
 31 |     }
 32 |     return max;
 33 | }
 34 | int minimum(int A[],int n){
 35 |     int min=A[0];
 36 |     for(int i=1;i<n;i++){
 37 |         if(A[i]<min){
 38 |             min=A[i];
 39 |         }
 40 |     }
 41 |     return min;
 42 | }
 43 | void hashing(int A[],int n){
 44 |     int max=maximum(A,n);
 45 |     int min=minimum(A,n);
 46 |     int y=-min;
 47 |     int B[max+1+y];
 48 |     for(int i=0;i<(max+1+y);i++){
 49 |         B[i]=0;
 50 |     }
 51 |     for(int i=0;i<n;i++){
 52 |         int k=A[i];
 53 |         B[k+y]++;
 54 |     }
 55 |     int maxB=maximum(B,max+1+y);
 56 |     while(maxB!=0){
 57 |         for(int i=0;i<(max+1+y);i++){
 58 |             if(B[i]==maxB){
 59 |                 for(int j=0;j<maxB;j++){
 60 |                     printf("%d ",i-y);
 61 |                 }
 62 |             }
 63 |         }
 64 |         maxB--;
 65 |     }
 66 | }
 67 | int main() {
 68 |     int n;
 69 |     scanf("%d",&n);
 70 |     int A[n];
 71 |     for(int i=0;i<n;i++){
 72 |         scanf("%d",&A[i]);
 73 |     }
 74 |     hashing(A,n);
 75 | }
 76 | 
 77 | -----------------------------------------------
 78 | #include <stdio.h>
 79 | #include <string.h>
 80 | #include <math.h>
 81 | #include <stdlib.h>
 82 | int maximum(int A[],int n){
 83 |     int max=A[0];
 84 |     for(int i=1;i<n;i++){
 85 |         if(A[i]>max){
 86 |             max=A[i];
 87 |         }
 88 |     }
 89 |     return max;
 90 | }
 91 | void hashing(int A[],int n){
 92 |      int max=maximum(A,n);  //1st
 93 |     int B[max+1];
 94 |     for(int i=0;i<(max+1);i++){
 95 |         B[i]=0;
 96 |     }
 97 |     for(int i=0;i<n;i++){
 98 |         int k=A[i];
 99 |         B[k]++;
100 |     }
101 |     int maxB=maximum(B,max+1);
102 |     while(maxB!=0){
103 |          for(int i=0;i<(max+1);i++){
104 |              if(B[i]==maxB){
105 |                  for(int j=0;j<(maxB);j++){
106 |                      printf("%d ",i);
107 |                  }
108 |              }
109 |         
110 |     }
111 |         maxB--;
112 |     }
113 |    
114 | }
115 | int main() {
116 |   int n;
117 |     scanf("%d",&n);
118 |     int A[n];
119 |     for(int i=0;i<n;i++){
120 |         scanf("%d",&A[i]);
121 |     }
122 |    hashing(A,n);
123 |     
124 | }
125 | ===============================================================================================================
126 | public class Solution {
127 |     public static void main(String args[] ) throws Exception {
128 |         Scanner sc = new Scanner(System.in);
129 |         int n = sc.nextInt();
130 |         HashMap<Integer,Integer> mp = new HashMap<>();
131 |         for(int i=0;i<n;i++){
132 |             int num = sc.nextInt();
133 |             if(mp.containsKey(num)) mp.put(num,mp.get(num)+1);
134 |             else mp.put(num,1);
135 |         }
136 |         
137 |         ArrayList<Map.Entry<Integer,Integer>> list = new ArrayList<>(mp.entrySet());
138 |         
139 |         Collections.sort(list, new Comparator <Map.Entry<Integer,Integer>>(){
140 |             
141 |             public int compare(Map.Entry<Integer,Integer> o1, Map.Entry<Integer,Integer> o2){
142 |                 return o2.getValue().compareTo(o1.getValue());
143 |             }
144 |         });
145 |         
146 |         HashMap<Integer,Integer> map = new HashMap<>();
147 |         
148 |         for(Map.Entry<Integer,Integer> lst : list){
149 |             map.put(lst.getKey(),lst.getValue());
150 |             for(int i=0;i<lst.getValue();i++) System.out.print(lst.getKey()+" ");
151 |         }       
152 |     }
153 | }
154 | =================================================================================================
155 | class Pair{
156 |         int val;
157 |         int count;
158 |         
159 |         Pair(int val , int count){
160 |             this.val = val;
161 |             this.count = count;
162 |         }
163 |     }
164 | 
165 | public class Solution {
166 |     
167 |     public static void main(String args[] ) throws Exception {
168 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT */
169 |         
170 |         Scanner sc = new Scanner(System.in);
171 |         int n = sc.nextInt();
172 |         
173 |         int arr[] = new int[n];
174 |         
175 |         for(int i =  0 ; i < n ; i++){
176 |             arr[i] = sc.nextInt();
177 |         }
178 |         
179 |         Map<Integer , Integer> map = new HashMap<>();
180 |         
181 |         for(int i : arr){
182 |             map.put(i , map.getOrDefault(i,0)+1);
183 |         }
184 |         //System.out.println(Arrays.toString(arr));
185 |         PriorityQueue<Pair> q = new PriorityQueue<>((a,b) -> a.count != b.count ? b.count - a.count : a.val-b.val);
186 |         
187 |         for(int i : map.keySet()){
188 |           //  System.out.println(i + " " + map.get(i));
189 |             q.add(new Pair(i , map.get(i)));
190 |         }
191 |         //System.out.println(q);
192 |         
193 |         while(!q.isEmpty()){
194 |             Pair v = q.poll();
195 |             for(int i = 0 ; i < v.count ; i++){
196 |                 System.out.print(v.val + " ");
197 |             }
198 |         }
199 |     }
200 | }
201 | ==========================================================================================================
202 | public class Solution {
203 |     public static void main(String args[] ) throws Exception {
204 |         Scanner s = new Scanner(System.in);
205 |         
206 |         int n = s.nextInt();
207 |         int arr[] = new int[n];
208 |         
209 |         Map<Integer, Integer> map = new HashMap<>();
210 |         List<Integer> res = new ArrayList<>();
211 |         
212 |         for(int i=0; i<n; i++){
213 |             arr[i] = s.nextInt();    
214 |         }
215 |         
216 |         for(int i=0; i<n; i++){
217 |             if(!map.containsKey(arr[i])){
218 |                map.put(arr[i], 1); 
219 |             }
220 |             else{
221 |                 map.put(arr[i], map.get(arr[i]) + 1);
222 |             }
223 |             if(!res.contains(map.get(arr[i]))){
224 |                 res.add(map.get(arr[i]));
225 |             }
226 |         }
227 |         
228 |         
229 |         for(int i=res.size()-1; i>=0; i--){
230 |             int ele = res.get(i);
231 |             for(Map.Entry<Integer, Integer> k : map.entrySet()){
232 |                 if(k.getValue() == ele){
233 |                     for(int z=0; z<ele; z++){
234 |                         System.out.print(k.getKey() + " ");
235 |                     }
236 |                 }
237 |             }
238 |         }    
239 |     }
240 | }
241 | ====================================================================================
242 | int main() {
243 |     int n;
244 |     cin >> n;
245 |     vector<int> arr(n);
246 |     for(int i=0; i<n; i++)
247 |         cin >> arr[i];
248 |     map<int, int> freq;
249 |     for(int i: arr)
250 |         freq[i]++;
251 |     int m = freq.size();
252 |     vector<int> num;
253 |     for(auto i: freq) {
254 |         num.push_back(i.first);
255 |     }
256 |     for(int i=0; i<m; i++) {
257 |         for(int j=i+1; j<m; j++) {
258 |             if(freq[num[i]] < freq[num[j]]) {
259 |                 int temp = num[i];
260 |                 num[i] = num[j];
261 |                 num[j] = temp;
262 |             } else if(freq[num[i]] == freq[num[j]]) {
263 |                 if(num[i] > num[j]) {
264 |                     int temp = num[i];
265 |                     num[i] = num[j];
266 |                     num[j] = temp;
267 |                 }
268 |             }
269 |         }
270 |     }
271 |     for(int i: num) {
272 |         for(int j=0; j<freq[i]; j++)
273 |             cout << i << " ";
274 |     }
275 |     return 0;
276 | }
277 | ================================================================================
278 | import java.io.*;
279 | import java.util.*;
280 | import java.text.*;
281 | import java.math.*;
282 | import java.util.regex.*;
283 | 
284 | public class Solution {
285 |     public static void main(String args[] ) throws Exception {
286 |         Scanner s=new Scanner(System.in);
287 |         int a=s.nextInt();
288 |         int arr[]=new int[a];
289 |         HashMap<Integer,Integer> map=new HashMap<>();
290 |         for(int i=0;i<a;i++){
291 |             arr[i]=s.nextInt();
292 |             map.put(arr[i],map.getOrDefault(arr[i],0)+1);
293 |         }
294 |         PriorityQueue<int[]> pq=new PriorityQueue<>((x,y)->x[1]==y[1]?x[0]-y[0]:y[1]-x[1]);
295 |         for(Map.Entry<Integer,Integer> hm:map.entrySet()){
296 |             pq.offer(new int[]{hm.getKey(),hm.getValue()});
297 |         }
298 |         while(!pq.isEmpty()){
299 |             int ar[]=pq.poll();
300 |             for(int i=0;i<ar[1];i++){
301 |                 System.out.print(ar[0]+" ");
302 |             }
303 |         }
304 |     }
305 | }
306 | ======================================================================================
307 | import java.io.*;
308 | import java.util.*;
309 | import java.text.*;
310 | import java.math.*;
311 | import java.util.regex.*;
312 | 
313 | public class Solution {
314 |     public static void main(String args[] ) throws Exception {
315 |         HashMap<Integer,Integer> map = new  HashMap<>();
316 |         Scanner s = new Scanner(System.in);
317 |         int n=s.nextInt();
318 |         int a[]=new int[n];
319 |         for(int i=0;i<n;i++)
320 |         {
321 |             a[i]=s.nextInt();
322 |         }
323 |         Arrays.sort(a);
324 |         for(int i=0;i<n;i++)
325 |         {
326 |             map.put(a[i],map.getOrDefault(a[i],0)+1);
327 |         }
328 |         
329 |         List<Integer> list = new ArrayList<>();
330 |         for(int num:a)
331 |         {
332 |             list.add(num);
333 |         }
334 |         
335 |         Collections.sort(list,(b,c)->{
336 |             int freq=map.get(c)-map.get(b);
337 |             if(freq==0)
338 |             {
339 |                 return b-c;
340 |             }
341 |             return freq;
342 |         });
343 |         for(int num:list)
344 |         {
345 |             System.out.print(num+" ");
346 |         }
347 |     }
348 | }
349 | ==================================================================
350 | import java.io.*;
351 | import java.util.*;
352 | import java.text.*;
353 | import java.math.*;
354 | import java.util.regex.*;
355 | 
356 | public class Solution {
357 |     public static void main(String args[] ) throws Exception {
358 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT */
359 |         Scanner obj=new Scanner(System.in);
360 |         int a=obj.nextInt();
361 |         int arr[]=new int[a];
362 |         for(int i=0;i<a;i++)
363 |         {
364 |             arr[i]=obj.nextInt();
365 |         }
366 |         HashMap<Integer,Integer>hm=new HashMap<>();
367 |         for(int i=0;i<a;i++)
368 |         {
369 |             if(hm.containsKey(arr[i]))
370 |             {
371 |                 hm.put(arr[i],hm.get(arr[i])+1);
372 |             }
373 |             else
374 |             hm.put(arr[i],1);
375 |         }
376 |         for(int i=0;i<a;i++)
377 |         {
378 |             for(int j=i+1;j<a;j++)
379 |             {
380 |                 int f1=hm.get(arr[i]);
381 |                 int f2=hm.get(arr[j]);
382 |                 if(f1<f2||(f1==f2&&arr[j]<arr[i]))
383 |                 {
384 |                     int temp=arr[i];
385 |                     arr[i]=arr[j];
386 |                     arr[j]=temp;
387 |                 }
388 |             }
389 |             
390 |         }
391 |         for(int ch:arr)
392 |         {
393 |             System.out.print(ch+" ");
394 |         }
395 |     }
396 | }
397 | 


--------------------------------------------------------------------------------
/Sort and Sum alternatively:
--------------------------------------------------------------------------------
  1 | Write a Program to sort alternatively and print the elements after sum even index's elements.
  2 | 
  3 | Input Format
  4 | 
  5 | 7
  6 | 5 2 8 7 4 3 9
  7 | 
  8 | Constraints
  9 | 
 10 | 4<=n<=10
 11 | 
 12 | Output Format
 13 | 
 14 | 9 2 8 3 7 4 5
 15 | 9
 16 | 
 17 | Sample Input 0
 18 | 
 19 | 5
 20 | 4 2 5 1 3
 21 | Sample Output 0
 22 | 
 23 | 5 1 4 2 3
 24 | 3
 25 | =======================================================================================================================================================================================================
 26 | single array
 27 | #include <stdio.h>
 28 | #include <string.h>
 29 | #include <math.h>
 30 | #include <stdlib.h>
 31 | 
 32 | int main() {
 33 | 
 34 |     int n,i,j,sum=0;
 35 |     scanf("%d",&n);
 36 |     int a[n];
 37 |     for(i=0;i<n;i++)
 38 |         scanf("%d",&a[i]);
 39 |     for(i=0;i<n-1;i++)
 40 |     {
 41 |         for(j=i+1;j<n;j++)
 42 |         {
 43 |             if(a[i]>a[j])
 44 |             {
 45 |                 int temp=a[i];
 46 |                 a[i]=a[j];
 47 |                 a[j]=temp;
 48 |             }
 49 |         }
 50 |     }
 51 |     int l=0,r=n-1;
 52 |     while(l<r)
 53 |     {
 54 |         printf("%d ",a[r]);
 55 |         printf("%d ",a[l]);
 56 |         sum=sum+a[l];
 57 |         l++;
 58 |         r--;
 59 |     }
 60 |     if(n%2!=0)
 61 |         printf("%d ",a[l]);
 62 |     printf("\n%d",sum);
 63 | }
 64 | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 65 | 2 array
 66 | #include <stdio.h>
 67 | #include <string.h>
 68 | #include <math.h>
 69 | #include <stdlib.h>
 70 | 
 71 | int main() {
 72 | 
 73 |     int n,i,j,sum=0;
 74 |     scanf("%d",&n);
 75 |     int a[n];
 76 |     int b[n];
 77 |     for(i=0;i<n;i++)
 78 |         scanf("%d",&a[i]);
 79 |     for(i=0;i<n-1;i++)
 80 |     {
 81 |         for(j=i+1;j<n;j++)
 82 |         {
 83 |             if(a[i]>a[j])
 84 |             {
 85 |                 int temp=a[i];
 86 |                 a[i]=a[j];
 87 |                 a[j]=temp;
 88 |             }
 89 |         }
 90 |     }
 91 |     int l=0,r=n-1,c=0;
 92 |     while(l<r)
 93 |     {
 94 |         b[c++]=a[r];
 95 |         b[c++]=a[l];
 96 |         l++;
 97 |         r--;
 98 |     }
 99 |     if(n%2!=0)
100 |         b[c]=a[l];
101 |     
102 |     for(i=0;i<n;i++)
103 |         printf("%d ",b[i]);
104 |     
105 |     i=1;
106 |     while(i<n)
107 |     {
108 |         sum=sum+b[i];
109 |         i=i+2;
110 |     }
111 |     printf("\n%d",sum);
112 | }
113 | 


--------------------------------------------------------------------------------
/Sort array alternately:
--------------------------------------------------------------------------------
 1 | Sort the array alternately i.e first element should be max value, second min value,
 2 | third second max, third second min
 3 | 
 4 | Input Format
 5 | 
 6 | 7
 7 | 1 2 3 4 5 6 7
 8 | 
 9 | Constraints
10 | 
11 | 5<=n<=20
12 | 
13 | Output Format
14 | 
15 | 7 1 6 2 5 3 4
16 | 
17 | Sample Input 0
18 | 
19 | 7
20 | 1 2 3 4 5 6 7
21 | Sample Output 0
22 | 
23 | 7 1 6 2 5 3 4
24 | -----------------------------------------------------------------------------------------------------------------------------------
25 | #include <stdio.h>
26 | #include <string.h>
27 | #include <math.h>
28 | #include <stdlib.h>
29 | 
30 | int main() {
31 | 
32 |     int n,i,j;
33 |     scanf("%d",&n);
34 |     int a[n];
35 |     for(i=0;i<n;i++)
36 |         scanf("%d",&a[i]);
37 |     for(i=0;i<n-1;i++)
38 |     {
39 |         for(j=i+1;j<n;j++)
40 |         {
41 |             if(a[i]>a[j])
42 |             {
43 |                 int temp=a[i];
44 |                 a[i]=a[j];
45 |                 a[j]=temp;
46 |             }
47 |         }
48 |     }
49 |     int l=0,r=n-1;
50 |     while(l<r)
51 |     {
52 |         printf("%d ",a[r]);
53 |         printf("%d ",a[l]);
54 |         l++;
55 |         r--;
56 |     }
57 |     if(n%2!=0)
58 |         printf("%d",a[l]);
59 | }
60 | 


--------------------------------------------------------------------------------
/Sorting array elements by frequency:
--------------------------------------------------------------------------------
 1 | Need to write a program to sort the given array based on frequency of elements.
 2 | 
 3 | Input Format
 4 | 
 5 | 12
 6 | 3 2 3 2 4 2 3 5 3 7 5 1
 7 | 
 8 | Constraints
 9 | 
10 | 6<=n<=20
11 | 
12 | Output Format
13 | 
14 | 3 3 3 3 2 2 2 5 5 4 7 1
15 | 
16 | Sample Input 0
17 | 
18 | 7
19 | 3 4 7 6 3 4 4
20 | Sample Output 0
21 | 
22 | 4 4 4 3 3 7 6
23 | Explanation 0
24 | 
25 | Highest frequency element will come first and next frequency element will come next and so on. Other elements will come in the same order which presents in the given array.
26 | 
27 | Sample Input 1
28 | 
29 | 7
30 | 2 5 3 2 5 5 1
31 | Sample Output 1
32 | 
33 | 5 5 5 2 2 3 1
34 | -------------------------------------------------------------------------------------------------------------------------------------
35 | #include <stdio.h>
36 | #include <string.h>
37 | #include <math.h>
38 | #include <stdlib.h>
39 | 
40 | int maximum(int A[],int n)
41 | {
42 |     int max=A[0];
43 |     for(int i=0;i<n;i++)
44 |     {
45 |         if(max<A[i])
46 |         {
47 |             max=A[i];
48 |         }
49 |     }
50 |     return max;
51 | }
52 | int main() {
53 |     int n;
54 |     scanf("%d",&n);
55 |     int A[n];
56 |     for(int i=0;i<n;i++)
57 |     {
58 |         scanf("%d",&A[i]);
59 |     }
60 |     int max=maximum(A,n);
61 |     int B[max+1];
62 |     for(int i=0;i<(max+1);i++)
63 |     {
64 |         B[i]=0;
65 |     }
66 |     for(int i=0;i<n;i++)
67 |     {
68 |         int k=A[i];
69 |         B[k]++;
70 |     }
71 |    int y=maximum(B,(max+1));
72 |     while(y!=0)
73 |     {
74 |         for(int i=0;i<n;i++)
75 |         {
76 |             int h=A[i];
77 |             if(B[h]==y)
78 |             {  
79 |                 for(int j=0;j<y;j++){
80 |                              printf("%d ",h);
81 |                 }
82 |             B[h]=0;
83 |             }
84 |         }
85 |         y--;
86 |     }
87 |     return 0;
88 | }
89 | 


--------------------------------------------------------------------------------
/Sorting in max and min order:
--------------------------------------------------------------------------------
 1 | Write a program to print
 2 | 
 3 | Input Format
 4 | 
 5 | 7 13 2 4 15 12 10 5
 6 | 
 7 | Constraints
 8 | 
 9 | 1<=elements<=20
10 | 
11 | Output Format
12 | 
13 | 15 2 13 4 12 5 10
14 | 
15 | Sample Input 0
16 | 
17 | 5
18 | 1 5 6 2 8
19 | Sample Output 0
20 | 
21 | 8 1 6 2 5
22 | 
23 | ====================================================================================
24 | #include <stdio.h>
25 | #include <string.h>
26 | #include <math.h>
27 | #include <stdlib.h>
28 | 
29 | int main() {
30 | 
31 |     int n,i,j;
32 |     scanf("%d",&n);
33 |     int a[n];
34 |     for(i=0;i<n;i++)
35 |         scanf("%d",&a[i]);
36 |     for(i=0;i<n-1;i++)
37 |     {
38 |         for(j=i+1;j<n;j++)
39 |         {
40 |             if(a[i]>a[j])
41 |             {
42 |                 int temp=a[i];
43 |                 a[i]=a[j];
44 |                 a[j]=temp;
45 |             }
46 |         }
47 |     }
48 |     int l=0,r=n-1;
49 |     while(l<r)
50 |     {
51 |         printf("%d ",a[r]);
52 |         printf("%d ",a[l]);
53 |         l++;
54 |         r--;
55 |     }
56 |     if(n%2!=0)
57 |         printf("%d",a[l]);
58 | }
59 | 


--------------------------------------------------------------------------------
/Square Numbers 1:
--------------------------------------------------------------------------------
 1 | Given two numbers a and b both we have to find the square numbers which lie
 2 | between a and b(inclusive)
 3 | 
 4 | Input Format
 5 | 
 6 | 20
 7 | 100
 8 | 
 9 | Constraints
10 | 
11 | 20<=a<=200
12 | 20<=b<=200
13 | 
14 | Output Format
15 | 
16 | 25 36 49 64 81 100
17 | 
18 | Sample Input 0
19 | 
20 | 30
21 | 90
22 | Sample Output 0
23 | 
24 | 36 49 64 81
25 | ==================================================================================
26 | #include <stdio.h>
27 | #include <string.h>
28 | #include <math.h>
29 | #include <stdlib.h>
30 | 
31 | int main() {
32 | 
33 |     int n,m,ans;
34 |     scanf("%d%d",&n,&m);
35 |    for(int i=5;i<=14;i++)
36 |    {
37 |        ans=i*i;
38 |        if(ans>=n&&ans<=m)
39 |            printf("%d ",ans);
40 |    }
41 | }
42 | 


--------------------------------------------------------------------------------
/Sum of Two numbers 46:
--------------------------------------------------------------------------------
  1 | Given 2 huge numbers as separate digits, store them in array and process them and
  2 | calculate the sum of 2 numbers and store the result in an array and print the sum.
  3 | 
  4 | Input Format
  5 | 
  6 | 12
  7 | 9 2 8 1 3 5 6 7 3 1 1 6
  8 | 9
  9 | 7 8 4 6 2 1 9 9 7
 10 | 
 11 | Constraints
 12 | 
 13 | 5<=n<=20
 14 | 
 15 | Output Format
 16 | 
 17 | 9 2 8 9 2 0 2 9 5 1 1 3
 18 | 
 19 | Sample Input 0
 20 | 
 21 | 5
 22 | 1 2 3 4 5
 23 | 4
 24 | 6 7 8 9
 25 | Sample Output 0
 26 | 
 27 | 1 9 1 3 4
 28 | Explanation 0
 29 | 
 30 | You will have to add these two array as like below: 12345+ 6789= 19134
 31 | 
 32 | ------------------------------------------------------------------------------------------------------
 33 | #include <stdio.h>
 34 | #include <string.h>
 35 | #include <math.h>
 36 | #include <stdlib.h>
 37 | 
 38 | int main() {
 39 | 
 40 |     int n,m,i,j;
 41 | 
 42 |     long long int num1=0,num2=0,sum=0,s,c=0;
 43 | 
 44 |     scanf("%d",&n);
 45 | 
 46 |     int a[n];
 47 | 
 48 |     for(i=0;i<n;i++)
 49 | 
 50 |         scanf("%d",&a[i]);
 51 | 
 52 |     scanf("%d",&m);
 53 | 
 54 |     int b[m];
 55 | 
 56 |     for(i=0;i<m;i++)
 57 | 
 58 |         scanf("%d",&b[i]);
 59 | 
 60 |     for(i=0;i<n;i++)
 61 | 
 62 |     {
 63 | 
 64 |         num1=num1*10+a[i];
 65 | 
 66 |     }
 67 | 
 68 |     for(i=0;i<m;i++)
 69 | 
 70 |     {
 71 | 
 72 |         num2=num2*10+b[i];
 73 | 
 74 |     }
 75 | 
 76 |     sum=num1+num2;
 77 | 
 78 |     s=sum;
 79 | 
 80 |     while(s>0)
 81 | 
 82 |     {
 83 | 
 84 |         c++;
 85 | 
 86 |         s/=10;
 87 | 
 88 |     }
 89 | 
 90 |     int r[c];
 91 | 
 92 |     j=c-1;
 93 | 
 94 |     while(sum>0)
 95 | 
 96 |     {
 97 | 
 98 |         r[j]=sum%10;
 99 | 
100 |         j--;
101 | 
102 |         sum/=10;
103 | 
104 |     }
105 | 
106 |     for(i=0;i<c;i++)
107 | 
108 |         printf("%d ",r[i]);
109 | 
110 |     return 0;
111 | 
112 | }
113 | 


--------------------------------------------------------------------------------
/Sum of all elements 1:
--------------------------------------------------------------------------------
 1 | Need to write a program to sum of all elements
 2 | 
 3 | Input Format
 4 | 
 5 | 6
 6 | 1 2 3 4 5 6
 7 | 
 8 | Constraints
 9 | 
10 | 1<=n<=20
11 | 
12 | Output Format
13 | 
14 | 21
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | 4 3 2 1 5
20 | Sample Output 0
21 | 
22 | 15
23 | ------------------------------------------------------------------
24 | #include<stdio.h>
25 | int main() {
26 |     int n,i,sum=0;
27 |     scanf("%d",&n);
28 |     int a[n];
29 |     for(i=0;i<n;i++)
30 |     {
31 |         scanf("%d",&a[i]);
32 |         sum=sum+a[i];
33 |     }
34 |     printf("%d",sum);
35 | }
36 |   -----------------------------------------------------------------------------------
37 | import java.io.*;
38 | import java.util.*;
39 | 
40 | public class Solution {
41 | 
42 |     public static void main(String[] args) {
43 |         Scanner z=new Scanner(System.in);
44 |         int n,sum=0;
45 |         n=z.nextInt();
46 |         int a[]=new int[n];
47 |         for(int i=0;i<n;i++)
48 |         {
49 |             a[i]=z.nextInt();
50 |             sum=sum+a[i];
51 |         }
52 |         
53 |         System.out.print(sum+" ");
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/Swap array elements:
--------------------------------------------------------------------------------
  1 | Need to write a program to swap the elements of the array to the given input.
  2 | 
  3 | Input Format
  4 | 
  5 | 8 3 2 4 5 7 8 6 1 2
  6 | 
  7 | Constraints
  8 | 
  9 | 5<=n<=20
 10 | 
 11 | Output Format
 12 | 
 13 | 6 1 4 5 7 8 3 2
 14 | 
 15 | Sample Input 0
 16 | 
 17 | 7
 18 | 4 5 6 3 2 1 8
 19 | 1
 20 | Sample Output 0
 21 | 
 22 | 8 5 6 3 2 1 4
 23 | Sample Input 1
 24 | 
 25 | 10
 26 | 1 2 3 4 5 6 7 8 9 1
 27 | 2
 28 | Sample Output 1
 29 | 
 30 | 9 1 3 4 5 6 7 8 1 2
 31 | -----------------------------------------------------------------------------------------------------------------------
 32 | #include <stdio.h>
 33 | #include <string.h>
 34 | #include <math.h>
 35 | #include <stdlib.h>
 36 | 
 37 | int main() {
 38 | 
 39 |     int n,i;
 40 |     scanf("%d",&n);
 41 |     int a[n];
 42 |     for(i=0;i<n;i++)
 43 |         scanf("%d",&a[i]);
 44 |     int key;
 45 |     scanf("%d",&key);
 46 |     int t=n-key;
 47 |     for(i=0;i<key;i++)
 48 |     {
 49 |         int temp=a[i];
 50 |         a[i]=a[t];
 51 |         a[t]=temp;
 52 |         t++;
 53 |     }
 54 |     for(i=0;i<n;i++)
 55 |     printf("%d ",a[i]);
 56 | }
 57 | -----------------------------------------------------------------------------------------------------------------------------------------
 58 | #include <stdio.h>
 59 | #include <string.h>
 60 | #include <math.h>
 61 | #include <stdlib.h>
 62 | 
 63 |    void swapElement(int a[],int n,int k){
 64 | 
 65 |     for(int i=0,j=n-k;i<n && j<n;i++,j++){
 66 | 
 67 |         int temp=a[i];
 68 | 
 69 |         a[i]=a[j];
 70 | 
 71 |         a[j]=temp;
 72 | 
 73 |     }
 74 | 
 75 |     for(int i=0;i<n;i++){
 76 | 
 77 |         printf("%d ",a[i]);
 78 | 
 79 |     }
 80 | 
 81 | }
 82 | 
 83 | int main() {
 84 | 
 85 |     int n;
 86 | 
 87 |     scanf("%d",&n);
 88 | 
 89 |     int a[n];
 90 | 
 91 |     for(int i=0;i<n;i++){
 92 | 
 93 |         scanf("%d",&a[i]);
 94 | 
 95 |     }
 96 | 
 97 |     int k;
 98 | 
 99 |     scanf("%d",&k);
100 | 
101 |     swapElement(a,n,k);
102 | 
103 |     return 0;
104 | }
105 | 


--------------------------------------------------------------------------------
/Union of Two Array:
--------------------------------------------------------------------------------
 1 | Find the union intersection of two array.
 2 | 
 3 | Input Format
 4 | 
 5 | 7
 6 | 5
 7 | 1 3 4 5 6 8 9
 8 | 1 5 8 9 2
 9 | 
10 | Constraints
11 | 
12 | 4<=n<=10
13 | 
14 | Output Format
15 | 
16 | 1 3 4 5 6 8 9 2
17 | 
18 | Sample Input 0
19 | 
20 | 5
21 | 3
22 | 3 6 2 7 6
23 | 8 9 5
24 | Sample Output 0
25 | 
26 | 3 6 2 7 8 9 5
27 | ------------------------------------------------------------------------------------------------------------------------
28 | #include <stdio.h>
29 | #include <string.h>
30 | #include <math.h>
31 | #include <stdlib.h>
32 | 
33 | int main() {
34 | int a,b,i,j,k;
35 |     scanf("%d%d",&a,&b);
36 |     int arr[a],arr1[b];
37 |     int n=a+b;
38 |     int c[n];
39 |     for(i=0;i<a;i++)
40 |         scanf("%d",&arr[i]);
41 |     
42 |     for(i=0;i<b;i++)
43 |         scanf("%d",&arr1[i]);
44 | 
45 |     for(i=0;i<a;i++)
46 |         c[i]=arr[i];
47 |     for(j=0;j<b;j++)
48 |         c[i++]=arr1[j];
49 | 
50 |     for(i=0;i<n;i++)
51 |     {
52 |         for(j=i+1;j<n;j++)
53 |         {
54 |             if(c[i]==c[j])
55 |             {
56 |                 for(k=j;k<n;k++)
57 |                 {
58 |                     c[k]=c[k+1];
59 |                 }
60 |                 n--;
61 |                 j--;
62 |             }
63 |         }
64 |     }
65 |     for(int i=0;i<n;i++)
66 |         printf("%d ",c[i]);
67 |     return 0;
68 | 
69 | }
70 | 


--------------------------------------------------------------------------------
/first half in ascending order and second half in descending order:
--------------------------------------------------------------------------------
 1 | Sort the array first half in ascending order and second half in descending order.
 2 | 
 3 | Input Format
 4 | 
 5 | 8
 6 | 4 5 3 7 1 2 3 4
 7 | 
 8 | Constraints
 9 | 
10 | 5<=n<=20
11 | 
12 | Output Format
13 | 
14 | 3 4 5 7 4 3 2 1
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | 3 2 1 4 5
20 | Sample Output 0
21 | 
22 | 1 2 3 5 4
23 | -------------------------------------------------------------------------------
24 | int main() {
25 | 
26 |     int n,i,j;
27 |     scanf("%d",&n);
28 |     int a[n];
29 |     for(i=0;i<n;i++)
30 |         scanf("%d",&a[i]);
31 |     
32 |     int half=ceil(n/2.0);
33 |     for(i=half;i<n-1;i++)
34 |     {
35 |         for(j=i+1;j<n;j++)
36 |         if(a[i]<a[j])
37 |         {
38 |             int temp=a[i];
39 |             a[i]=a[j];
40 |             a[j]=temp;
41 |         }
42 |     }
43 |     half=n/2;
44 |         for(i=0;i<half;i++)
45 |         {
46 |         for(j=i+1;j<=half;j++)
47 |         {
48 |         if(a[i]>a[j])
49 |         {
50 |             int temp=a[i];
51 |             a[i]=a[j];
52 |             a[j]=temp;
53 |         }
54 |         }
55 |     }
56 |         for(i=0;i<n;i++)
57 |             printf("%d ",a[i]);
58 |     
59 |     
60 |     return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/merge two array and sort:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <limits.h>
 3 | 
 4 | int sort(int a[],int n)
 5 | {
 6 |     int t,i,j;
 7 |     for(i=0;i<n-1;i++)
 8 |       {
 9 |           for(j=i+1;j<n;j++)
10 |            {
11 |                if(a[i]>a[j])
12 |                {
13 |                    t=a[i];
14 |                    a[i]=a[j];
15 |                    a[j]=t;
16 |                }
17 |            }
18 |       }
19 |       for(i=0;i<n;i++)
20 |        printf("%d ",a[i]);
21 | }
22 | int merge(int a[],int b[],int n1,int n2)
23 | {
24 |  int i,j;
25 |  int n3=n1+n2;
26 |  int c[n3];
27 |  for(i=0;i<n1;i++)
28 |   c[i]=a[i];
29 |  for(j=0;j<n2;j++)
30 |   c[i++]=b[j];
31 |  sort(c,n3);
32 | }
33 | int main()
34 | {
35 |   int n1,i;
36 |     scanf("%d",&n1);
37 |     int a[n1];
38 |     for(i=0;i<n1;i++)
39 |      scanf("%d",&a[i]);
40 |     int n2;
41 |     scanf("%d",&n2);
42 |     int b[n2];
43 |     for(i=0;i<n2;i++)
44 |      scanf("%d",&b[i]);
45 |     merge(a,b,n1,n2);
46 | 
47 | }
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/minimum of all the greater numbers:
--------------------------------------------------------------------------------
 1 | Given an array, find the minimum of all the greater numbers for each element in the
 2 | array.
 3 | 
 4 | Input Format
 5 | 
 6 | 7
 7 | 2 3 7 -1 8 5 11
 8 | 
 9 | Constraints
10 | 
11 | 4<=n<=10
12 | 
13 | Output Format
14 | 
15 | 2->3, 3->5, 7->8, -1->2, 8->11, 5->7, 11->,
16 | 
17 | Sample Input 0
18 | 
19 | 6
20 | 5 4 3 7 6 1
21 | Sample Output 0
22 | 
23 | 5->6, 4->5, 3->4, 7->, 6->7, 1->3,
24 | 
25 | =====================================================================================================================
26 | #include <stdio.h>
27 | #include <string.h>
28 | #include <math.h>
29 | #include <stdlib.h>
30 | #include <limits.h>
31 | int maxi(int a[],int n,int key)
32 | {   int min=INT_MAX;
33 |     for(int i=0;i<n;i++)
34 |     {
35 |         if(a[i]>key && a[i]<min)
36 |             min=a[i];
37 |     }
38 |  return min;
39 | }
40 | int main() {
41 |     
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=0;i<n;i++)
48 |     {
49 |         int max=maxi(a,n,a[i]);
50 |         if(max != INT_MAX)
51 |             printf("%d->%d, ",a[i],max);
52 |         else
53 |             printf("%d->, ",a[i]);
54 |     }
55 |     return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/missing Number:
--------------------------------------------------------------------------------
 1 | Given an array nums containing n distinct numbers in the range [0, n], return the only number in the range that is missing from the array.
 2 | 
 3 |  
 4 | 
 5 | Example 1:
 6 | 
 7 | Input: nums = [3,0,1]
 8 | Output: 2
 9 | Explanation: n = 3 since there are 3 numbers, so all numbers are in the range [0,3]. 2 is the missing number in the range since it does not appear in nums.
10 | Example 2:
11 | 
12 | Input: nums = [0,1]
13 | Output: 2
14 | Explanation: n = 2 since there are 2 numbers, so all numbers are in the range [0,2]. 2 is the missing number in the range since it does not appear in nums.
15 | Example 3:
16 | 
17 | Input: nums = [9,6,4,2,3,5,7,0,1]
18 | Output: 8
19 | Explanation: n = 9 since there are 9 numbers, so all numbers are in the range [0,9]. 8 is the missing number in the range since it does not appear in nums.
20 |  
21 | 
22 | Constraints:
23 | 
24 | n == nums.length
25 | 1 <= n <= 104
26 | 0 <= nums[i] <= n
27 | All the numbers of nums are unique.
28 |  
29 | 
30 | Follow up: Could you implement a solution using only O(1) extra space complexity and O(n) runtime complexity?
31 | ==============================================================================================================================================
32 | class Solution {
33 |     public int missingNumber(int[] nums) {
34 |         int n=nums.length;
35 |         Arrays.sort(nums);
36 |         int j;
37 |         for(int i=0;i<n;i++)
38 |         {
39 |             for(j=0;j<n;j++)
40 |             {
41 |                 if(i==nums[i])
42 |                 break;
43 |             }
44 |             if(j==n)
45 |             return i;
46 |         }
47 |     return n;     
48 |     }
49 | }
50 | ==============================================================================================================================================
51 | class Solution {
52 |     public int missingNumber(int[] nums) {
53 |         int n=nums.length;
54 |         int ans=(n*(n+1))/2;
55 |         int sum=0;
56 |         for(int i:nums)
57 |             sum=sum+i;
58 |         return (ans-sum);   
59 |     }
60 | }
61 | =====================================================================================
62 | class Solution {
63 |     public int missingNumber(int[] nums) {
64 |         int n=nums.length;
65 |         Arrays.sort(nums);
66 |         for(int i=0;i<n;i++)
67 |         {
68 |             if(i!=nums[i])
69 |             {
70 |                 return i;
71 |                 
72 |             }
73 |         }
74 |     return n;     
75 |     }
76 | }
77 | =====================================================================
78 | 


--------------------------------------------------------------------------------
/without n how to take array elements:
--------------------------------------------------------------------------------
 1 | public class Main {
 2 |         public static void main(String[] args) 
 3 |     {
 4 |         
 5 |         Scanner sc=new Scanner(System.in);
 6 |             Scanner z=new Scanner(System.in);
 7 |         String[] j= z.nextLine().split(" ");
 8 |             for(String i:j)
 9 |         System.out.println(Integer.valueOf(i));
10 |         }
11 | }
12 | ----------------------------------------------------------------------------------------------------
13 | 
14 | 
15 | 
16 | public class Main {
17 |         public static void main(String[] args) 
18 |     {
19 |         
20 |         Scanner sc=new Scanner(System.in);
21 |         String str=sc.nextLine();
22 |         String [] j=str.split(" ");
23 |             for(String i:j)
24 |         System.out.println(Integer.valueOf(i));
25 |         }
26 | }
27 | ===========================================================
28 | public class Main {
29 |         public static void main(String[] args) 
30 |     {
31 |         
32 |         Scanner z=new Scanner(System.in);
33 |         while(z.hasNextInt());
34 |             int data=z.nextInt();
35 |     }
36 | }
37 | =====================================================
38 | 


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