├── Nim game
├── Odd or even
├── Add digits
├── a num after a double reversal
├── Calculate delayed arrival time
├── matrix diagonal sum
├── armstrong number
├── Reverse integer
├── ugly number
├── Three consecutive odds
├── Reverse the given string
├── palindrome number
├── First and last value in array
├── Even numbers in array
├── minimum cost to move chips to
├── Even Index in Array
├── Odd num in array
├── Rotate array
├── Sum of num 2d array
├── Array value greaterthan given value
├── count of vowel
├── Array values greaterthan10
├── Sum of even numbers in array
├── Sum of rows in 2d
├── Sum of column in 2D
├── To find targeted value
└── Maximum value in each row


/Nim game:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public boolean canWinNim(int n) {
3 |         return n%4 !=0 ;
4 |     }
5 | }
6 | 


--------------------------------------------------------------------------------
/Odd or even:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     static boolean isEven(int n) {
3 |         // code here
4 |         return (n&1)==0;
5 |     }
6 | }
7 | 


--------------------------------------------------------------------------------
/Add digits:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public int addDigits(int num) {
3 |         if(num==0) return 0;
4 |         return num%9 == 0? 9:num%9;
5 |         
6 |         
7 |     }
8 | }
9 | 


--------------------------------------------------------------------------------
/a num after a double reversal:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public boolean isSameAfterReversals(int num) {
3 |         if( num ==0) return true;
4 |         return num%10 !=0;
5 |         
6 |     }
7 | }
8 | 


--------------------------------------------------------------------------------
/Calculate delayed arrival time:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public int findDelayedArrivalTime(int arrivalTime, int delayedTime) {
3 |         return (arrivalTime+delayedTime) %24;
4 |         
5 |     }
6 | }
7 | 


