├── 30 Day codes
    ├── Day 0.cpp
    ├── Day 2.cpp
    ├── Day 3.cpp
    ├── Day 5.cpp
    ├── Day 6.cpp
    ├── Day 7.cpp
    ├── Day 9.cpp
    └── Day1.cpp
├── Algorithms
    ├── Implementation Challenges
    │   ├── Apple and Orange.cpp
    │   ├── Bon Appétit.cpp
    │   ├── Breaking the record.cpp
    │   ├── Cats and a Mouse.c
    │   ├── Divisible Sum Pairs.cpp
    │   ├── Drawing Book.cpp
    │   ├── GradingStudents.c
    │   ├── Sock Merchant.cpp
    │   └── The Hurdle Race.c
    └── Warmup Challenges
    │   ├── A Very Big Sum.cpp
    │   ├── Birthday Cake Candles.cpp
    │   ├── Compare the Triplets.cpp
    │   ├── Diagonal Difference.cpp
    │   ├── Mini-Max Sum.cpp
    │   ├── Plus Minus.cpp
    │   ├── Simple Array Sum.cpp
    │   ├── Solve Me First.cpp
    │   ├── Staircase.cpp
    │   └── Time conversion.cpp
├── Cats and a Mouse
├── LICENSE
├── README.md
├── The Hurdle Race
├── c++
    └── introduction
    │   ├── Arrays Introduction.cpp
    │   ├── Conditional Statements.cpp
    │   ├── For Loop.cpp
    │   ├── Functions.cpp
    │   ├── Variable Sized Arrays.cpp
    │   ├── basic data type.cpp
    │   ├── hello world.cpp
    │   └── input and output.cpp
├── java
    └── Introduction
    │   ├── Java If-Else.txt
    │   ├── Java Loops I.txt
    │   ├── Java Loops II.txt
    │   ├── Java Output Formatting.txt
    │   ├── Java Stdin and Stdout I.txt
    │   ├── Java Stdin and Stdout II.txt
    │   └── Welcome to Java!.txt
└── python
    ├── Introduction
        ├── Arithmetic operation.py
        ├── Loops.py
        ├── Python Division.py
        ├── Python If-Else.py
        └── hello python.py
    └── Lists.py


/30 Day codes/Day 0.cpp:
--------------------------------------------------------------------------------
 1 | int main() {
 2 |    
 3 |     char s[105]; 
 4 |     
 5 |     fgets(s,105,stdin);
 6 |     
 7 |     printf("Hello, World.\n");
 8 |     
 9 |     printf("%s",s);
10 |     
11 |     
12 |     return 0;
13 | }
14 | 


--------------------------------------------------------------------------------
/30 Day codes/Day 2.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include <math.h>
 4 | #include <stdlib.h>
 5 | 
 6 | int main() {  
 7 |    double m,b,c;
 8 |     int a,t,sum;
 9 |     scanf("%lf %d %d",&m,&t,&a);
10 |     b=m*t/100;
11 |     c=m*a/100;
12 |     sum=round(m+b+c);
13 |     printf("The total meal cost is %d dollars.",sum);
14 |     
15 |     return 0;
16 | }
17 | 


