├── A sparse matrix.cpp
├── Binary search on array.py
├── Check Armstrong number.cpp
├── Check bit.cpp
├── Compress a string.py
├── Compute N!.cpp
├── Compute a power b.cpp
├── Compute area of rectangle.cpp
├── Compute fibonacci number.cpp
├── Count vowels and consonants.cpp
├── Cubes sum.cpp
├── Digits in a string.cpp
├── Digits sum.py
├── Find duplicate element in array.cpp
├── Harshad numbers.cpp
├── Hollow rectangle pattern.cpp
├── Inverted pyramid pattern.cpp
├── LICENSE
├── Letter repetition.cpp
├── Letters of the alphabet.cpp
├── Linear search on array.py
├── Long factorial.cpp
├── Matrix Row Sum.cpp
├── Matrix column sum.cpp
├── Max element in the array.cpp
├── Narcissistic numbers.cpp
├── Natural numbers sum.cpp
├── Number of multiples.cpp
├── Number reverse.cpp
├── Occurrence of a character.cpp
├── Odd even index.cpp
├── Palindromic right-angled triangle pattern.cpp
├── Prime or not.cpp
├── Print half diamond pattern.cpp
├── Print multiplication table.cpp
├── Print pyramid pattern.cpp
├── Print unique elements of array.cpp
├── README.md
├── Rectangle pattern.cpp
├── Reverse array.cpp
├── Reverse string.cpp
├── Right-angled triangle pattern 1.cpp
├── Right-angled triangle pattern 2.cpp
├── Squares sum.cpp
├── Sum of all odd elements.cpp
├── Sum of two matrices.cpp
├── The missing number.cpp
├── Toggle case of characters.cpp
├── Transpose matrix.cpp
├── Triangle validator.cpp
└── Vowels in a string.cpp


/A sparse matrix.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a matrix of size N x M, print whether it is a sparse matrix or not.
 3 | Note: If a matrix contain 0 in more than half of its cells, then it is called a sparse matrix.
 4 | 
 5 | Input Format
 6 | 
 7 | First line of input contains N, M - size of the matrix. Its followed by N lines each containing M intergers - elements of the matrix.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= N, M <= 100
12 | 0 <= ar[i] <= 109
13 | 
14 | Output Format
15 | 
16 | Print "Yes" if the given matrix is a sparse matrix, otherwise print "No".
17 | 
18 | Sample Input 0
19 | 
20 | 2 3
21 | 5 0 0
22 | 0 8 0
23 | Sample Output 0
24 | 
25 | Yes
26 | 
27 | */
28 | #include <cmath>
29 | #include <cstdio>
30 | #include <vector>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
38 |     int N, M;
39 |     cin>>N>>M;
40 |     int A[N][M];
41 |     int s = 0;
42 |     for(int i=0; i<N; i++)
43 |     {
44 |         for(int j=0; j<M; j++)
45 |         {
46 |             cin>>A[i][j];
47 |             if(A[i][j] == 0)
48 |             {
49 |                 s++;
50 |             }
51 |         }
52 |     }
53 |  
54 |     if(s > (N*M)/2)
55 |     {
56 |         cout<<"Yes"<<endl;
57 |     }
58 |     else
59 |     {
60 |         cout<<"No";
61 |     }
62 |  
63 | 
64 | 
65 |     return 0;
66 | }
67 | 


--------------------------------------------------------------------------------
/Binary search on array.py:
--------------------------------------------------------------------------------
 1 | #Given an array of integers, search a given key in the array using binary search.
 2 | #Note: Do not use any inbuilt functions/libraries for your main logic.
 3 | #(Try to practice both iterative and recursive codes for Binary Search)
 4 | 
 5 | #Input Format
 6 | 
 7 | ##First line of input contains two integers, N - size of the array and K - search key. Second line contains the elements of the array.
 8 | 
 9 | #Constraints
10 | 
11 | #1 <= N <= 102
12 | #0 <= ar[i] <= 109
13 | 
14 | #Output Format
15 | 
16 | #Print "true" if key is present in the array, otherwise, print false.
17 | 
18 | #Sample Input 0
19 | 
20 | #5 19
21 | #2 19 23 35 38
22 | #Sample Output 0
23 | 
24 | #true
25 | #Explanation 0
26 | 
27 | #Self Explanatory
28 | n,k=map(int,input().split())
29 | arr=list(map(int,input().split()))
30 | l=0
31 | h=n-1
32 | 
33 | def BS(arr,l,h,k): 
34 |     if h>=l: 
35 |         mid=l+(h-l)//2
36 |         if arr[mid]==k: 
37 |             return mid 
38 |         elif arr[mid]>k: 
39 |             return BS(arr,l,mid-1,k) 
40 |         else: 
41 |             return BS(arr,mid+1,h,k) 
42 |     else: 
43 |         return -1
44 | result=BS(arr,0,n-1,k) 
45 | 
46 | if result!=-1: 
47 |     print("true") 
48 | else: 
49 |     print("false") 
50 | 


--------------------------------------------------------------------------------
/Check Armstrong number.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given an integer N, check whether it's an Armstrong number or not.
 3 | Note: Armstrong number is a number that is equal to the sum of cubes of its digits.
 4 | 
 5 | Input Format
 6 | 
 7 | First and only line of input contains a integer - N.
 8 | 
 9 | Constraints