--------------------------------------------------------------------------------
/matrix diagonal sum:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int diagonalSum(int[][] arr) {
 3 |         int n= arr.length;
 4 |         int sum = 0;
 5 |         for(int i=0; i<n; i++){
 6 |             sum+= arr[i][i];
 7 |             sum+= arr[i][n-i-1];
 8 | 
 9 |         }
10 |         return (n&1)==1 ? sum - arr[n/2][n/2]: sum;
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/armstrong number:
--------------------------------------------------------------------------------
 1 | // User function Template for Java
 2 | class Solution {
 3 |     static boolean armstrongNumber(int n) {
 4 |         // code here
 5 |         int  m = n;
 6 |         int s=0;
 7 |         while(n!=0){
 8 |             s += Math.pow( n%10,3);
 9 |             n = n/10;
10 |             
11 |         }
12 |         return s==m;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/Reverse integer:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int reverse(int n) {
 3 |         long rev = 0;
 4 |         while(n != 0){
 5 |             rev = rev*10 +(n%10);
 6 |             n = n/10;
 7 |         }
 8 |         if(rev < Integer.MIN_VALUE || rev > Integer.MAX_VALUE){
 9 |             return 0;
10 |         }
11 |         return (int)rev;
12 |         
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/ugly number:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isUgly(int n) {
 3 |          if(n<=0) return false;
 4 |         while(n%2==0){
 5 |             n=n/2;
 6 |         }
 7 |         while(n%3==0){
 8 |             n=n/3;
 9 |         }
10 |         while(n%5==0){
11 |             n=n/5;
12 |         }
13 |         return n==1;
14 |         
15 |         
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/Three consecutive odds:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean threeConsecutiveOdds(int[] arr) {
 3 |          for (int i = 0; i < arr.length - 2; i++) {
 4 |             if (arr[i] % 2 != 0 && arr[i+1] % 2 != 0 && arr[i+2] % 2 != 0) {
 5 |                 return true;
 6 |             }
 7 |         }
 8 |         return false;
 9 |     }
10 |    // public static void main(String args[]){
11 |     //    S
12 |  //   }
13 | 
14 |         
15 |     }
16 | 


--------------------------------------------------------------------------------
/Reverse the given string:
--------------------------------------------------------------------------------
 1 | package string_based_problems;
 2 | import java.util.*;
 3 | public class Reverse {
 4 | 
 5 | 	public static void main(String[] args) {
 6 | 		Scanner sc = new Scanner(System.in);
 7 | 		String s = sc.nextLine();
 8 | 		//String rev=" ";
 9 | 		for( int i= s.length() - 1; i>=0; i--) {
10 | 			char ch = s.charAt(i);
11 | 			System.out.print(ch);
12 | 			//rev += ch;
13 | 		}
14 | 		//System.out.print(rev);
15 | 		
16 | 		
17 | 	}
18 | 
19 | }
20 | 


--------------------------------------------------------------------------------
/palindrome number:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isPalindrome(int n) {
 3 |         if(n<0){
 4 |             return false;
 5 |         }
 6 |        int rev = 0;
 7 |        int s = n;
 8 |         while(n != 0){
 9 |             rev = rev*10 +(n%10);
10 |             n = n/10;
11 |         }
12 |         if(rev == s){
13 |             return true;
14 |         }
15 |         return false;
16 | 
17 |         
18 |     }
19 | } 
20 |             
21 |         
22 | 


--------------------------------------------------------------------------------
/First and last value in array:
--------------------------------------------------------------------------------
 1 | package array_based_problem;
 2 | import java.util.Scanner;
 3 | 
 4 | public class FirstLast {
 5 | 
 6 | 	public static void main(String[] args) {
 7 | 		Scanner sc = new Scanner(System.in);
 8 | 		int n = sc.nextInt();
 9 | 		int arr[] = new int[n];
10 | 		for(int i = 0; i<n;i++) {
11 | 			arr[i] = sc.nextInt();
12 | 		}
13 | 			System.out.println(arr[0]);
14 | 			System.out.println(arr[n-1]);
15 | 		}
16 | 		// TODO Auto-generated method stub
17 | 
18 | 	}
19 | 


--------------------------------------------------------------------------------
/Even numbers in array:
--------------------------------------------------------------------------------
 1 | package array_based_problem;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class EvenNumbers {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 		Scanner sc = new Scanner(System.in);
 9 | 		int n = sc.nextInt();
10 | 		int arr[] = new int[n];
11 | 		for(int i = 0;i<n;i++) {
12 | 			arr[i] = sc.nextInt();
13 | 			if(arr[i]%2==0) {
14 | 				System.out.println(arr[i]);
15 | 			}
16 | 			
17 | 		}
18 | 		// TODO Auto-generated method stub
19 | 
20 | 	}
21 | 
22 | }
23 | 


--------------------------------------------------------------------------------
/minimum cost to move chips to:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     
 3 |     public int minCostToMoveChips(int[] arr) {
 4 |         int EvenCount = 0;
 5 |         int OddCount = 0;
 6 |         for(int i=0; i<arr.length; i++){
 7 |             if((arr[i]&1)==0){
 8 |                 EvenCount++;
 9 |             }
10 |             else{
11 |                 OddCount++;
12 |             }
13 |         }
14 |             return EvenCount<OddCount?EvenCount:OddCount;
15 |             
16 |         }
17 |     }
18 |         
19 |     
20 | 


--------------------------------------------------------------------------------
/Even Index in Array:
--------------------------------------------------------------------------------
 1 | package array_based_problem;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class Evenindex {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 			Scanner sc = new Scanner(System.in);
 9 | 			int n = sc.nextInt();
10 | 			int arr[] = new int[n];
11 | 			for(int i = 0;i<n;i++) {
12 | 				arr[i] = sc.nextInt();
13 | 				if(i%2==0) {
14 | 					System.out.println(arr[i]);
15 | 				}
16 | 				
17 | 			}
18 | 			// TODO Auto-generated method stub
19 | 
20 | 		}
21 | 
22 | 
23 | 
24 | 	}
25 | 
26 | 
27 | 


--------------------------------------------------------------------------------
/Odd num in array:
--------------------------------------------------------------------------------
 1 | package array_based_problem;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class OddNumbers {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 			Scanner sc = new Scanner(System.in);
 9 | 			int n = sc.nextInt();
10 | 			int arr[] = new int[n];
11 | 			for(int i = 0;i<n;i++) {
12 | 				arr[i] = sc.nextInt();
13 | 				if(arr[i]%2!=0) {
14 | 					System.out.println(arr[i]);
15 | 				}
16 | 				
17 | 			}
18 | 			// TODO Auto-generated method stub
19 | 
20 | 		}
21 | 
22 | 
23 | 		// TODO Auto-generated method stub
24 | 
25 | 	}
26 | 
27 | 
28 | 


--------------------------------------------------------------------------------
/Rotate array:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public void reverse(int arr[],int left, int right){
 3 |         while(left<right){
 4 |             int tem= arr[left];
 5 |             arr[left] = arr[right];
 6 |             arr[right] = tem;
 7 |             left++;
 8 |             right--;
 9 |         }
10 |     }
11 |     public void rotate(int[] nums, int k) {
12 |      int n = nums.length;
13 |      k = k%n;
14 |      reverse(nums,0,n-1);
15 |      reverse(nums,0,k-1);
16 |      reverse(nums,k,n-1);
17 |     }
18 | }
19 |         
20 |         
21 |         
22 |         
23 | 