--------------------------------------------------------------------------------
/30 Day codes/Day 3.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | int main(){
10 |   int N; 
11 | 
12 | scanf("%d",&N);
13 | 
14 | if( N%2 == 1 || (N > 5 && N < 21))
15 | 
16 |     printf("Weird");
17 | 
18 | else
19 | 
20 |     printf("Not Weird");
21 | 
22 | return 0;
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/30 Day codes/Day 5.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | int main(){
10 |     int n,i;
11 |     scanf("%d",&n);
12 |     for(i=1;i<11;i++)
13 |         printf("%d x %d = %d\n",n,i,(n*i));
14 |     return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/30 Day codes/Day 6.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include <math.h>
 4 | #include <stdlib.h>
 5 | 
 6 | #include <stdio.h>
 7 | #include <stdlib.h>
 8 | 
 9 | int main() {
10 | 
11 |    int t;
12 |     scanf("%d",&t);
13 |     while(t)
14 |         {
15 |         char a[10000];
16 |    scanf("%s",a);
17 |         int i=0;
18 |         while(a[i]!='\0')
19 |         {if(i%2==0)
20 |             printf("%c",a[i]);
21 |         i++;}
22 |        i=0;
23 |         printf(" ");
24 |         while(a[i]!='\0')
25 |         {if(i%2!=0)
26 |             printf("%c",a[i]);
27 |         i++;}
28 |         t--;
29 |         printf("\n");
30 |     }  
31 |     return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/30 Day codes/Day 7.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main(){
 9 | 
10 | 	int a[10000],i,n;
11 | 	scanf("%d",&n);
12 | 	for(i=0;i<n;i++)
13 | 	{
14 | 		scanf("%d",&a[i]);
15 | 	}
16 | 		for(i=n-1;i>=0;i--)
17 | 	{
18 | 		printf("%d ",a[i]);
19 | 	}
20 | 	return 0;
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/30 Day codes/Day 9.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | int factorial(int n) {
10 |     if(n<=1)
11 |         return(1);
12 |     else 
13 |         return(n*factorial(n-1));
14 |         
15 | 
16 | }
17 | 
18 | int main() {
19 |     int n; 
20 |     scanf("%i", &n);
21 |     int result = factorial(n);
22 |     printf("%d\n", result);
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/30 Day codes/Day1.cpp:
--------------------------------------------------------------------------------
 1 | #include <limits>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 |     int i = 4;
 7 |     double d = 4.0;
 8 |     string s = "HackerRank ";
 9 |       // Declare second integer, double, and String variables.
10 |     int i2;
11 |     double d2;
12 |     string s2;
13 | 
14 |     // Read and save an integer, double, and String to your variables.
15 |     string tmp;
16 | 
17 |     getline(cin, tmp);
18 |     i2 = stoi(tmp);
19 | 
20 |     getline(cin, tmp);
21 |     d2 = stod(tmp);
22 | 
23 |     getline(cin, s2);
24 | 
25 |     // Print the sum of both integer variables on a new line.
26 |     printf("%i\n", i + i2);
27 | 
28 |     // Print the sum of the double variables on a new line.
29 |     printf("%.1f\n", d + d2);
30 | 
31 |     // Concatenate and print the String variables on a new line
32 |     // The 's' variable above should be printed first.
33 |     cout << s + s2 << endl;
34 | 
35 |     return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/Algorithms/Implementation Challenges/Apple and Orange.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <stdlib.h>
 3 | 
 4 | int main(){
 5 |   int s,t;  
 6 |   scanf("%d %d",&s,&t);
 7 |   int a, b; 
 8 |   scanf("%d %d",&a,&b);
 9 |   int m, n;
10 |   scanf("%d %d",&m,&n);
11 |   int apple[m],orange[n];
12 |   int aCount = 0;
13 |   for(int i = 0; i < m; i++){
14 |     scanf("%d",&apple[i]);
15 |     if(a+apple[i] >= s && a+apple[i] <= t){
16 |       aCount++;
17 |     }
18 |   }
19 |   int oCount = 0;
20 |   for(int i = 0; i < n; i++){
21 |     scanf("%d",&orange[i]);
22 |     if(b+orange[i] >= s && b+orange[i] <= t){
23 |        oCount++;
24 |     }
25 |   }
26 |   printf("%d\n%d", aCount, oCount);
27 |   return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/Algorithms/Implementation Challenges/Bon Appétit.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main()
 9 | {
10 |     int n,k,i,bc,ba,sum=0;
11 |     scanf("%d%d",&n,&k);
12 |     int a[n];
13 |     for(i=0;i<n;i++)
14 |     {  scanf("%d",&a[i]);
15 |          sum+=a[i];
16 |            }
17 |     ba=(sum-a[k])/2;
18 |     scanf("%d",&bc);
19 |     if(bc==ba)
20 |         printf("Bon Appetit");
21 |     else
22 |         printf("%d",(bc-ba));
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/Algorithms/Implementation Challenges/Breaking the record.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | int main()
10 | {
11 |     int maxchange,minchange,i,j=0,k=0,n;
12 |     scanf("%d",&n);
13 |     int a[n],b[n];
14 |     for(i=0;i<n;i++)
15 |     scanf("%d",&a[i]);
16 |          a[i]=b[i];
17 |     maxchange=a[0];
18 |     minchange=a[0];
19 |     for(i=1;i<n;i++)
20 |     { if(maxchange<a[i])
21 |     {j++;
22 |      maxchange=a[i];
23 |     }
24 |        if(minchange>a[i])
25 |        {  k++;
26 |          minchange=a[i];  }
27 |                
28 |     }
29 |     printf("%d %d",j,k);
30 | 
31 |     return 0;
32 | }
33 | 
34 | 


--------------------------------------------------------------------------------
/Algorithms/Implementation Challenges/Cats and a Mouse.c:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main() {
 9 |     int q,x,y,z;
10 |     scanf("%d",&q);
11 |     while(q)
12 |     {scanf("%d %d %d",&x,&y,&z);
13 |           if(abs(x-z)>abs(y-z))
14 |               printf("Cat B\n");
15 |      else if(abs(x-z)==abs(y-z))
16 |          printf("Mouse C\n");
17 |            else
18 |          printf("Cat A\n");
19 |      q--;
20 |     }
21 |     
22 |  
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/Algorithms/Implementation Challenges/Divisible Sum Pairs.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | int main()
10 | { 
11 |     int k,i,j,c=0,n; 
12 |     scanf("%d %d",&n,&k);
13 |     int a[n];
14 |     for(i=0;i<n;i++)
15 |         scanf("%d",&a[i]);
16 |     for(i=0;i<n-1;i++)
17 |     {
18 |         for(j=i+1;j<n;j++)
19 |         {
20 |             if((a[i]+a[j])%k==0)
21 |                 c++;
22 |         }
23 |     }  
24 |     printf("%d\n",c);
25 |     return 0;
26 | 
27 | }
28 | 


--------------------------------------------------------------------------------
/Algorithms/Implementation Challenges/Drawing Book.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | int main()
10 | {
11 |     int a,b,c;
12 |     
13 |     scanf("%d",&a);
14 |     scanf("%d",&b);
15 |     c=a/2-(b/2);
16 |     if(b/2>c)
17 |         printf("%d",c);
18 |     else
19 |         printf("%d",b/2);
20 | 
21 |     return 0;
22 | } 
23 | 
24 | 


--------------------------------------------------------------------------------
/Algorithms/Implementation Challenges/GradingStudents.c:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | 
 4 | int main()
 5 | {
 6 | 	int i,n;
 7 | 	scanf("%d",&n);
 8 | 	int *a=malloc(sizeof(int)*n);
 9 | 	for(i=0;i<n;i++){
10 | 		scanf("%d",&a[i]);
11 | 	}
12 | 	int *r=malloc(sizeof(int)*n);
13 | 	for(i=0;i<n;)
14 | 	{
15 | 		if(a[i]<38)
16 | 		{
17 | 			r[i]=a[i];
18 | 			i++;
19 | 		}
20 | 		else
21 | 		{
22 | 			if(((a[i]+2)%5)==0)
23 | 			{
24 | 				r[i]=a[i]+2;
25 | 				i++;
26 | 			}
27 | 			else if(((a[i]+1)%5)==0)
28 | 			{
29 | 				r[i]=a[i]+1;
30 | 				i++;
31 | 			} 
32 | 			else
33 | 			{
34 | 				r[i]=a[i];
35 | 				i++;
36 | 			}
37 | 		}
38 | 	}
39 | 	for(i=0;i<n;i++)
40 | 	{
41 | 		printf("%d\n",r[i]);
42 | 	}
43 | }
44 | 


--------------------------------------------------------------------------------
/Algorithms/Implementation Challenges/Sock Merchant.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main()
 9 | {
10 |     int n,j=0,i; 
11 |     scanf("%d",&n);
12 |    int a[100];
13 |       int b[100]={0};
14 |     for(i=0;i<n;i++)
15 |     {  scanf("%d",&a[i]);
16 |             b[a[i]]++;
17 |          if(b[a[i]]%2==0)
18 |              j++;
19 |     }
20 |      printf("%d",j);   
21 |     return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/Algorithms/Implementation Challenges/The Hurdle Race.c:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main() {
 9 |     int n,a[100];
10 |     int max=a[0];
11 |     int k,i,j=0; 
12 |     scanf("%d %d", &n, &k);
13 |     for(i=1;i<=n;i++)
14 |     {   scanf("%d",&a[i]);
15 |                    }
16 |     for(i=1;i<=n;i++)
17 |     {     if(a[i]>max)
18 |         max=a[i];
19 |          }
20 |     if(max>k)
21 |         printf("%d",(max-k));
22 |     else
23 |         printf("0");
24 |     
25 |     
26 |     return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/A Very Big Sum.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main() {
 9 |   long long int i,sum=0;
10 |  long long int a[10],n; 
11 |     scanf("%lld", &n);
12 |     for(i=0;i<n;i++)
13 |     { scanf("%lld",&a[i]);
14 |        sum=sum+a[i];
15 |     }
16 |     printf("%lld",sum);
17 |      return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/Birthday Cake Candles.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | int birthdayCakeCandles(int n, int ar_size, int* ar) {
10 |     int i,b=0,max=0;
11 |     for(i=0;i<n;i++){
12 |         if(ar[i]>max){
13 |             max=ar[i];
14 | //            printf("%d\n",max);
15 |         }
16 |     }
17 |     for(i=0;i<n;i++){
18 |         if(max==ar[i]){
19 |             b+=1;
20 |         }   
21 |     }
22 | return b;
23 | }
24 | 
25 | int main() {
26 |     int n; 
27 |     scanf("%i", &n);
28 |     int *ar = malloc(sizeof(int) * n);
29 |     for(int ar_i = 0; ar_i < n; ar_i++){
30 |        scanf("%i",&ar[ar_i]);
31 |     }
32 |     int result = birthdayCakeCandles(n, n, ar);
33 |     printf("%d\n", result);
34 |     return 0;
35 | }
36 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/Compare the Triplets.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | int main() {
10 |     int a[100],b[100],i,j=0,k=0;
11 |     for(i=0;i<3;i++)
12 |     { scanf("%d",&a[i]);
13 |     }
14 |     for(i=0;i<3;i++)
15 |     {scanf("%d",&b[i]);
16 |            }
17 |     for(i=0;i<3;i++)
18 |     {  if(a[i]>b[i])
19 |             {j++;
20 |             }
21 |           else if(a[i]<b[i])
22 |           {
23 |           k++;
24 |    
25 |           }}
26 |     printf("%d %d",j,k);
27 |      return 0;
28 |     }
29 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/Diagonal Difference.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include <math.h>
 4 | #include <stdlib.h>
 5 | int main()
 6 | {
 7 |     int A[100][100],i,j,suma=0,sumb=0,N;
 8 |     scanf("%d",&N);
 9 |     for(i=0;i<N;i++)
10 |         {
11 |         for(j=0;j<N;j++)
12 |             {
13 |             scanf("%d",&A[i][j]);
14 |             if(i==j)
15 |                 suma+=A[i][j];
16 |             if(j==(N-i-1))
17 |                 sumb+=A[i][j];
18 |         }
19 |     }
20 |     printf("%d",abs(suma-sumb));
21 |     
22 |     return 0;
23 | }
24 | 
25 |  
26 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/Mini-Max Sum.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main(){
 9 |     long int a,b, c, d;
10 |     long int e,max,min,ma=0,mi=0,sum_max=0,sum_min=0;
11 |     long int no[5];
12 |     int i;
13 |     scanf("%ld %ld %ld %ld %ld",&a,&b,&c,&d,&e);
14 |     no[0]=a;
15 |     no[1]=b;
16 |     no[2]=c;
17 |     no[3]=d;
18 |     no[4]=e;
19 |     max=a;
20 |     min=a;
21 |     for(i=1;i<5;i++)
22 |         {
23 |         if(no[i]>max)
24 |             {
25 |             max=no[i];
26 |             ma=i;
27 |         }      
28 |         if(no[i]<min)
29 |             {
30 |             min=no[i];
31 |             mi=i;
32 |         }
33 |     }
34 |      for(i=0;i<5;i++)
35 |         {
36 |             if(i!=mi)
37 |                 sum_max+=no[i];
38 |                   if(i!=ma)
39 |                 sum_min+=no[i];
40 |      }
41 |     printf("%ld %ld",sum_min,sum_max);
42 |     return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/Plus Minus.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | void plusMinus(int arr_size, int* arr) {
10 |     // Complete this function
11 | }
12 | 
13 | int main() {
14 |     int n; 
15 |     scanf("%i", &n);
16 |     int *arr = malloc(sizeof(int) * n);
17 |     for (int arr_i = 0; arr_i < n; arr_i++) {
18 |        scanf("%i",&arr[arr_i]);
19 |     }
20 |     plusMinus(n, arr);
21 |     return 0;
22 | }
23 | 
24 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/Simple Array Sum.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | 
 9 | int main() {
10 |   int a[1000],n,i,sum=0;
11 |     scanf("%d",&n);
12 |     for(i=0;i<n;i++)
13 |         {
14 |         scanf("%d",&a[i]);
15 |         sum+=a[i];
16 |     }
17 |     printf("%d",sum);
18 |     return 0;
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/Solve Me First.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <string.h>
 3 | #include <math.h>
 4 | #include <stdlib.h>
 5 | 
 6 |     int c;
 7 |     int solveMeFirst(int a, int b) {
 8 |     c=a+b;
 9 |     return c;
10 |  
11 | }
12 | int main() {
13 |     int num1,num2;
14 |     scanf("%d %d",&num1,&num2);
15 |     int sum; 
16 |     sum = solveMeFirst(num1,num2);
17 |     printf("%d",sum);
18 |     return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/Staircase.cpp:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main() {
 9 |     int n,i,j;
10 |    
11 |     scanf("%d",&n);
12 |     for(i=1;i<=n;++i)
13 |         {
14 |         for(j=1;j<=n;++j)
15 |             {if(j<=(n-i))
16 |             printf(" ");
17 |              else
18 |                  printf("#");
19 |         }
20 |         printf("\n");
21 |     }
22 |     
23 | 	   
24 |     return 0;
25 | }
26 | 
27 | 


--------------------------------------------------------------------------------
/Algorithms/Warmup Challenges/Time conversion.cpp:
--------------------------------------------------------------------------------
 1 |  #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main(){
 9 |     
10 |    
11 |     int hh, mm, ss ;
12 |     char t12[2];
13 |     scanf("%d:%d:%d%s", &hh, &mm, &ss, t12) ;
14 |     if (strcmp(t12,"PM")==0 && hh!=12) hh += 12 ;
15 |     if (strcmp(t12,"AM")==0 && hh==12) hh = 0 ;
16 |     printf("%02d:%02d:%02d", hh, mm, ss) ;
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/Cats and a Mouse:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main() {
 9 |     int q,x,y,z;
10 |     scanf("%d",&q);
11 |     while(q)
12 |     {scanf("%d %d %d",&x,&y,&z);
13 |           if(abs(x-z)>abs(y-z))
14 |               printf("Cat B\n");
15 |      else if(abs(x-z)==abs(y-z))
16 |          printf("Mouse C\n");
17 |            else
18 |          printf("Cat A\n");
19 |      q--;
20 |     }
21 |     
22 |  
23 |     return 0;
24 | }
25 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Akshay Pratap Singh
 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 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # hacckerank-code
2 | codes
3 | 


--------------------------------------------------------------------------------
/The Hurdle Race:
--------------------------------------------------------------------------------
 1 | #include <math.h>
 2 | #include <stdio.h>
 3 | #include <string.h>
 4 | #include <stdlib.h>
 5 | #include <assert.h>
 6 | #include <limits.h>
 7 | #include <stdbool.h>
 8 | int main() {
 9 |     int n,a[100];
10 |     int max=a[0];
11 |     int k,i,j=0; 
12 |     scanf("%d %d", &n, &k);
13 |     for(i=1;i<=n;i++)
14 |     {   scanf("%d",&a[i]);
15 |                    }
16 |     for(i=1;i<=n;i++)
17 |     {     if(a[i]>max)
18 |         max=a[i];
19 |          }
20 |     if(max>k)
21 |         printf("%d",(max-k));
22 |     else
23 |         printf("0");
24 |     
25 |     
26 |     return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/c++/introduction/Arrays Introduction.cpp:
--------------------------------------------------------------------------------
 1 | #include <cmath>
 2 | #include <cstdio>
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | 
 8 | 
 9 | int main() {
10 |     int n,i;
11 |     cin>>n;
12 |     int a[n];
13 |     for(i=0;i<n;i++)
14 |         cin>>a[i];
15 |      for(i=n-1;i>=0;i--)
16 |         cout<<a[i]<<" ";
17 |     
18 |     return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/c++/introduction/Conditional Statements.cpp:
--------------------------------------------------------------------------------
 1 | #include <map>
 2 | #include <set>
 3 | #include <list>
 4 | #include <cmath>
 5 | #include <ctime>
 6 | #include <deque>
 7 | #include <queue>
 8 | #include <stack>
 9 | #include <string>
10 | #include <bitset>
11 | #include <cstdio>
12 | #include <limits>
13 | #include <vector>
14 | #include <climits>
15 | #include <cstring>
16 | #include <cstdlib>
17 | #include <fstream>
18 | #include <numeric>
19 | #include <sstream>
20 | #include <iostream>
21 | #include <algorithm>
22 | #include <unordered_map>
23 | 
24 | using namespace std;
25 | 
26 | 
27 | int main(){
28 |     int n;
29 |     cin >> n;
30 |     if(n==1)
31 |         cout<<"one";
32 |     if(n==2)
33 |         cout<<"two";
34 |      if(n==3)
35 |         cout<<"three";
36 |     if(n==4)
37 |         cout<<"four";
38 |      if(n==5)
39 |         cout<<"five";
40 |     if(n==6)
41 |         cout<<"six";
42 |      if(n==7)
43 |         cout<<"seven";
44 |     if(n==8)
45 |         cout<<"eight";
46 |       if(n==9)
47 |         cout<<"nine";
48 |     if(n>9)
49 |         cout<<"Greater than 9";
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/c++/introduction/For Loop.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 |     int i,c,b;
 7 |     string a[11]={"even","odd","one","two","three","four","five","six","seven","eight","nine"};
 8 |     cin>>c>>b;
 9 |     for(i=c;i<=b;i++)
10 |     {
11 |         if((i>9) && (i%2==0))  cout<<a[0]<<endl;
12 |         else if((i>9) && (i%2!=0)) cout<<a[1]<<endl;
13 |         else    cout<<a[i+1]<<endl;
14 |     }
15 |     return 0;
16 | }
17 | 
18 | 


--------------------------------------------------------------------------------
/c++/introduction/Functions.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | using namespace std;
 4 | 
 5 | int max_of_four(int, int, int, int);
 6 | int max_of_four(int a, int b, int c, int d)
 7 | {
 8 |     return max(max(a,b),max(c,d));             }
 9 | 
10 | 
11 | int main() {
12 |     int a, b, c, d;
13 |     scanf("%d %d %d %d", &a, &b, &c, &d);
14 |     int ans = max_of_four(a, b, c, d);
15 |     printf("%d", ans);
16 |     
17 |     return 0;
18 | }
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/c++/introduction/Variable Sized Arrays.cpp:
--------------------------------------------------------------------------------
 1 | #include<stdio.h>
 2 | #include<stdlib.h>
 3 | int main() {
 4 |     int n,q,m,l,k;
 5 |     scanf("%d%d",&n,&q);
 6 |     int *arr[n];
 7 |     for(int i = 0 ; i < n;i++){
 8 |         scanf("%d",&m);
 9 |         arr[i] = (int *)malloc(m * sizeof(int));
10 |         for(int j = 0 ; j < m ;j++){
11 |              scanf("%d",&arr[i][j]);
12 |         }
13 |     }
14 |     while(q--){
15 |         scanf("%d%d",&l,&k);
16 |         printf("%d\n",arr[l][k]);
17 |     } 
18 |     return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/c++/introduction/basic data type.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | #include<iomanip>
 4 | using namespace std;
 5 | 
 6 | int main() {
 7 |     int a;
 8 |     long int b;
 9 |     char c;
10 |     float d;
11 |     double e;
12 |     cin>>a>>b>>c>>d>>e;
13 |     cout<<a<<"\n"<<b<<"\n"<<c<<"\n";
14 |     std::cout<<std::fixed<<std::setprecision(3)<<d<<"\n";
15 |     std::cout<<std::fixed<<std::setprecision(5)<<e<<"\n";
16 |     return 0;
17 | }
18 | 
19 | 


--------------------------------------------------------------------------------
/c++/introduction/hello world.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstdio>
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 |     printf("Hello, World!");
 7 |     return 0;
 8 | }
 9 | 
10 | 


--------------------------------------------------------------------------------
/c++/introduction/input and output.cpp:
--------------------------------------------------------------------------------
 1 | #include <cmath>
 2 | #include <cstdio>
 3 | #include <vector>
 4 | #include <iostream>
 5 | #include <algorithm>
 6 | using namespace std;
 7 | 
 8 | 
 9 | int main() {
10 |     int a,b,c;
11 | cin>>a>>b>>c;
12 |     cout<<a+b+c;
13 |     
14 |     return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/java/Introduction/Java If-Else.txt:
--------------------------------------------------------------------------------
 1 |     import java.io.*;
 2 |     import java.util.*;
 3 |     import java.text.*;
 4 |     import java.math.*;
 5 |     import java.util.regex.*;
 6 | 
 7 |     public class Solution {
 8 | 
 9 |         public static void main(String[] args) {
10 | 
11 |             Scanner sc=new Scanner(System.in);
12 |             int n=sc.nextInt();            
13 |             String ans="";
14 |             if((n%2==1 || (n>=6 && n <= 20))){
15 |               ans = "Weird";
16 |             }
17 |             else{
18 |             
19 |                ans="Not Weird";
20 |                 
21 |             }
22 |             System.out.println(ans);
23 |             
24 |         }
25 |     }


--------------------------------------------------------------------------------
/java/Introduction/Java Loops I.txt:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | import java.text.*;
 4 | import java.math.*;
 5 | import java.util.regex.*;
 6 | 
 7 | public class Solution {
 8 | 
 9 |     public static void main(String[] args) {
10 |         Scanner in = new Scanner(System.in);
11 |         int N = in.nextInt();
12 |         for(int i=1;i<=10;i++)
13 |         System.out.println(+N+" x " +i+ " = " +(N*i));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/java/Introduction/Java Loops II.txt:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | import java.io.*;
 3 | 
 4 | class Solution{
 5 |     public static void main(String []argh){
 6 |         Scanner in = new Scanner(System.in);
 7 |         int t=in.nextInt();
 8 |         for(int i=0;i<t;i++){
 9 |             int a = in.nextInt();
10 |             int b = in.nextInt();
11 |             int n = in.nextInt();
12 |             for(int j=0;j<n;j++)
13 |             {  a+=b*(int)Math.pow(2,j);
14 |                System.out.print(a+" ");
15 |                        }System.out.println("");
16 |         }
17 |         in.close();
18 |     }
19 | }


--------------------------------------------------------------------------------
/java/Introduction/Java Output Formatting.txt:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | 
 3 | public class Solution {
 4 | 
 5 |     public static void main(String[] args) {
 6 |             Scanner sc=new Scanner(System.in);
 7 |             System.out.println("================================");
 8 |             for(int i=0;i<3;i++){
 9 |                 String s1=sc.next();
10 |                 int x=sc.nextInt();
11 |                 System.out.printf("%-15s%03d%n", s1, x);  }
12 |             System.out.println("================================");
13 | 
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/java/Introduction/Java Stdin and Stdout I.txt:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Solution {
 4 | 
 5 |     public static void main(String[] args) {
 6 |         Scanner sc = new Scanner(System.in);
 7 |         int a = sc.nextInt();
 8 |         int b = sc.nextInt();
 9 |         int c = sc.nextInt();
10 | 
11 |         System.out.println(+a);
12 |         System.out.println(+b);
13 |          System.out.println(+c);
14 |     }
15 | }


--------------------------------------------------------------------------------
/java/Introduction/Java Stdin and Stdout II.txt:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | 
 3 | public class Solution {
 4 | 
 5 |     public static void main(String[] args) {
 6 |         Scanner sc = new Scanner(System.in);
 7 |         int i = sc.nextInt();
 8 |         Double d = sc.nextDouble();
 9 |            sc.nextLine();
10 |         String s = sc.nextLine();
11 | 
12 |       
13 | 
14 |         System.out.println("String: " + s);
15 |         System.out.println("Double: " + d);
16 |         System.out.println("Int: " + i);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/java/Introduction/Welcome to Java!.txt:
--------------------------------------------------------------------------------
1 | public class Solution {
2 | 
3 |     public static void main(String[] args) {
4 |      System.out.println("Hello, World.");
5 |         System.out.println("Hello, Java.");
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/python/Introduction/Arithmetic operation.py:
--------------------------------------------------------------------------------
1 | a = int(input())
2 | b = int(input())
3 | print (a+b)
4 | print (a-b)
5 | print (a*b)
6 | 


--------------------------------------------------------------------------------
/python/Introduction/Loops.py:
--------------------------------------------------------------------------------
1 | n = int(input())
2 | i=0
3 | while (i<n):
4 |  print (i*i)
5 |  i = i+1;
6 | 


--------------------------------------------------------------------------------
/python/Introduction/Python Division.py:
--------------------------------------------------------------------------------
1 | a = int(input())
2 | b = int(input())
3 | x =  int(a/b)
4 | print(x)
5 | print (a/b)
6 | 


--------------------------------------------------------------------------------
/python/Introduction/Python If-Else.py:
--------------------------------------------------------------------------------
 1 | x = int(input())
 2 | if (x%2==0):
 3 |       if((x>2) and (x<5)) or (x>20):
 4 |          print ("Not Weird")
 5 |       if (x>6) and (x<=20):
 6 |          print ("Weird") 
 7 | else:
 8 |     if (x>6) and (x<20):
 9 |         print ("Not Weird")
10 |     else:
11 |          print ("Weird")
12 |         
13 | 


--------------------------------------------------------------------------------
/python/Introduction/hello python.py:
--------------------------------------------------------------------------------
1 | print("HELLO PYTHON")
2 | 


--------------------------------------------------------------------------------
/python/Lists.py:
--------------------------------------------------------------------------------
 1 | if __name__ == '__main__':
 2 |     N = int(input())
 3 |     result = []
 4 |     for n in range(N):
 5 |         x = input().split(" ")
 6 |         command = x[0]
 7 |         if command == 'append':
 8 |             result.append(int(x[1]))
 9 |         if command == 'print':
10 |             print(result)
11 |         if command == 'insert':
12 |             result.insert(int(x[1]), int(x[2]))
13 |         if command == 'reverse':
14 |             result = result[::-1]
15 |         if command == 'pop':
16 |             result.pop()
17 |         if command == 'sort':
18 |             result = sorted(result)
19 |         if command == 'remove':
20 |             result.remove(int(x[1]))
21 |         #   print(result)
22 | 


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