10 | 
11 | 0 <= N <= 109
12 | 
13 | Output Format
14 | 
15 | Print "Yes" if the number is an Armstrong number, "No" otherwise.
16 | 
17 | Sample Input 0
18 | 
19 | 153
20 | Sample Output 0
21 | 
22 | Yes
23 | Explanation 0
24 | 
25 | 13 + 53 + 33 = 153
26 | */
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | using namespace std;
33 | 
34 | 
35 | int main() {
36 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
37 |     int N,s=0,r,q;
38 |     cin>>N;
39 |     q=N;
40 |     while(q>0){
41 |         r=q%10;
42 |         s=s+(r*r*r);
43 |         q=q/10;
44 |     }
45 |     if(s==N)
46 |         cout<<"Yes"<<endl;
47 |     else
48 |         cout<<"No"<<endl;
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/Check bit.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | In a given integer N, check whether the ith bit is set or not.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains N and i.
 7 | 
 8 | Constraints
 9 | 
10 | 0 <= N <= 109
11 | 0 <= i <= 30
12 | 
13 | Output Format
14 | 
15 | Print "true" if ith bit is set in the given integer N, "false" otherwise.
16 | 
17 | Sample Input 0
18 | 
19 | 10 1
20 | Sample Output 0
21 | 
22 | true
23 | Explanation 0
24 | 
25 | The binary form of 10 is: 1010. So the 1st bit in 10 is set. Note that LSB bit is referred as 0th bit.
26 | */
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | using namespace std;
33 | 
34 | 
35 | int main() {
36 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
37 |    int N,i;
38 |     int res;
39 |   cin>>N>>i;
40 |     res = (N >> (i));
41 |     if (res & 1)
42 |         printf("true\n");
43 |     else
44 |         printf("false\n");
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/Compress a string.py:
--------------------------------------------------------------------------------
 1 | #Given a string, compress the given string. See example for more details.
 2 | 
 3 | #Input Format
 4 | 
 5 | #Input contains a string S, consisting of lowercase and uppercase characters.
 6 | 
 7 | #Constraints
 8 | 
 9 | #1 <= len(S) <= 100
10 | 
11 | #Output Format
12 | 
13 | #Print the compressed string.
14 | 
15 | #Sample Input 0
16 | 
17 | #aaaBBBBhhhekkL
18 | #Sample Output 0
19 | 
20 | #a3B4h3e1k2L1
21 | #Explanation 0
22 | 
23 | #In the given string, a is repeating for 3 times continuosly. So after compression it becomes a3.
24 | #Similarly,
25 | #B is repeating for 4 times - B4
26 | #h is repeating for 3 times - h3
27 | #e is repeating for 1 times - e1
28 | #k is repeating for 2 times - k2
29 | #L is repeating for 1 times - L1
30 | string=str(input())
31 | ind = 0
32 | def compress(string):
33 |     global ind
34 |     cstr = ""
35 |     l = len(string)
36 |     while (ind != l):
37 |         count = 1
38 | 
39 |         while ((ind < (l-1)) and (string[ind] == string[ind+1])):
40 |             count = count + 1
41 |             ind = ind + 1
42 | 
43 |         
44 |         else:
45 |             cstr = cstr + str(string[ind]) + str(count)
46 | 
47 |         ind += 1
48 | 
49 |     return cstr
50 |       
51 | print(compress(string))
52 | 


--------------------------------------------------------------------------------
/Compute N!.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a non-negative number - N, print N!
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a number - N.
 7 | 
 8 | Constraints
 9 | 
10 | 0 <= N <= 10
11 | 
12 | Output Format
13 | 
14 | Print factorial of N.
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | Sample Output 0
20 | 
21 | 120
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | 
26 | */
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | using namespace std;
33 | 
34 | 
35 | int main() {
36 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
37 |     int N,f=1;
38 |     cin>>N;
39 |     for(int i=1;i<=N;i++){
40 |         f=f*i;
41 |     }
42 |     cout<<f<<endl;
43 |     return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/Compute a power b.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given two integers a and b, compute a power b.
 3 | Note: Do not use any inbuilt functions/libraries for your main logic.
 4 | 
 5 | Input Format
 6 | 
 7 | First and only line of input contains two positive integers a and b.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= a <= 100
12 | 0 <= b <= 9
13 | 
14 | Output Format
15 | 
16 | Print a power b.
17 | 
18 | Sample Input 0
19 | 
20 | 2 3
21 | Sample Output 0
22 | 
23 | 8
24 | Explanation 0
25 | 
26 | Self Explanatory.
27 | */
28 | #include <cmath>
29 | #include <cstdio>
30 | #include <vector>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
38 |     long long a,b,f=1;
39 |     cin>>a>>b;
40 |     for(int i=1;i<=b;i++){
41 |         f=f*a;
42 |     }
43 |     cout<<f;
44 |     return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/Compute area of rectangle.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given the length and breadth of a rectangle, print area of the rectangle.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains two positive integers L - length of the rectangle and B - breadth of the rectangle.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= L, B <=109
11 | 
12 | Output Format
13 | 
14 | Print area of the given rectangle.
15 | 
16 | Sample Input 0
17 | 
18 | 5 8
19 | Sample Output 0
20 | 
21 | 40
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     long long L,B;
37 |     cin>>L;
38 |     cin>>B;
39 |     cout<<L*B<<endl;
40 |     return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/Compute fibonacci number.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | For a given positive integer - N, compute Nth fibonacci number.
 4 | 
 5 | Input Format
 6 | 
 7 | First and only line of input contains a positive number - N.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= N <= 20
12 | 
13 | Output Format
14 | 
15 | Print the Nth fibonacci number.
16 | 
17 | Sample Input 0
18 | 
19 | 4
20 | Sample Output 0
21 | 
22 | 3
23 | Explanation 0
24 | 
25 | The fibonacci series is defined as:
26 | 1, 1, 2, 3, 5, 8,......
27 | At 4th position we have 3.
28 | */
29 | #include <cmath>
30 | #include <cstdio>
31 | #include <vector>
32 | #include <iostream>
33 | #include <algorithm>
34 | using namespace std;
35 | 
36 | 
37 | 
38 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
39 |   int fR(int N)
40 | {
41 |     if (N <= 1)
42 |         return N;
43 |     return fR(N - 1) + fR(N - 2);
44 | }
45 | int main()
46 | {
47 |     int N;
48 |     cin>>N;
49 |     cout<<fR(N)<<endl;
50 |     return 0;
51 | }
52 | 
53 |     
54 | 


--------------------------------------------------------------------------------
/Count vowels and consonants.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a string, print count of vowels and consonants in the string.
 3 | 
 4 | Input Format
 5 | 
 6 | Input contains a string S, consisting of lowercase and uppercase characters.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= len(S) <= 100
11 | 
12 | Output Format
13 | 
14 | Print count of vowels and consonants in the given string, separated by space.
15 | 
16 | Sample Input 0
17 | 
18 | aBxbbiAasPw
19 | Sample Output 0
20 | 
21 | 4 7
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | 
26 | */
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | #include<string>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
38 |     string s;
39 |    cin>>s;
40 |     int l=s.length();
41 |     int v=0,c=0;
42 |     for(int i=0;i<l;i++){
43 |         if(s[i]=='a'||s[i]=='e'||s[i]=='i'||s[i]=='o'||s[i]=='u'||s[i]=='A'||s[i]=='E'||s[i]=='I'||s[i]=='O'||s[i]=='U'){
44 |             v=v+1;
45 |         }
46 |         else{
47 |             c=c+1;
48 |         }
49 |     }
50 |     cout<<v<<" "<<c<<endl;
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Cubes sum.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a positive integer N, print the sum of cubes of 1st N natural numbers.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a positive integer - N.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 102
11 | 
12 | Output Format
13 | 
14 | Print the sum of cubes of 1st N natural numbers.
15 | 
16 | Sample Input 0
17 | 
18 | 4
19 | Sample Output 0
20 | 
21 | 100
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     int N,s=0;
37 |     cin>>N;
38 |     for(int i=1;i<=N;i++){
39 |         s+=i*i*i;
40 |     }
41 |     cout<<s<<endl;
42 |     
43 |     return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/Digits in a string.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a string, check if it contains only digits.
 3 | 
 4 | Input Format
 5 | 
 6 | Input contains a string S, consisting of ascii characters.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= len(S) <= 100
11 | 
12 | Output Format
13 | 
14 | Print "Yes" if string contains only digits, "No" otherwise.
15 | 
16 | Sample Input 0
17 | 
18 | 123456786543
19 | Sample Output 0
20 | 
21 | Yes
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | 
26 | Sample Input 1
27 | 
28 | "Smart-Interviews"
29 | Sample Output 1
30 | 
31 | No
32 | Explanation 1
33 | 
34 | Self Explanatory
35 | */
36 | #include <cmath>
37 | #include <cstdio>
38 | #include <vector>
39 | #include <iostream>
40 | #include <algorithm>
41 | using namespace std;
42 | 
43 | 
44 | 
45 | int allDigits(string str, int len)
46 | {
47 | int c=0;
48 |     for (int i = 0; i < len; i++) {
49 |       if (str[i] >= '0' && str[i] <= '9'){
50 |          c++;
51 |       }
52 | 
53 |     }
54 |     return c;
55 | }
56 | 
57 | // Driver code
58 | int main()
59 | {
60 |     string s;
61 |     cin>>s;
62 |     int l = s.length();
63 | 
64 |     if (allDigits(s, l)==l)
65 |         cout << "Yes";
66 |     else
67 |         cout << "No";
68 | 
69 |     return 0;
70 | }
71 | 


--------------------------------------------------------------------------------
/Digits sum.py:
--------------------------------------------------------------------------------
 1 | # Given a non-negative integer - N, print the sum of digits of the given number.
 2 | 
 3 | #Input Format
 4 | 
 5 | #First and only line of input contains a non-negative integer N.
 6 | 
 7 | #Constraints
 8 | 
 9 | #0 <= length(N) <= 103
10 | 
11 | #Output Format
12 | 
13 | #Print the sum of digits of the given number.
14 | 
15 | #Sample Input 0
16 | 
17 | #164
18 | #Sample Output 0
19 | 
20 | #11
21 | #Explanation 0
22 | 
23 | #Self Explanatory
24 |   n=int(input())
25 | s=0
26 | while(n>0):
27 |     s=s+n%10
28 |     n=n//10
29 |     
30 | print(s)
31 |     
32 |     
33 | 


--------------------------------------------------------------------------------
/Find duplicate element in array.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Find a duplicate element in the given array of integers. There will be only a single duplicate element in the array.
 3 | Note: Do not use any inbuilt functions/libraries for your main logic.
 4 | 
 5 | Input Format
 6 | 
 7 | First line of input contains size of the array - N and second line contains the elements of the array.
 8 | 
 9 | Constraints
10 | 
11 | 2 <= N <= 100
12 | 0 <= ar[i] <= 109
13 | 
14 | Output Format
15 | 
16 | Print the duplicate element from the given array.
17 | 
18 | Sample Input 0
19 | 
20 | 6
21 | 5 4 10 9 21 10
22 | Sample Output 0
23 | 
24 | 10
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     int i,j,N;
37 |   cin>>N;
38 |     int A[N];
39 |   for(i=0;i<N;i++)
40 |   {
41 |    cin>>A[i];
42 |   }
43 |   for(i=0; i<N; i++)
44 |    {
45 |     for(j=i+1;j<N;j++)
46 |     {
47 |     if(A[i]==A[j])
48 |     {
49 |     cout<<A[i]<<endl;
50 |     }
51 |    }
52 |    }
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Harshad numbers.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | Given an integer N, check whether it is a Harshad number or not.
 4 | Note: A Harshad number is an integer, that is divisible by the sum of its digits.
 5 | 
 6 | Input Format
 7 | 
 8 | First and only line of input contains a integer - N.
 9 | 
10 | Constraints
11 | 
12 | 1 <= N <= 109
13 | 
14 | Output Format
15 | 
16 | Print "Yes" if the number is a Harshad number, "No" otherwise.
17 | 
18 | Sample Input 0
19 | 
20 | 18
21 | Sample Output 0
22 | 
23 | Yes
24 | Explanation 0
25 | 
26 | 18 / (1 + 8) = 2
27 | As 18 is divisible by the sum of its digits, it is a Harshad number.
28 | */
29 | #include <cmath>
30 | #include <cstdio>
31 | #include <vector>
32 | #include <iostream>
33 | #include <algorithm>
34 | using namespace std;
35 | 
36 | 
37 | int main() {
38 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
39 |     int N,q,r,s=0;
40 |     cin>>N;
41 |     q=N;
42 |     while(q>0){
43 |         r=q%10;
44 |         s=s+r;
45 |         q=q/10;
46 |     }
47 |     if(N%s==0)
48 |         cout<<"Yes"<<endl;
49 |     else
50 |         cout<<"No"<<endl;
51 |     
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/Hollow rectangle pattern.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print hollow rectangle pattern using '*'. See example for more details.
 3 | 
 4 | Input Format
 5 | 
 6 | Input contains two integers W - width of the rectangle and L - length of the rectangle.
 7 | 
 8 | Constraints
 9 | 
10 | 2 <= W <= 50
11 | 2 <= L <= 50
12 | 
13 | Output Format
14 | 
15 | For the given integers W and L, print the hollow rectangle pattern.
16 | 
17 | Sample Input 0
18 | 
19 | 5 4
20 | Sample Output 0
21 | 
22 | *****
23 | *   *
24 | *   *
25 | *****
26 | Explanation 0
27 | 
28 | Self Explanatory
29 | */
30 | #include <cmath>
31 | #include <cstdio>
32 | #include <vector>
33 | #include <iostream>
34 | #include <algorithm>
35 | using namespace std;
36 | 
37 | 
38 | int main() {
39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
40 |     int W,L;
41 |     cin>>W>>L;
42 |     for(int i=1;i<=L;i++){
43 |         for(int j=1;j<=W;j++){
44 |             if(i==1||i==L||j==1||j==W){
45 |                 cout<<"*";
46 |             }
47 |                 else{
48 |                     cout<<" ";
49 |                 }
50 |         }
51 |         cout<<endl;
52 |     }
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Inverted pyramid pattern.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print hollow half inverted pyramid pattern using '*'. See example for more details.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a single integer N - the size of the pyramid.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 50
11 | 
12 | Output Format
13 | 
14 | For the given integer, print hollow half inverted pyramid pattern.
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | Sample Output 0
20 | 
21 | * * * * *
22 | *     *
23 | *   *
24 | * *
25 | *
26 | Explanation 0
27 | 
28 | Self Explanatory
29 | */
30 | #include <cmath>
31 | #include <cstdio>
32 | #include <vector>
33 | #include <iostream>
34 | #include <algorithm>
35 | using namespace std;
36 | 
37 | 
38 | int main() {
39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
40 |     int N;
41 |     cin>>N;
42 |     for(int i=N;i>0;i--)
43 |     {
44 |         if(i==1 || i==N)
45 |             for(int j=1;j<=i;j++)
46 |             {
47 |                cout<<"* ";
48 |             }
49 |         
50 |         else
51 |         {
52 |             for(int j=1;j<=i;j++)
53 |             {  
54 |                 if(j==1 || j==i)
55 |                    cout<<"* ";
56 |                 else
57 |                    cout<<"  ";
58 |             }
59 |         }
60 |        cout<<endl;
61 |     }             
62 |   
63 |    
64 |     return 0;
65 | }
66 |               
67 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 Firoz Hussain 
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Letter repetition.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given an integer - N, print a string with the letter 'o' repeated for N times in the word Go...od.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a single integer N.
 7 | 
 8 | Constraints
 9 | 
10 | 0 <= N<= 100
11 | 
12 | Output Format
13 | 
14 | Print the word Go..od with letter 'o' repeated N times.
15 | 
16 | Sample Input 0
17 | 
18 | 4
19 | Sample Output 0
20 | 
21 | Gooood
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     int N;
37 |     cin>>N;
38 |     cout<<"G";
39 |     for(int i=0;i<N;i++){
40 |         cout<<"o";
41 |     }
42 |     cout<<"d";
43 |     return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/Letters of the alphabet.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a string, check if it contains all the letters of the english alphabet.
 3 | 
 4 | Input Format
 5 | 
 6 | Input contains a string S, consisting of lowercase and uppercase characters.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= len(S) <= 100
11 | 
12 | Output Format
13 | 
14 | Print "Yes" if string contains all the letters of alphabet, "No" Otherwise.
15 | 
16 | Sample Input 0
17 | 
18 | askhTwsFlkqwertyuioPasdfghjklZxcvBnm
19 | Sample Output 0
20 | 
21 | Yes
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | #include<unordered_map>
32 | using namespace std;
33 | 
34 | string uniqueChar(string str) {
35 |     // Write your code here
36 |     int d=str.length();
37 |      for(int i = 0;i<d;i++){
38 |             if(int(str[i])<92){
39 |                 str[i] = tolower(str[i]);
40 |             }
41 |         }
42 |     unordered_map<char , int> charCount;
43 |     string ans;
44 |     for(int i = 0;i<d;i++){
45 |          charCount[str[i]]++;
46 |         if(charCount[str[i]]==1){
47 |            ans.push_back(str[i]);
48 |           
49 |         }
50 |      
51 |     }
52 | 
53 |     return ans;
54 | }
55 | 
56 | int main() {
57 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
58 |       string s;
59 |    cin>>s;
60 |     int d=0;
61 |     int l=s.length();
62 |  s=uniqueChar(s);
63 |     l=s.length();
64 |     for(int i=0;i<l;i++){
65 |          if((s[i]>='a'&& s[i]<='z')){
66 |             d++;
67 |            }  
68 |     }
69 |     if(d==26)
70 |     cout<<"Yes"<<endl;
71 |     else
72 |     cout<<"No"<<endl;
73 |     return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/Linear search on array.py:
--------------------------------------------------------------------------------
 1 | #Given an array on integers, search a given key in the array using linear search.
 2 | #Note: Do not use any inbuilt functions/libraries for your main logic.
 3 | 
 4 | #Input Format
 5 | 
 6 | #First line of input contains two integers, N - size of the array and K - search key. Second line contains the elements of the array.
 7 | 
 8 | #Constraints
 9 | 
10 | #1 <= N <= 102
11 | #0 <= ar[i] <= 109
12 | 
13 | #Output Format
14 | 
15 | #If key is found, print the index of the array, otherwise print -1.
16 | 
17 | #Sample Input 0
18 | 
19 | #5 15
20 | #-2 -19 8 15 4
21 | #Sample Output 0
22 | 
23 | #3
24 | #Explanation 0
25 | 
26 | #Self Explanatory
27 | n,k=list(map(int,input().split()))
28 | arr=list(map(int,input().split()))
29 | c=0
30 | for i in arr:
31 |     if i==k :
32 |         print(arr.index(i))
33 |         c+=1
34 | if c==0:
35 |     print(-1)
36 | 


--------------------------------------------------------------------------------
/Long factorial.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a non-negative number - N, print N!
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a number - N.
 7 | 
 8 | Constraints
 9 | 
10 | 0 <= N <= 20
11 | 
12 | Output Format
13 | 
14 | Print factorial of N.
15 | 
16 | Sample Input 0
17 | 
18 | 3
19 | Sample Output 0
20 | 
21 | 6
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | 
27 | 
28 | #include <cmath>
29 | #include <cstdio>
30 | #include <vector>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
38 |     long long f=1,N;
39 |     cin>>N;
40 |     for(int i=1;i<=N;i++)
41 |         f=f*i;
42 |     
43 |     cout<<f<<endl;
44 |     return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/Matrix Row Sum.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a matrix of size N x M, print row-wise sum, separated by a newline.
 3 | Note: Try to solve this without declaring/storing the matrix.
 4 | 
 5 | Input Format
 6 | 
 7 | First line of input contains N, M - the size of the matrix. Its followed by N lines each containing M integers - elements of the matrix.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= N, M <= 100
12 | -106 <= ar[i] <= 106
13 | 
14 | Output Format
15 | 
16 | Print row-wise sum of the matrix, separated by a newline.
17 | 
18 | Sample Input 0
19 | 
20 | 2 3
21 | 5 -1 3
22 | 19 8 -5
23 | Sample Output 0
24 | 
25 | 7
26 | 22
27 | */
28 | #include <cmath>
29 | #include <cstdio>
30 | #include <vector>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
38 |     int N,M,sum=0;
39 |     cin>>N>>M;
40 |     int A[N][M];
41 |     for(int i=0;i<N;i++){
42 |         for(int j=0;j<M;j++){
43 |             cin>>A[i][j];
44 |         }
45 |     }
46 |      for(int i=0;i<N;i++){
47 |         for(int j=0;j<M;j++){
48 |             sum=sum+A[i][j];
49 |         }
50 |          cout<<sum<<endl;
51 |          sum=0;
52 |     }
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Matrix column sum.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a matrix of size N x M, print column-wise sum, separated by a newline.
 3 | 
 4 | Input Format
 5 | 
 6 | The first line of input contains N, M - the size of the matrix. Its followed by N lines each containing M integers - elements of the matrix.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N, M <= 100
11 | -106 <= ar[i] <= 106
12 | 
13 | Output Format
14 | 
15 | Print column-wise sum of the matrix, separated by newline.
16 | 
17 | Sample Input 0
18 | 
19 | 2 2
20 | 5 -1
21 | 19 8
22 | Sample Output 0
23 | 
24 | 24
25 | 7
26 | 
27 | */
28 | #include <cmath>
29 | #include <cstdio>
30 | #include <vector>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
38 |     int N,M,sum=0;
39 |     cin>>N>>M;
40 |     int A[N][M];
41 |     for(int i=0;i<N;i++){
42 |         for(int j=0;j<M;j++){
43 |             cin>>A[i][j];
44 |         }
45 |     }
46 |      for(int j=0;j<M;j++){
47 |         for(int i=0;i<N;i++){
48 |            sum=sum+A[i][j];
49 |         }
50 |          cout<<sum<<endl;
51 |          sum=0;
52 |     }
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Max element in the array.cpp:
--------------------------------------------------------------------------------
 1 | /*   
 2 | Find maximum element from the given array of integers.
 3 | 
 4 | Input Format
 5 | 
 6 | First line of input contains N - the size of the array and second line contains the elements of the array.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 100
11 | -109 <= ar[i] <= 109
12 | 
13 | Output Format
14 | 
15 | Print the maximum element of the given array.
16 | 
17 | Sample Input 0
18 | 
19 | 5
20 | -2 -19 8 15 4
21 | Sample Output 0
22 | 
23 | 15
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;
35 |     cin>>n;
36 |     int A[n];
37 |     for(int i=0;i<n;i++)
38 |         cin>>A[i];
39 |     
40 |     for(int i=0;i<n;i++)
41 |     {
42 |         if(A[0]<A[i]){
43 |             A[0]=A[i];
44 |         }
45 |     }
46 |     cout<<A[0]<<endl;
47 |     return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/Narcissistic numbers.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | Given an integer N, check whether it is a Narcissistic number or not.
 4 | Note: A narcissistic number is a number that is the sum of its own digits each raised to the power of the number of digits
 5 | 
 6 | Input Format
 7 | 
 8 | First and only line of input contains a integer - N.
 9 | 
10 | Constraints
11 | 
12 | 0 <= N <= 109
13 | 
14 | Output Format
15 | 
16 | Print "Yes" if the number is Narcissistic number, "No" otherwise.
17 | 
18 | Sample Input 0
19 | 
20 | 8208
21 | Sample Output 0
22 | 
23 | Yes
24 | Explanation 0
25 | 
26 | 84 + 24 + 04 + 84 = 8208
27 | */
28 | #include <cmath>
29 | #include <cstdio>
30 | #include <vector>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
38 |     long long N,q;
39 |         long long s=0,r;
40 |     cin>>N;
41 |     q=N;
42 |     int d= int(log10(N) + 1);
43 |     while(q != 0){
44 |         r=q%10;
45 |         s=s+pow(r,d);
46 |         q=q/10;
47 |     }
48 |     if(s==N)
49 |         cout<<"Yes"<<endl;
50 |     else
51 |         cout<<"No"<<endl;
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/Natural numbers sum.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a positive integer N, print the sum of 1st N natural numbers.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a positive integer - N.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 104
11 | 
12 | Output Format
13 | 
14 | Print the sum of 1st N natural numbers.
15 | 
16 | Sample Input 0
17 | 
18 | 4
19 | Sample Output 0
20 | 
21 | 10
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     int N,s=0;
37 |     cin>>N;
38 |     for(int i=1;i<=N;i++)
39 |         s+=i;
40 |     
41 |     cout<<s<<endl;
42 |     return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/Number of multiples.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a positive integer - N, print the number of multiples of 3, 5 between [1, N].
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a positive integer - N.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <=1018
11 | 
12 | Output Format
13 | 
14 | Print the number of multiples of 3, 5 in range of 1 to N.
15 | 
16 | Sample Input 0
17 | 
18 | 12
19 | Sample Output 0
20 | 
21 | 6
22 | Explanation 0
23 | 
24 | Multiples of 3 and 5 in range of 1 to 12 are 3, 5, 6, 9, 10, 12.
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
36 |     long long N;
37 |     cin>>N;
38 |     cout<<N/3+N/5-N/15<<endl;
39 |     return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/Number reverse.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a number N, reverse the number.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a integer - N.
 7 | 
 8 | Constraints
 9 | 
10 | -1018 <= N <= 1018
11 | 
12 | Output Format
13 | 
14 | Print the reversed number.
15 | 
16 | Sample Input 0
17 | 
18 | 1344
19 | Sample Output 0
20 | 
21 | 4431
22 | Explanation 0
23 | 
24 | Self Explanatory.
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
36 |     long long signed N,s=0;
37 |     cin>>N;
38 |     while(N != 0){
39 |         s=(s*10)+(N%10);
40 |         N=N/10;
41 |     }
42 |     cout<<s<<endl;
43 |     return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/Occurrence of a character.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a sentence S and a character ch, count occurrence of the given character in the sentence
 3 | 
 4 | Input Format
 5 | 
 6 | First line of input contains a sentence - S and second line of input contains a single lowercase character - ch.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= len(S) <= 100
11 | 
12 | Output Format
13 | 
14 | Print count of the given character in the sentence.
15 | 
16 | Sample Input 0
17 | 
18 | Data Structures & Algorithms
19 | s
20 | Sample Output 0
21 | 
22 | 2
23 | Explanation 0
24 | 
25 | Self Explanatory
26 | */
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | #include<string>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
38 |      string s;
39 |    getline(cin,s);
40 |     char ch;
41 |     cin>>ch;
42 |     int c=0;
43 |     int l=s.length();
44 |     for(int i=0;i<l;i++){
45 |         if(s[i]==ch){
46 |             c++;
47 |         }
48 |     }
49 |     cout<<c<<endl;
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/Odd even index.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a string, print all the letters present at odd index, followed by the letters present at even index.
 3 | 
 4 | Input Format
 5 | 
 6 | Input contains a string S, consisting of ascii characters.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= len(S) <= 100
11 | 
12 | Output Format
13 | 
14 | Print letters present at odd index, followed by the letters present at even index.
15 | 
16 | Sample Input 0
17 | 
18 | afdg5tg
19 | Sample Output 0
20 | 
21 | fgtad5g
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
36 |     string s;
37 |     cin>>s;
38 |     int l=s.length();
39 |     for(int i=0;i<l;i++){
40 |         if(i%2!=0){
41 |             cout<<s[i];
42 |         }
43 |     }
44 |      for(int i=0;i<l;i++){
45 |         if(i%2==0){
46 |             cout<<s[i];
47 |         }
48 |     }
49 |     return 0;
50 | }
51 | 


--------------------------------------------------------------------------------
/Palindromic right-angled triangle pattern.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print palindromic right-angled triangle pattern using characters. See example for more details.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a integer N - size of the pattern.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 26
11 | 
12 | Output Format
13 | 
14 | For the given integer N, print the palindromic right-angled triangle pattern.
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | Sample Output 0
20 | 
21 | A 
22 | A B A 
23 | A B C B A 
24 | A B C D C B A 
25 | A B C D E D C B A
26 | Explanation 0
27 | 
28 | Self Explanatory
29 | */
30 | #include <cmath>
31 | #include <cstdio>
32 | #include <vector>
33 | #include <iostream>
34 | #include <algorithm>
35 | using namespace std;
36 | 
37 | 
38 | int main() {
39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
40 |      int i, j, r, c=0;
41 |     cin>>r;
42 |     for (i = 0; i < 2*r; i=i+2) {
43 |         for (j = 0; j <= i; j++) {
44 |             cout<<char('A'+c)<<" ";
45 |             if(j< i/2)
46 |                 c++;
47 |             else
48 |                 c--;
49 |         }
50 |         c = 0;
51 |        cout<<endl;
52 |     }
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Prime or not.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | Given a positive integer N, check whether the number is prime or not.
 4 | 
 5 | Input Format
 6 | 
 7 | First and only line of input contains a integer - N.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= N <= 1012
12 | 
13 | Output Format
14 | 
15 | Print "Yes" if the number is prime, "No" otherwise.
16 | 
17 | Sample Input 0
18 | 
19 | 11
20 | Sample Output 0
21 | 
22 | Yes
23 | Explanation 0
24 | 
25 | Self Explanatory
26 | */
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | using namespace std;
33 | 
34 | 
35 | int main() {
36 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
37 |     long long N;
38 |   bool ab=false;
39 |     cin>>N;
40 |     if(N>1){
41 |     for(long long i=2;i<sqrt(N);i++){
42 |         if(N%i==0){
43 |             ab=true;
44 |             break;
45 |         }
46 |     }
47 |     if(ab==false){
48 |         cout<<"Yes"<<endl;
49 |     }
50 |     else{
51 |         cout<<"No"<<endl;
52 |     }
53 |     }
54 |     else{
55 |         cout<<"No"<<endl;
56 |     }
57 |     return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/Print half diamond pattern.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print half diamond pattern using '*'. See example for more details.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a single integer N.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 50
11 | 
12 | Output Format
13 | 
14 | For the given integer, print the half diamond pattern.
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | Sample Output 0
20 | 
21 | *
22 | **
23 | ***
24 | ****
25 | *****
26 | ****
27 | ***
28 | **
29 | *
30 | Explanation 0
31 | 
32 | Self Explanatory
33 | */
34 | 
35 | #include <cmath>
36 | #include <cstdio>
37 | #include <vector>
38 | #include <iostream>
39 | #include <algorithm>
40 | using namespace std;
41 | 
42 | 
43 | int main() {
44 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
45 |     int N;
46 |     cin>>N;
47 |     for(int i=0;i<N;i++){
48 |         for(int j=0;j<=i;j++){
49 |             cout<<"*";
50 |         }
51 |         cout<<endl;
52 |     }
53 |     for(int i=N-1;i>=0;i--){
54 |         for(int j=0;j<i;j++){
55 |             cout<<"*";
56 |         }
57 |         cout<<endl;
58 |     }
59 |     return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/Print multiplication table.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print multiplication table for given integer N.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a single integer N.
 7 | 
 8 | Constraints
 9 | 
10 | -105 <= N <= 105
11 | 
12 | Output Format
13 | 
14 | Print multiplication table for given integer N.
15 | 
16 | Sample Input 0
17 | 
18 | 9
19 | Sample Output 0
20 | 
21 | 9 * 1 = 9
22 | 9 * 2 = 18
23 | 9 * 3 = 27
24 | 9 * 4 = 36
25 | 9 * 5 = 45
26 | 9 * 6 = 54
27 | 9 * 7 = 63
28 | 9 * 8 = 72
29 | 9 * 9 = 81
30 | 9 * 10 = 90
31 | Explanation 0
32 | 
33 | Self Explanatory
34 | */
35 | #include <cmath>
36 | #include <cstdio>
37 | #include <vector>
38 | #include <iostream>
39 | #include <algorithm>
40 | using namespace std;
41 | 
42 | 
43 | int main() {
44 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
45 |     int N;
46 |     cin>>N;
47 |     for(int i=1;i<=10;i++){
48 |         cout<<N<<" * "<<i<<" = "<<N*i<<endl;
49 |     }
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/Print pyramid pattern.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print pyramid pattern using '*'. See example for more details.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a single integer N - the size of the pyramid.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 50
11 | 
12 | Output Format
13 | 
14 | For the given integer, print pyramid pattern.
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | Sample Output 0
20 | 
21 |     *
22 |    ***
23 |   *****
24 |  *******
25 | *********
26 | Explanation 0
27 | 
28 | Self Explanatory
29 | */
30 | #include <cmath>
31 | #include <cstdio>
32 | #include <vector>
33 | #include <iostream>
34 | #include <algorithm>
35 | using namespace std;
36 | 
37 | 
38 | int main() {
39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
40 |     int N;
41 |     cin>>N;
42 |     for(int i=1;i<=N;i++){
43 |         for(int l=N-i;l>0;l--){
44 |             cout<<" ";
45 |         }
46 |             for(int j=1;j<=(2*i-1);j++){
47 |                 cout<<"*"; 
48 |             }
49 |         cout<<endl;
50 |     }
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Print unique elements of array.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | Print unique elements of the array in the same order as they appear in the input.
 4 | Note: Do not use any inbuilt functions/libraries for your main logic.
 5 | 
 6 | Input Format
 7 | 
 8 | First line of input contains a single integer N - the size of array and second line contains array elements.
 9 | 
10 | Constraints
11 | 
12 | 1 <= N <= 100
13 | 0 <= ar[i] <= 109
14 | 
15 | Output Format
16 | 
17 | Print unique elements of the array.
18 | 
19 | Sample Input 0
20 | 
21 | 7
22 | 5 4 10 9 21 4 10
23 | Sample Output 0
24 | 
25 | 5 9 21
26 | */
27 | 
28 | #include <cmath>
29 | #include <cstdio>
30 | #include <vector>
31 | #include <iostream>
32 | #include <algorithm>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
38 |         int n,c=0;
39 |     cin>>n;
40 |     int A[n];
41 |     int i, j, k;
42 |        for(i=0;i<n;i++)
43 |             {
44 |          cin>>A[i];
45 |         }
46 |     for(i=0; i<n; i++)
47 |     {
48 |         c=0;
49 |         for(j=0,k=n; j<k+1; j++)
50 |         {
51 |           
52 |             if (i!=j)
53 |             {
54 |                if(A[i]==A[j])
55 |               {
56 |                  c++;
57 |                }
58 |              }
59 |         }
60 |        if(c==0)
61 |         {
62 |          cout<<A[i]<<" ";
63 |         }
64 |     }
65 |        cout<<endl<<endl;
66 | 
67 |     return 0;
68 | }
69 | 
70 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Smart-Interviews
 2 | This repository contains all the Basic solved problems taught in Smart Interviews Data Structures and Algorithms course. Have a look at the
 3 | website: https://smartinterviews.in/
 4 | 
 5 | Problems:https://www.hackerrank.com/contests/smart-interviews-basic/challenges/filters/page:1
 6 | 
 7 | *Curated list of problems which can only be solved when you clearly understand the topic. Nice problemset!*
 8 | 
 9 | 
10 | 
11 | some solution is in python 3 and Some are in c++;
12 | 


--------------------------------------------------------------------------------
/Rectangle pattern.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print rectangle pattern. See example for more details.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains a single integer N - the size of the rectangle.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 50
11 | 
12 | Output Format
13 | 
14 | For the given integer, print rectangle pattern as shown in example.
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | Sample Output 0
20 | 
21 | 5432*
22 | 543*1
23 | 54*21
24 | 5*321
25 | *4321
26 | Explanation 0
27 | 
28 | Self Explanatory
29 | */
30 | #include <cmath>
31 | #include <cstdio>
32 | #include <vector>
33 | #include <iostream>
34 | #include <algorithm>
35 | using namespace std;
36 | 
37 | 
38 | int main() {
39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
40 |     int N;
41 |     cin>>N;
42 |     for(int i=1;i<=N;i++){
43 |         for(int j=N;j>=1;j--){
44 |             if(i==j){
45 |                 cout<<"*";
46 |             }
47 |             else{
48 |                 cout<<j;
49 |             }
50 |         }
51 |         cout<<endl;
52 |     }
53 |     return 0;
54 | }
55 | 


--------------------------------------------------------------------------------
/Reverse array.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print array in reverse order.
 3 | Note: Try solving this using recursion. Do not use any inbuilt functions/libraries for your main logic.
 4 | 
 5 | Input Format
 6 | 
 7 | First line of input contains N - the size of the array and second line contains the elements of the array.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= N <= 100
12 | 0 <= ar[i] <= 1018
13 | 
14 | Output Format
15 | 
16 | Print the given array in reverse order.
17 | 
18 | Sample Input 0
19 | 
20 | 5
21 | 2 19 8 15 4
22 | Sample Output 0
23 | 
24 | 4 15 8 19 2
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     int n;
37 |     cin>>n;
38 |     long long A[n];
39 |     for(int i=0;i<n;i++)
40 |         cin>>A[i];
41 |     
42 |     for(int i=(n-1);i>=0;i--)
43 |         cout<<A[i]<<" ";
44 |     
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/Reverse string.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a string, reverse the given string in-place and then print it.
 3 | Note: Do not use any inbuilt functions/libraries for your main logic.
 4 | 
 5 | Input Format
 6 | 
 7 | Input contains a string S, consisting of ascii characters.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= len(s) <= 100
12 | 
13 | Output Format
14 | 
15 | Print the reversed string.
16 | 
17 | Sample Input 0
18 | 
19 | fdsrd
20 | Sample Output 0
21 | 
22 | drsdf
23 | Explanation 0
24 | 
25 | Self Explanatory
26 | */
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | #include <string>
33 | using namespace std;
34 | 
35 | 
36 | int main() {
37 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */
38 | 
39 |     string s;
40 |     cin>>s;
41 |     reverse(s.begin(), s.end()); 
42 |     cout<<s;
43 |     return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/Right-angled triangle pattern 1.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 
 3 | Print right-angled triangle pattern using integers. See example for more details.
 4 | 
 5 | Input Format
 6 | 
 7 | First line of input contains a single integer N - the size of the triangle.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= N <= 50
12 | 
13 | Output Format
14 | 
15 | For the given integer, print the right-angled triangle pattern.
16 | 
17 | Sample Input 0
18 | 
19 | 6
20 | Sample Output 0
21 | 
22 | 1 
23 | 2 3 
24 | 4 5 6 
25 | 7 8 9 10 
26 | 11 12 13 14 15 
27 | 16 17 18 19 20 21 
28 | Explanation 0
29 | 
30 | Self Explanatory.
31 | */
32 | #include <cmath>
33 | #include <cstdio>
34 | #include <vector>
35 | #include <iostream>
36 | #include <algorithm>
37 | using namespace std;
38 | 
39 | 
40 | int main() {
41 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
42 |     int N,k=0;
43 |     cin>>N;
44 |     for(int i=0;i<N;i++){
45 |         for(int j=0;j<=i;j++){
46 |             k++;
47 |             cout<<k<<" ";
48 |         }
49 |         cout<<endl;
50 |     }
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Right-angled triangle pattern 2.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print right-angled triangle pattern. See example for more details.
 3 | 
 4 | Input Format
 5 | 
 6 | First line of input contains a single integer N - the size of the triangle.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 50
11 | 
12 | Output Format
13 | 
14 | For the given integer, print the right-angled triangle pattern.
15 | 
16 | Sample Input 0
17 | 
18 | 5
19 | Sample Output 0
20 | 
21 | 1
22 | 2 6
23 | 3 7 10
24 | 4 8 11 13
25 | 5 9 12 14 15
26 | Explanation 0
27 | 
28 | Self Explanatory
29 | */
30 | #include <cmath>
31 | #include <cstdio>
32 | #include <vector>
33 | #include <iostream>
34 | #include <algorithm>
35 | using namespace std;
36 | 
37 | 
38 | int main() {
39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
40 |     int N,v,d;
41 |     cin>>N;
42 |     for(int i=1;i<=N;i++){
43 |         v=i;
44 |         d=N-1;
45 |         for(int j=1;j<=i;j++){
46 |             cout<<v<<" ";
47 |             v+=d;
48 |             d--;
49 |         }
50 |         cout<<endl;
51 |     }
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/Squares sum.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a positive integer N, print the sum of squares of 1st N natural numbers.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains positive integer - N.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 103
11 | 
12 | Output Format
13 | 
14 | Print the sum of squares of 1st N natural numbers.
15 | 
16 | Sample Input 0
17 | 
18 | 15
19 | Sample Output 0
20 | 
21 | 1240
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |     int N,s=0;
37 |     cin>>N;
38 |     for(int i=1;i<=N;i++){
39 |         s+=i*i;
40 |     }
41 |     cout<<s<<endl;
42 |     return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/Sum of all odd elements.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print sum of all odd elements in an array.
 3 | 
 4 | Input Format
 5 | 
 6 | First line of input contains N - the size of the array and second line contains array elements.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N <= 100
11 | -109 <= ar[i] <= 109
12 | 
13 | Output Format
14 | 
15 | Print sum of all odd elements of the given array.
16 | 
17 | Sample Input 0
18 | 
19 | 5
20 | 6 9 8 4 3
21 | Sample Output 0
22 | 
23 | 12
24 | */
25 | #include <cmath>
26 | #include <cstdio>
27 | #include <vector>
28 | #include <iostream>
29 | #include <algorithm>
30 | using namespace std;
31 | 
32 | 
33 | int main() {
34 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
35 |     int n,sum=0;
36 |     cin>>n;
37 |     int A[n];
38 |     for(int i=0;i<n;i++){
39 |         cin>>A[i];
40 |     }
41 |     for(int i=0;i<n;i++){
42 |         if(A[i]%2!=0)
43 |         {
44 |             sum+=A[i];
45 |         }
46 |         }
47 |     cout<<sum<<endl;
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/Sum of two matrices.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given two matrices A and B each of size N x M, print sum of the matrices (A + B)..
 3 | Note: Try solving it by declaring only a single matrix.
 4 | 
 5 | Input Format
 6 | 
 7 | First line of input contains N, M - size of the matrices. Its followed by 2*N lines, each containing M integers - elements of the matrices. First N lines for matrix A and the next N lines for matrix B.
 8 | 
 9 | Constraints
10 | 
11 | 1 <= N, M <= 100
12 | -109 <= ar[i] <= 109
13 | 
14 | Output Format
15 | 
16 | Print sum of the 2 given matrices (A + B).
17 | 
18 | Sample Input 0
19 | 
20 | 2 3
21 | 5 -1 3
22 | 19 8 4
23 | 4 5 -6
24 | 1 -2 12
25 | Sample Output 0
26 | 
27 | 9 4 -3
28 | 20 6 16
29 | */
30 | #include <cmath>
31 | #include <cstdio>
32 | #include <vector>
33 | #include <iostream>
34 | #include <algorithm>
35 | using namespace std;
36 | 
37 | 
38 | int main() {
39 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
40 |     int N,M;
41 |     cin>>N>>M;
42 |     int A[N][M],B[N][M];
43 |     for(int i=0;i<N;i++){
44 |         for(int j=0;j<M;j++){
45 |             cin>>A[i][j];
46 |         }
47 |     }
48 |     for(int i=0;i<N;i++){
49 |         for(int j=0;j<M;j++){
50 |             cin>>B[i][j];
51 |         }
52 |     }
53 |     for(int i=0;i<N;i++){
54 |         for(int j=0;j<M;j++){
55 |             cout<<A[i][j]+B[i][j]<<" ";
56 |         }
57 |         cout<<endl;
58 |     }
59 |     return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/The missing number.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Find the missing number in the given list of integers. The list contains 1 to 100 integers but one of the integer is missing. There are no duplicates in the list.
 3 | 
 4 | Input Format
 5 | 
 6 | Input contains a list of 99 integers.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= L[i] <= 100
11 | 
12 | Output Format
13 | 
14 | Print the missing number in the list.
15 | 
16 | Sample Input 0
17 | 
18 | 12 15 9 1 71 77 81 29 70 19 11 83 56 2 57 53 68 99 82 100 22 10 51 40 34 98 80 38 39 89 94 4 26 64 45 8 90 24 93 33 21 7 49 88 5 28 55 67 65 50 32 58 6 37 46 42 20 44 41 3 78 76 73 16 31 85 91 54 60 47 97 43 84 17 35 69 13 30 61 79 72 48 23 66 52 27 62 87 63 18 75 96 14 86 95 74 25 59 36 
19 | Sample Output 0
20 | 
21 | 92
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | int main(){
34 |  int i,arr[10000];
35 |     int temp[100];
36 |     for(int i = 0; i <= 99; i++){
37 |       cin>>arr[i];
38 |     }
39 |     for(int i = 0; i <= 99; i++){
40 |       temp[i] = 0;
41 |     }
42 |    
43 |     for(i = 0; i < 100; i++){
44 |       temp[arr[i]] = 1;
45 |     }
46 |  
47 |  
48 |     int ans=0;
49 |     for (i = 0; i <= 99 ; i++) {
50 |         if (temp[i] == 0)
51 |             ans = i  + 1;
52 |     }
53 |     cout << ans-1;
54 |     return 0;
55 | }
56 | 


--------------------------------------------------------------------------------
/Toggle case of characters.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a string, toggle the case of each character in the given string.
 3 | 
 4 | Input Format
 5 | 
 6 | Input contains a string S, consisting of lowercase and uppercase characters.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= len(S) <= 100
11 | 
12 | Output Format
13 | 
14 | Print the toggled string.
15 | 
16 | Sample Input 0
17 | 
18 | abdBd
19 | Sample Output 0
20 | 
21 | ABDbD
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | #include<string>
32 | using namespace std;
33 | 
34 | 
35 | int main() {
36 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
37 |     string s;
38 |     cin>>s;
39 |     int l=s.length();
40 |     for(int i=0;i<l;i++){           
41 |         if(isupper(s[i])){  
42 |             s[i] = tolower(s[i]);  
43 |         }  
44 |         else if(islower(s[i])){  
45 |             s[i] = toupper(s[i]);  
46 |         }      }
47 |     cout<<s<<endl;
48 |     return 0;
49 | }
50 | 


--------------------------------------------------------------------------------
/Transpose matrix.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a matrix of size N x M, print transpose of the matrix.
 3 | 
 4 | Input Format
 5 | 
 6 | First line of input contains N, M - the size of the matrix. Its followed by N lines each containing M integers - elements of the matrix.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= N, M <= 100
11 | -109 <= ar[i] <= 109
12 | 
13 | Output Format
14 | 
15 | Print the transposed of the given matrix.
16 | 
17 | Sample Input 0
18 | 
19 | 2 2
20 | 5 -1
21 | 19 8
22 | Sample Output 0
23 | 
24 | 5 19
25 | -1 8
26 | */
27 | #include <cmath>
28 | #include <cstdio>
29 | #include <vector>
30 | #include <iostream>
31 | #include <algorithm>
32 | using namespace std;
33 | 
34 | 
35 | int main() {
36 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 
37 |     int N,M;
38 |     cin>>N>>M;
39 |     int A[N][M];
40 |     for(int i=0;i<N;i++){
41 |         for(int j=0;j<M;j++){
42 |             cin>>A[i][j];
43 |         }
44 |     }
45 |     for(int j=0;j<M;j++){
46 |         for(int i=0;i<N;i++){
47 |             cout<<A[i][j]<<" ";
48 |         }
49 |         cout<<endl;
50 |     }
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/Triangle validator.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given the length of 3 sides of a triangle, check whether the triangle is valid or not.
 3 | 
 4 | Input Format
 5 | 
 6 | First and only line of input contains three integers A, B, C - length of sides of the triangle.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= A, B, C <= 109
11 | 
12 | Output Format
13 | 
14 | Print "Yes" if you can construct a triangle with the given three sides, "No" otherwise.
15 | 
16 | Sample Input 0
17 | 
18 | 4 3 5
19 | Sample Output 0
20 | 
21 | Yes
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */  
36 |     int A,B,C;
37 |     cin>>A>>B>>C;
38 |     if((A+B)>C&&(A+C)>B&&(B+C)>A)
39 |         cout<<"Yes"<<endl;
40 |     else
41 |         cout<<"No"<<endl;
42 |     return 0;
43 | }
44 |   
45 | 


--------------------------------------------------------------------------------
/Vowels in a string.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Given a string, check if it contains only vowels.
 3 | 
 4 | Input Format
 5 | 
 6 | Input contains a string S, consisting of lowercase and uppercase characters.
 7 | 
 8 | Constraints
 9 | 
10 | 1 <= len(S) <= 100
11 | 
12 | Output Format
13 | 
14 | Print "Yes" if string contains only vowels, "No" Otherwise.
15 | 
16 | Sample Input 0
17 | 
18 | SmartInterviews
19 | Sample Output 0
20 | 
21 | No
22 | Explanation 0
23 | 
24 | Self Explanatory
25 | */
26 | #include <cmath>
27 | #include <cstdio>
28 | #include <vector>
29 | #include <iostream>
30 | #include <algorithm>
31 | using namespace std;
32 | 
33 | 
34 | int main() {
35 |     /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
36 |      string s;
37 |    cin>>s;
38 |     int l=s.length();
39 |    int v=0;
40 |     for(int i=0;i<l;i++){
41 |         if(s[i]=='a'||s[i]=='e'||s[i]=='i'||s[i]=='o'||s[i]=='u'||s[i]=='A'||s[i]=='E'||s[i]=='I'||s[i]=='O'||s[i]=='U'){
42 |          v=v+1;
43 |         }
44 |     }
45 |     if(l==v)
46 |     cout<<"Yes"<<endl;
47 |     else
48 |         cout<<"No"<<endl;
49 |     return 0;
50 | }
51 | 


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