--------------------------------------------------------------------------------
/Sum of num 2d array:
--------------------------------------------------------------------------------
 1 | package twodArrayBased;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class SumNo {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 		Scanner sc = new Scanner(System.in);
 9 | 		int r = sc.nextInt();
10 | 		int c = sc.nextInt();
11 | 		int sum = 0;
12 | 		int arr[][] = new int[r][c];
13 | 		for(int i =0; i<r;i++) {
14 | 			for(int j=0; j<c ; j++) {
15 | 				arr[i][j]= sc.nextInt();
16 | 				sum += arr[i][j];
17 | 			}
18 | 			
19 | 		}
20 | 		System.out.println(sum);
21 | 		// TODO Auto-generated method stub
22 | 
23 | 	}
24 | 
25 | }
26 | 


--------------------------------------------------------------------------------
/Array value greaterthan given value:
--------------------------------------------------------------------------------
 1 | package array_based_problem;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class GreaterthanGiven {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 			Scanner sc = new Scanner(System.in);
 9 | 			int n = sc.nextInt();
10 | 			int x = sc.nextInt();
11 | 			int arr[] = new int[n];
12 | 			for(int i = 0;i<n;i++) {
13 | 				arr[i] = sc.nextInt();
14 | 				if(arr[i] > x) {
15 | 					System.out.println(arr[i]);
16 | 				}
17 | 				
18 | 			}
19 | 			// TODO Auto-generated method stub
20 | 
21 | 		}
22 | 
23 | 
24 | 		// TODO Auto-generated method stub
25 | 
26 | 	}
27 | 
28 | 
29 | 


--------------------------------------------------------------------------------
/count of vowel:
--------------------------------------------------------------------------------
 1 | package string_based_problems;
 2 | import java.util.*;
 3 | 
 4 | public class Vowel {
 5 | 
 6 | 	public static void main(String[] args) {
 7 | 		Scanner sc = new Scanner(System.in);
 8 | 		String s = sc.nextLine();
 9 | 		int count=0;
10 | 		for(int i=0; i<s.length(); i++) {
11 | 			char ch = s.charAt(i);
12 | 			if( ch == 'a' || ch == 'e' || ch == 'i' || ch =='o' || ch=='u') {
13 | 				count+=1;
14 | 			}
15 | 				}
16 | 		System.out.print(count);
17 | 		
18 | 		// TODO Auto-generated method stub
19 | 
20 | 	}
21 | 
22 | }
23 | 
24 | 
25 | 
26 | 
27 | //if("aeiou".indexOf(s.charAt(i)!= 0){
28 | //count++;}
29 | 


--------------------------------------------------------------------------------
/Array values greaterthan10:
--------------------------------------------------------------------------------
 1 | package array_based_problem;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class Greaterthan10 {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 		
 9 | 		// TODO Auto-generated method stub
10 | 
11 | 		Scanner sc = new Scanner(System.in);
12 | 		int n = sc.nextInt();
13 | 		int count = 0;
14 | 		int arr[] = new int[n];
15 | 		for(int i = 0;i<n;i++) {
16 | 			arr[i] = sc.nextInt();
17 | 			if(arr[i]>10) {
18 | 				
19 | 				count++;
20 | 				
21 | 				
22 | 			}
23 | 		}
24 | 			System.out.println(count);
25 | 			
26 | 		
27 | 		// TODO Auto-generated method stub
28 | 
29 | 	
30 | 
31 | 	}
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/Sum of even numbers in array:
--------------------------------------------------------------------------------
 1 | package array_based_problem;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class SumOfEven {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 			Scanner sc = new Scanner(System.in);
 9 | 			int n = sc.nextInt();
10 | 			int sum =0;
11 | 			int arr[] = new int[n];
12 | 			for(int i = 0;i<n;i++) {
13 | 				arr[i] = sc.nextInt();
14 | 				if(arr[i]%2==0) {
15 | 					 sum = sum + arr[i];
16 | 				}
17 | 			}
18 | 					System.out.println(sum);
19 | 				
20 | 				
21 | 			
22 | 			// TODO Auto-generated method stub
23 | 
24 | 		}
25 | 
26 | 
27 | 		// TODO Auto-generated method stub
28 | 
29 | 	}
30 | 
31 | 
32 | 


--------------------------------------------------------------------------------
/Sum of rows in 2d:
--------------------------------------------------------------------------------
 1 | package twodArrayBased;
 2 | import java.util.*;
 3 | 
 4 | public class SumOfRow {
 5 | 
 6 | 		public static void main(String[] args) {
 7 | 			Scanner sc = new Scanner(System.in);
 8 | 			int r = sc.nextInt();
 9 | 			int c = sc.nextInt();
10 | 			int arr[][] = new int[r][c];
11 | 			for(int i =0; i<r;i++) {
12 | 				for(int j=0; j<c ; j++) {
13 | 					arr[i][j]= sc.nextInt();
14 | 				}
15 | 			}
16 | 			for(int i =0; i<r;i++) {
17 | 				int sum =0;
18 | 				for(int j=0; j<c ; j++) {
19 | 					sum += arr[i][j];
20 | 				}
21 | 				System.out.println(sum);
22 | 			}
23 | 			// TODO Auto-generated method stub
24 | 
25 | 		}
26 | 
27 | 	}
28 | 
29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/Sum of column in 2D:
--------------------------------------------------------------------------------
 1 | package twodArrayBased;
 2 | import java.util.*;
 3 | 
 4 | public class SumOfColumn {
 5 |                 public static void main(String[] args) {
 6 | 				Scanner sc = new Scanner(System.in);
 7 | 				int r = sc.nextInt();
 8 | 				int c = sc.nextInt();
 9 | 				int arr[][] = new int[r][c];
10 | 				for(int i =0; i<r;i++) {
11 | 					for(int j=0; j<c ; j++) {
12 | 						arr[i][j]= sc.nextInt();
13 | 					}
14 | 				}
15 | 				for(int i =0; i<r;i++) {
16 | 					int sum =0;
17 | 					for(int j=0; j<c ; j++) {
18 | 						sum += arr[j][i];
19 | 					}
20 | 					System.out.println(sum);
21 | 				}
22 | 				// TODO Auto-generated method stub
23 | 
24 | 			
25 | 
26 | 		
27 | 
28 | 
29 | 
30 | 
31 | 
32 | 	}
33 | 
34 | }
35 | 


--------------------------------------------------------------------------------
/To find targeted value:
--------------------------------------------------------------------------------
 1 | package array_based_problem;
 2 | 
 3 | import java.util.Scanner;
 4 | 
 5 | public class Target {
 6 | 
 7 | 	public static void main(String[] args) {
 8 | 		
 9 | 			Scanner sc = new Scanner(System.in);
10 | 			int n = sc.nextInt();
11 | 			int x = sc.nextInt();
12 | 			int arr[] = new int[n];
13 | 			boolean isPrime = false;
14 | 			for(int i = 0;i<n;i++) {
15 | 				arr[i] = sc.nextInt();
16 | 				if(arr[i] == x) {
17 | 					isPrime = true;
18 |                     
19 | 				}
20 | 			
21 | 				
22 | 			}
23 | 			if(isPrime==true) {
24 | 				System.out.println("YES");
25 | 			}
26 | 			else {
27 | 			System.out.println("NO");
28 | 			
29 | 			// TODO Auto-generated method stub
30 | 
31 | 		}
32 | 	}
33 | }
34 | 
35 | 
36 | 		// TODO Auto-generated method stub
37 | 
38 | 	
39 | 
40 | 


--------------------------------------------------------------------------------
/Maximum value in each row:
--------------------------------------------------------------------------------
 1 | package twodArrayBased;
 2 | import java.util.*;
 3 | 
 4 | public class MaxInRow {
 5 | 
 6 | 	public static void main(String[] args) {
 7 | 
 8 | 								Scanner sc = new Scanner(System.in);
 9 | 								int r = sc.nextInt();
10 | 								int c = sc.nextInt();
11 | 								int max = Integer.MIN_VALUE;
12 | 								int row =-1;
13 | 								int arr[][] = new int[r][c];
14 | 								for(int i =0; i<r;i++) {
15 | 									for(int j=0; j<c ; j++) {
16 | 										arr[i][j]= sc.nextInt();
17 | 									}
18 | 								}
19 | 								for(int i =0; i<r;i++) {
20 | 									int sum=0;
21 | 									for(int j=0; j<c ; j++) {
22 | 										sum+=arr[i][j];
23 | 									}
24 | 										
25 | 									
26 | 									if(max<sum) {
27 | 										max = sum;
28 | 										row =i;
29 | 									}
30 | 								}
31 | 								System.out.println(max);
32 | 								System.out.println(row);
33 | 								// TODO Auto-generated method stub
34 | 
35 | 							
36 | 
37 | 						
38 | 
39 | 
40 | 
41 | 
42 | 
43 | 					}
44 | 
45 | 				
46 | 
47 | 
48 | 		
49 | 		}
50 | 
51 | 
52 | 
53 | 
54 | 		// TODO Auto-generated method stub
55 | 
56 | 	
57 | 


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