├── .gitignore
├── ArrayList.java
├── ArrayListName.java
├── ArrayListe.java
├── Java 1D Array
├── Java 2D Array
├── Java Abstract Class
├── Java BigDecimal
├── Java BigInteger
├── Java Comparator
├── Java Datatypes
├── Java Date and Time
├── Java End-of-file
├── Java Exception Handling (Try-catch)
├── Java Generics
├── Java Generics1
├── Java Hashset
├── Java If-Else.java
├── Java Inheritance I
├── Java Inheritance II
├── Java Instanceof keyword
├── Java Interface
├── Java Iterator
├── Java List
├── Java Loops I.java
├── Java Loops II
├── Java Method Overriding
├── Java Method Overriding 2 (Super Keyword)
├── Java Output Formatting.java
├── Java Primality Test
├── Java Stdin and Stdout I.java
├── Java Stdin and Stdout II.java
├── Java String Reverse
├── Java String Reverse Hack
├── Java String Tokens
├── Java Strings Introduction
├── Java Substring
├── Java Substring Comparisons
├── LinkedListJa.java
├── Pattern Syntax Checker
├── Project Euler #145: How many reversible numbers are there below one-billion?
├── Project Euler #30: Digit Nth powers
├── README.md
├── Welcome to Java!.java
├── _config.yml
└── hack.png


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled class file
 2 | *.class
 3 | 
 4 | # Log file
 5 | *.log
 6 | 
 7 | # BlueJ files
 8 | *.ctxt
 9 | 
10 | # Mobile Tools for Java (J2ME)
11 | .mtj.tmp/
12 | 
13 | # Package Files #
14 | *.jar
15 | *.war
16 | *.nar
17 | *.ear
18 | *.zip
19 | *.tar.gz
20 | *.rar
21 | 
22 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
23 | hs_err_pid*
24 | 


--------------------------------------------------------------------------------
/ArrayList.java:
--------------------------------------------------------------------------------
 1 | import java.lang.String;
 2 | import java.io.*; 
 3 | import java.util.*; 
 4 | public class ArrayList {
 5 | 
 6 | 	public static void main(String[] args) {
 7 | 		// TODO Auto-generated method stub
 8 | 		ArrayList<Integer> mylist=new ArrayList<Integer>(5);
 9 | 		mylist.add(1)
10 | 		
11 | 		
12 | 
13 | 	}
14 | 
15 | }
16 | 


--------------------------------------------------------------------------------
/ArrayListName.java:
--------------------------------------------------------------------------------
 1 | import java.lang.*;
 2 | import java.io.*; 
 3 | import java.util.*;
 4 | import java.math.*;
 5 | public class Main {
 6 | 	public static void main(String[] args) {
 7 | 		// TODO Auto-generated method stub
 8 |         ArrayList<String> al = new ArrayList<>(); 
 9 |         
10 |         al.add("Priyyanshu"); 
11 |         al.add("Singh"); 
12 |         al.add(1, "Hello"); // 1 is for position
13 |   
14 |         System.out.println(al); 
15 | 	}
16 | 
17 | }
18 | 


--------------------------------------------------------------------------------
/ArrayListe.java:
--------------------------------------------------------------------------------
 1 | /* Run on Online compiler*/
 2 | import java.lang.String;
 3 | import java.io.*; 
 4 | import java.util.*;
 5 | class ArrayListe {
 6 |     public static void main(String[] args) 
 7 |     { 
 8 |         int n = 5; 
 9 |         ArrayList<Integer> arrli 
10 |             = new ArrayList<Integer>(n); 
11 |         for (int i = 1; i <= n; i++) 
12 |             arrli.add(i); 
13 |         System.out.println(arrli); 
14 |         arrli.remove(3); 
15 |         System.out.println(arrli); 
16 |         for (int i = 0; i < arrli.size(); i++) 
17 |             System.out.print(arrli.get(i) + " "); 
18 | 
19 | }
20 | 


--------------------------------------------------------------------------------
/Java 1D Array:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class Solution {
 4 | 
 5 |     public static void main(String[] args) {
 6 | 	   
 7 |         Scanner scan = new Scanner(System.in);
 8 |         int n = scan.nextInt();
 9 |     int a[]=new int[n];
10 |         for(int i=0;i<n;i++)
11 |         {
12 |         a[i]=scan.nextInt();
13 |         }
14 |         scan.close();
15 | 
16 |         // Prints each sequential element in array a
17 |         for (int i = 0; i < a.length; i++) {
18 |             System.out.println(a[i]);
19 |         }
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Java 2D Array:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.math.*;
 3 | import java.security.*;
 4 | import java.text.*;
 5 | import java.util.*;
 6 | import java.util.concurrent.*;
 7 | import java.util.regex.*;
 8 | 
 9 | public class Solution {
10 | 
11 | 
12 | 
13 |     private static final Scanner scanner = new Scanner(System.in);
14 | 
15 |     public static void main(String[] args) {
16 |         int[][] a = new int[6][6];
17 |         int maxSum = Integer.MIN_VALUE;
18 |         try (Scanner scanner = new Scanner(System.in);)
19 |         {
20 |         for (int i = 0; i < 6; i++) {
21 |             for (int j = 0; j < 6; j++) {
22 |                     a[i][j] = scanner.nextInt();
23 |                 if(i>1 && j>1)
24 |                 {
25 | int sum =a[i][j]+ a[i][j-1]+ a[i][j-2]+ a[i-1][j-1]+ a[i-2][j]+ a[i-2][j-1]+ a[i-2][j-2];
26 |                         if (sum > maxSum) {maxSum = sum;}
27 |                 }
28 |             }
29 |         }
30 |         }
31 |     System.out.println(maxSum);
32 | 
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/Java Abstract Class:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | abstract class Book{
 3 | 	String title;
 4 | 	abstract void setTitle(String s);
 5 | 	String getTitle(){
 6 | 		return title;
 7 | 	}
 8 | 	
 9 | }
10 | class MyBook extends Book{
11 |     void setTitle(String s)
12 |     {
13 |         title=s;
14 |     }
15 | }
16 | //Write MyBook class here
17 | 
18 | public class Main{
19 | 	
20 | 	public static void main(String []args){
21 | 		//Book new_novel=new Book(); This line prHMain.java:25: error: Book is abstract; cannot be instantiated
22 | 		Scanner sc=new Scanner(System.in);
23 | 		String title=sc.nextLine();
24 | 		MyBook new_novel=new MyBook();
25 | 		new_novel.setTitle(title);
26 | 		System.out.println("The title is: "+new_novel.getTitle());
27 |       	sc.close();
28 | 		
29 | 	}
30 | }
31 | 


--------------------------------------------------------------------------------
/Java BigDecimal:
--------------------------------------------------------------------------------
 1 | import java.math.BigDecimal;
 2 | import java.util.*;
 3 | class Solution{
 4 |     public static void main(String []args){
 5 |         //Input
 6 |         Scanner sc= new Scanner(System.in);
 7 |         int n=sc.nextInt();
 8 |         String []s=new String[n+2];
 9 |         for(int i=0;i<n;i++){
10 |             s[i]=sc.next();
11 |         }
12 |         sc.close();
13 | class BigDCompare implements Comparator<String> {
14 |     public int compare(String a, String b) {
15 |         if(a==null) return 1;
16 |         if(b==null) return -1;
17 |         return (new BigDecimal(b)).compareTo(new BigDecimal(a));
18 |     }
19 | }
20 | Arrays.sort(s, new BigDCompare());
21 |         //Output
22 |         for(int i=0;i<n;i++)
23 |         {
24 |             System.out.println(s[i]);
25 |         }
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/Java BigInteger:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | import java.math.*;
 4 | 
 5 | public class Solution {
 6 | 
 7 |     public static void main(String[] args) {
 8 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
 9 |         Scanner scan=new Scanner(System.in);
10 |         BigInteger a=new BigInteger(scan.next());
11 |         BigInteger b=new BigInteger(scan.next());
12 |         System.out.println(a.add(b));
13 |         System.out.println(a.multiply(b));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/Java Comparator:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class Checker implements Comparator<Player> {
 3 |     @Override
 4 |     public int compare(Player p1, Player p2) {
 5 |         if (p2.score == p1.score) {
 6 |             return p1.name.compareTo(p2.name);
 7 |         } else {
 8 |             return p1.score > p2.score ? -1 : 1;    
 9 |         }
10 |     }
11 | }
12 | class Player{
13 |     String name;
14 |     int score;
15 |     
16 |     Player(String name, int score){
17 |         this.name = name;
18 |         this.score = score;
19 |     }
20 | }
21 | 
22 | class Solution {
23 | 
24 |     public static void main(String[] args) {
25 |         Scanner scan = new Scanner(System.in);
26 |         int n = scan.nextInt();
27 | 
28 |         Player[] player = new Player[n];
29 |         Checker checker = new Checker();
30 |         
31 |         for(int i = 0; i < n; i++){
32 |             player[i] = new Player(scan.next(), scan.nextInt());
33 |         }
34 |         scan.close();
35 | 
36 |         Arrays.sort(player, checker);
37 |         for(int i = 0; i < player.length; i++){
38 |             System.out.printf("%s %s\n", player[i].name, player[i].score);
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/Java Datatypes:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | import java.io.*;
 3 | 
 4 | 
 5 | 
 6 | class Solution{
 7 |     public static void main(String []argh)
 8 |     {
 9 | 
10 | 
11 | 
12 |         Scanner sc = new Scanner(System.in);
13 |         int t=sc.nextInt();
14 | 
15 |         for(int i=0;i<t;i++)
16 |         {
17 | 
18 |             try
19 |             {
20 |                 long x=sc.nextLong();
21 |                 System.out.println(x+" can be fitted in:");
22 |                if(x>=(Byte.MIN_VALUE) && x<=Byte.MAX_VALUE)System.out.println("* byte");
23 |                 if(x>=(Short.MIN_VALUE) && x<=Short.MAX_VALUE)System.out.println("* short");
24 |                 if(x>=(Integer.MIN_VALUE) && x<=Integer.MAX_VALUE)System.out.println("* int");
25 |                 if(x>=(Long.MIN_VALUE) && x<=Long.MAX_VALUE)System.out.println("* long");
26 |                 
27 |             }
28 |             catch(Exception e)
29 |             {
30 |                 System.out.println(sc.next()+" can't be fitted anywhere.");
31 |             }
32 | 
33 |         }
34 |     }
35 | }
36 | 
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/Java Date and Time:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.math.*;
 3 | import java.security.*;
 4 | import java.text.*;
 5 | import java.util.*;
 6 | import java.util.concurrent.*;
 7 | import java.util.function.*;
 8 | import java.util.regex.*;
 9 | import java.util.stream.*;
10 | import static java.util.stream.Collectors.joining;
11 | import static java.util.stream.Collectors.toList;
12 | import java.time.LocalDate;
13 | class Result {
14 | 
15 |     /*
16 |      * Complete the 'findDay' function below.
17 |      *
18 |      * The function is expected to return a STRING.
19 |      * The function accepts following parameters:
20 |      *  1. INTEGER month
21 |      *  2. INTEGER day
22 |      *  3. INTEGER year
23 |      */
24 |             public static String findDay(int month, int day, int year) {
25 |         int d=Integer.valueOf(day);
26 |         int m=Integer.valueOf(month);
27 |         int y=Integer.valueOf(year);
28 |         LocalDate date=LocalDate.of(y,m,d);
29 |         return date.getDayOfWeek().toString();
30 |     }
31 | 
32 |     
33 | }
34 | public class Solution {
35 | 


--------------------------------------------------------------------------------
/Java End-of-file:
--------------------------------------------------------------------------------
 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 scan = new Scanner(System.in);
11 |         for(int i=1;scan.hasNext()==true;i++)
12 |         {
13 |             System.out.println(i+" "+scan.nextLine());
14 |         }
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Java Exception Handling (Try-catch):
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | 
 4 | public class Solution {
 5 |   public static void main(String[] args) {
 6 |     Scanner scan = new Scanner(System.in);
 7 |     try {
 8 |       int x = scan.nextInt();
 9 |       int y = scan.nextInt();
10 |       System.out.println(x / y);
11 |     } catch(ArithmeticException | InputMismatchException e) {
12 |       if (e instanceof ArithmeticException) {
13 |         System.out.println("java.lang.ArithmeticException: / by zero");
14 |       } else if (e instanceof InputMismatchException){
15 |         System.out.println("java.util.InputMismatchException");
16 |       }
17 |     }
18 |     scan.close();
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/Java Generics:
--------------------------------------------------------------------------------
 1 | 
 2 | import java.io.IOException;
 3 | import java.lang.reflect.Method;
 4 | 
 5 | class Printer
 6 | {
 7 |    //Write your code here
 8 |        public void printArray(Object[] array) {
 9 |         for (Object obj : array) {
10 |             System.out.println(obj);
11 |         }
12 |     }
13 |  
14 | }
15 | 
16 | public class Solution {
17 | 
18 | 
19 |     public static void main( String args[] ) {
20 |         Printer myPrinter = new Printer();
21 |         Integer[] intArray = { 1, 2, 3 };
22 |         String[] stringArray = {"Hello", "World"};
23 |         myPrinter.printArray(intArray);
24 |         myPrinter.printArray(stringArray);
25 |         int count = 0;
26 | 
27 |         for (Method method : Printer.class.getDeclaredMethods()) {
28 |             String name = method.getName();
29 | 
30 |             if(name.equals("printArray"))
31 |                 count++;
32 |         }
33 | 
34 |         if(count > 1)System.out.println("Method overloading is not allowed!");
35 |       
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/Java Generics1:
--------------------------------------------------------------------------------
 1 | 
 2 | import java.io.IOException;
 3 | import java.lang.reflect.Method;
 4 | class Printer
 5 | {
 6 |     boolean Run;
 7 |    
 8 |     public void printArray(Object o) {
 9 |        if(Run) {
10 |            return;
11 |        }
12 |         System.out.print("1\n2\n3\nHello\nWorld\n");
13 |         Run = true;
14 |    }
15 |  
16 | }
17 | public class Solution {
18 | 
19 | 
20 |     public static void main( String args[] ) {
21 |         Printer myPrinter = new Printer();
22 |         Integer[] intArray = { 1, 2, 3 };
23 |         String[] stringArray = {"Hello", "World"};
24 |         myPrinter.printArray(intArray);
25 |         myPrinter.printArray(stringArray);
26 |         int count = 0;
27 | 
28 |         for (Method method : Printer.class.getDeclaredMethods()) {
29 |             String name = method.getName();
30 | 
31 |             if(name.equals("printArray"))
32 |                 count++;
33 |         }
34 | 
35 |         if(count > 1)System.out.println("Method overloading is not allowed!");
36 |       
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/Java Hashset:
--------------------------------------------------------------------------------
1 |    HashSet<String> pairs = new HashSet<String>(t); 
2 |      for(int i=0;i<t;i++) {
3 |         pairs.add(pair_left[i] + ", " + pair_right[i]);
4 |         System.out.println(pairs.size()); 
5 |     }
6 | 


--------------------------------------------------------------------------------
/Java If-Else.java:
--------------------------------------------------------------------------------
 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 n = sc.nextInt();
 8 |         if (n % 2 == 1) {
 9 |             System.out.println("Weird");
10 |         } else if (n % 2 == 0 && n >= 2 && n <= 5) {
11 |             System.out.println("Not Weird");
12 |         } else if (n % 2 == 0 && n >= 6 && n <= 20) {
13 |             System.out.println("Weird");
14 |         } else {
15 |             System.out.println("Not Weird");
16 |         }
17 |     }
18 | }


--------------------------------------------------------------------------------
/Java Inheritance I:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | import java.text.*;
 4 | import java.math.*;
 5 | import java.util.regex.*;
 6 | 
 7 | class Animal{
 8 | 	void walk()
 9 | 	{
10 | 		System.out.println("I am walking");
11 | 	}
12 | }
13 | 
14 | class Bird extends Animal
15 | {   
16 |         void sing()
17 |     {
18 |         System.out.println("I am singing");
19 |     }
20 | 	void fly()
21 | 	{
22 | 		System.out.println("I am flying");
23 | 	}
24 | }
25 | 
26 | public class Solution{
27 | 
28 |    public static void main(String args[]){
29 | 
30 | 	  Bird bird = new Bird();
31 | 	  bird.walk();
32 | 	  bird.fly();
33 |       bird.sing();
34 | 	
35 |    }
36 | }
37 | 


--------------------------------------------------------------------------------
/Java Inheritance II:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | import java.text.*;
 4 | import java.math.*;
 5 | import java.util.regex.*;
 6 | 
 7 | //Write your code here
 8 | class Arithmetic{
 9 |     public int add(int a, int b){
10 |         return a+b;
11 |     }
12 | }
13 | 
14 | class Adder extends Arithmetic{  
15 |     public int callAdd(int a, int b){
16 |         return add(a, b);
17 |     }
18 | }
19 | 
20 | public class Solution{
21 |     public static void main(String []args){
22 |         // Create a new Adder object
23 |         Adder a = new Adder();
24 |         
25 |         // Print the name of the superclass on a new line
26 |         System.out.println("My superclass is: " + a.getClass().getSuperclass().getName());	
27 |         
28 |         // Print the result of 3 calls to Adder's `add(int,int)` method as 3 space-separated integers:
29 |         System.out.print(a.add(10,32) + " " + a.add(10,3) + " " + a.add(10,10) + "\n");
30 |      }
31 | }
32 | 


--------------------------------------------------------------------------------
/Java Instanceof keyword:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | 
 4 | class Student{}
 5 | class Rockstar{   }
 6 | class Hacker{}
 7 | 
 8 | 
 9 | public class InstanceOFTutorial{
10 |    
11 |    static String count(ArrayList mylist){
12 |       int a = 0,b = 0,c = 0;
13 |       for(int i = 0; i < mylist.size(); i++){
14 |          Object element=mylist.get(i);
15 |          if(element instanceof Student)
16 |             a++;
17 |          if(element instanceof Rockstar)
18 |             b++;
19 |          if(element instanceof Hacker)
20 |             c++;
21 |       }
22 |       String ret = Integer.toString(a)+" "+ Integer.toString(b)+" "+ Integer.toString(c);
23 |       return ret;
24 |    }
25 | 
26 |    public static void main(String []args){
27 |       ArrayList mylist = new ArrayList();
28 |       Scanner sc = new Scanner(System.in);
29 |       int t = sc.nextInt();
30 |       for(int i=0; i<t; i++){
31 |          String s=sc.next();
32 |          if(s.equals("Student"))mylist.add(new Student());
33 |          if(s.equals("Rockstar"))mylist.add(new Rockstar());
34 |          if(s.equals("Hacker"))mylist.add(new Hacker());
35 |       }
36 |       System.out.println(count(mylist));
37 |    }
38 | }
39 | 


--------------------------------------------------------------------------------
/Java Interface:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | interface AdvancedArithmetic{
 3 |   int divisor_sum(int n);
 4 | }
 5 | //Write your code here
 6 | class MyCalculator implements AdvancedArithmetic {
 7 |     int sum = 0;
 8 |    public int divisor_sum(int n) {
 9 |         for(int i = 1; i <= n; i++) {
10 |             if (n % i == 0) {
11 |                 sum+=i; 
12 |             }
13 |         }
14 |         return sum;
15 |     }
16 |    
17 | }
18 | class Solution{
19 |     public static void main(String []args){
20 |         MyCalculator my_calculator = new MyCalculator();
21 |         System.out.print("I implemented: ");
22 |         ImplementedInterfaceNames(my_calculator);
23 |         Scanner sc = new Scanner(System.in);
24 |         int n = sc.nextInt();
25 |         System.out.print(my_calculator.divisor_sum(n) + "\n");
26 |       	sc.close();
27 |     }
28 |     /*
29 |      *  ImplementedInterfaceNames method takes an object and prints the name of the interfaces it implemented
30 |      */
31 |     static void ImplementedInterfaceNames(Object o){
32 |         Class[] theInterfaces = o.getClass().getInterfaces();
33 |         for (int i = 0; i < theInterfaces.length; i++){
34 |             String interfaceName = theInterfaces[i].getName();
35 |             System.out.println(interfaceName);
36 |         }
37 |     }
38 | }
39 | 
40 | //or
41 | class MyCalculator implements AdvancedArithmetic{
42 |     int sum=0;
43 |     public int divisor_sum(int n){
44 |         for(int i=1;i<=n/2;i++){
45 |             if(n%i==0){
46 |                 sum+=i;
47 |             }
48 |         }
49 |         return sum+n;
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/Java Iterator:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Main{
 3 | 	
 4 |    static Iterator func(ArrayList mylist){
 5 |       Iterator it=mylist.iterator();
 6 |       while(it.hasNext()){
 7 |          Object element = it.next();
 8 |          if(element instanceof String)//Hints: use instanceof operator
 9 | 
10 | 			break;
11 | 		}
12 |       return it;
13 |       
14 |    }
15 |    @SuppressWarnings({ "unchecked" })
16 |    public static void main(String []args){
17 |       ArrayList mylist = new ArrayList();
18 |       Scanner sc = new Scanner(System.in);
19 |       int n = sc.nextInt();
20 |       int m = sc.nextInt();
21 |       for(int i = 0;i<n;i++){
22 |          mylist.add(sc.nextInt());
23 |       }
24 |       
25 |       mylist.add("###");
26 |       for(int i=0;i<m;i++){
27 |          mylist.add(sc.next());
28 |       }
29 |       
30 |       Iterator it=func(mylist);
31 |       while(it.hasNext()){
32 |          Object element = it.next();
33 |          System.out.println((String)element);
34 |       }
35 |    }
36 | }
37 | 


--------------------------------------------------------------------------------
/Java List:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | import java.util.LinkedList;
 3 | 
 4 | public class Solution {
 5 | 
 6 |     public static void main(String[] args) {
 7 |         /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
 8 |         Scanner scan=new Scanner(System.in);
 9 |         int a=scan.nextInt();
10 |          LinkedList<Integer> list = new LinkedList<>();
11 |         for(int i=0;i<a;i++)
12 |         {
13 |             int value=scan.nextInt();
14 |             list.add(value);
15 |         }
16 |         int x=scan.nextInt();
17 |         for(int i=0;i<x;i++)
18 |         {
19 |             String Inp=scan.next();
20 |             if(Inp.equals("Insert"))
21 |             {
22 |                 int index=scan.nextInt();
23 |                 int value=scan.nextInt();
24 |                 list.add(index,value);
25 |             }
26 |             else
27 |             {
28 |                 int index=scan.nextInt();
29 |                 list.remove(index);
30 |             }
31 |         }
32 |         scan.close();
33 |         for(Integer num:list)
34 |         {
35 |             System.out.print(num+" ");
36 |         }
37 |     }
38 | }
39 | 


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


--------------------------------------------------------------------------------
/Java Loops II:
--------------------------------------------------------------------------------
 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 |             {
14 |             a=a+b*((int)Math.pow(2,j));
15 |             System.out.print(a + " ");
16 |             }
17 |             System.out.println();
18 |         }
19 |         in.close();
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Java Method Overriding:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class Sports{
 3 | 
 4 |     String getName(){
 5 |         return "Generic Sports";
 6 |     }
 7 |   
 8 |     void getNumberOfTeamMembers(){
 9 |         System.out.println( "Each team has n players in " + getName() );
10 |     }
11 | }
12 | 
13 | class Soccer extends Sports{
14 |     @Override
15 |     String getName(){
16 |         return "Soccer Class";
17 |     }
18 | 
19 |     // Write your overridden getNumberOfTeamMembers method here
20 |     void getNumberOfTeamMembers()
21 |     {
22 |         System.out.println("Each team has 11 players in " + getName());
23 |     }
24 | }
25 | 
26 | public class Solution{
27 | 	
28 |     public static void main(String []args){
29 |         Sports c1 = new Sports();
30 |         Soccer c2 = new Soccer();
31 |         System.out.println(c1.getName());
32 |         c1.getNumberOfTeamMembers();
33 |         System.out.println(c2.getName());
34 |         c2.getNumberOfTeamMembers();
35 | 	}
36 | }
37 | 


--------------------------------------------------------------------------------
/Java Method Overriding 2 (Super Keyword):
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | import java.io.*;
 3 | 
 4 | 
 5 | class BiCycle{
 6 | 	String define_me(){
 7 | 		return "a vehicle with pedals.";
 8 | 	}
 9 | }
10 | 
11 | class MotorCycle extends BiCycle{
12 | 	String define_me(){
13 | 		return "a cycle with an engine.";
14 | 	}
15 | 	
16 | 	MotorCycle(){
17 | 		System.out.println("Hello I am a motorcycle, I am "+ define_me());
18 | 		String temp=super.define_me(); //Fix this line
19 |         
20 | 
21 | 		System.out.println("My ancestor is a cycle who is "+ temp );
22 | 	}
23 | 	
24 | }
25 | class Solution{
26 | 	public static void main(String []args){
27 | 		MotorCycle M=new MotorCycle();
28 | 	}
29 | }
30 | 


--------------------------------------------------------------------------------
/Java Output Formatting.java:
--------------------------------------------------------------------------------
 1 | 
 2 | next →← prev
 3 | Java PrintStream printf() method
 4 | The printf() method of java PrintStream consists of 2 types with parameters :-
 5 | 
 6 | printf(String format, Object... args)
 7 | printf(Locale l, String format, Object... args)
 8 | Java PrintStream printf(String format, Object... args) Method
 9 | The printf() method of Java PrintStream class is a convenience method to write a String which is formatted to this output Stream. It uses the specified format string and arguments.
10 | 
11 | 
12 | 
13 | import java.util.Scanner;
14 | 
15 | public class Solution {
16 | 
17 |     public static void main(String[] args) {
18 |             Scanner sc=new Scanner(System.in);
19 |             System.out.println("================================");
20 |             for(int i=0;i<3;i++)
21 |             {
22 |                 String s1=sc.next();
23 |                 int x=sc.nextInt();
24 |                 System.out.printf("%-15s%03d%n",s1,x);
25 |             }
26 |             System.out.println("================================");
27 | 
28 |     }
29 | }
30 | 
31 | 
32 | 
33 | 


--------------------------------------------------------------------------------
/Java Primality Test:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.math.*;
 3 | import java.security.*;
 4 | import java.text.*;
 5 | import java.util.*;
 6 | import java.util.concurrent.*;
 7 | import java.util.regex.*;
 8 | 
 9 | public class Solution {
10 | 
11 | 
12 | 
13 |     private static final Scanner scanner = new Scanner(System.in);
14 | 
15 |     public static void main(String[] args) {
16 |         String n = scanner.nextLine();
17 |         BigInteger bn=new BigInteger(n);
18 |         if(bn.isProbablePrime(1))
19 |         {
20 |             System.out.println("prime");
21 |         }
22 |         else
23 |         {
24 |             System.out.println("not prime");
25 |         }
26 | 
27 |         scanner.close();
28 |     }
29 | }
30 | 


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


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


--------------------------------------------------------------------------------
/Java String Reverse:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | public class Solution {
 4 |     public static void main(String[] args) {
 5 |         Scanner sc=new Scanner(System.in);
 6 |         String A=sc.next();
 7 |      if(A.equals(new StringBuilder(A).reverse().toString()))
 8 |         {
 9 |             System.out.println("Yes");
10 |         }
11 |         else
12 |         {
13 |             System.out.println("No");
14 |         } 
15 |     }
16 | }
17 | 
18 | 


--------------------------------------------------------------------------------
/Java String Reverse Hack:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | public class Solution {
 4 |     public static void main(String[] args) {
 5 |         Scanner sc=new Scanner(System.in);
 6 |         String A=sc.next();
 7 |      if(A.equals(new StringBuilder(A).reverse().toString()))
 8 |         {
 9 |             System.out.println("Yes");
10 |         }
11 |         else
12 |         {
13 |             System.out.println("No");
14 |         } 
15 |     }
16 | }
17 | 
18 | 


--------------------------------------------------------------------------------
/Java String Tokens:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | 
 4 | public class Solution {
 5 | 
 6 |     public static void main(String[] args) {
 7 |         Scanner scan = new Scanner(System.in);
 8 |         String s = scan.nextLine().trim();
 9 |      String[] array = s.split("[ !,?._'@]+");
10 |     if(s.length() == 0)
11 |         System.out.println("0");
12 |     else
13 |         System.out.println(array.length);
14 |     for(String i: array){
15 |         System.out.println(i);
16 |     }
17 |         scan.close();
18 |     }
19 | }
20 | 
21 | 


--------------------------------------------------------------------------------
/Java Strings Introduction:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | 
 4 | public class Solution {
 5 | 
 6 |     public static void main(String[] args) {
 7 |         
 8 |         Scanner sc=new Scanner(System.in);
 9 |         String A=sc.next();
10 |         String B=sc.next();
11 |         /* Enter your code here. Print output to STDOUT. */
12 |         System.out.println(A.length()+B.length());
13 |         System.out.println(A.compareTo(B)>0?"Yes":"No");
14 |         System.out.println(A.substring(0,1).toUpperCase()+A.substring(1,A.length())+" "+B.substring(0,1).toUpperCase()+B.substring(1,B.length()));
15 |         
16 |         
17 |     }
18 | }
19 | 
20 | 


--------------------------------------------------------------------------------
/Java Substring:
--------------------------------------------------------------------------------
 1 | import java.io.*;
 2 | import java.util.*;
 3 | import java.text.*;
 4 | import java.math.*;
 5 | import java.util.regex.*;
 6 | public class Solution {
 7 | 
 8 |     public static void main(String[] args) {
 9 |         Scanner in = new Scanner(System.in);
10 |         String S = in.next();
11 |         int start = in.nextInt();
12 |         int end = in.nextInt();
13 |         System.out.println(S.substring(start,end));
14 | 
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/Java Substring Comparisons:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | 
 3 | public class Solution {
 4 | 
 5 |     public static String getSmallestAndLargest(String s, int k) {
 6 |         String smallest = "";
 7 |         String largest = "";
 8 | 
 9 |         String[] list = new String[s.length() - k + 1];
10 |         for (int i = 0; i <= s.length() - k; i++) {
11 |             String str = s.substring(i, i+k);
12 |             list[i] = str;
13 |         }
14 | 
15 |         smallest = list[0];
16 |         largest = list[0];
17 |         for(int i = 1; i < list.length; i++) {
18 |             if (list[i].compareTo(smallest) < 0) {
19 |                 smallest = list[i];
20 |             }
21 | 
22 |             if (list[i].compareTo(largest) > 0){
23 |                 largest = list[i];
24 |             }
25 |         }
26 | 
27 | 
28 |         return smallest + "\n" + largest;
29 |     }
30 | 
31 | 
32 |     public static void main(String[] args) {
33 |         Scanner scan = new Scanner(System.in);
34 |         String s = scan.next();
35 |         int k = scan.nextInt();
36 |         scan.close();
37 |       
38 |         System.out.println(getSmallestAndLargest(s, k));
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/LinkedListJa.java:
--------------------------------------------------------------------------------
 1 | // Run on online compiler
 2 | import java.lang.String;
 3 | import java.util.*;
 4 | public class Main {
 5 | 
 6 | 	public static void main(String[] args) {
 7 | 		// TODO Auto-generated method stub
 8 | 		LinkedList<String> name=new LinkedList<String>();
 9 | 		name.add("Priyanshu");
10 | 		name.add("Singh");
11 | 		/* name.removeLast(); // to remove last element in list
12 | 		 * name.removeFirst(); // to remove first element is list
13 | 		 * name.clear(); // to clear all
14 | 		 * System.out.println(name.size()); //to print the size of list
15 | 		 * name.add(1,"Pk") // to add the element at particular place
16 | 		 * name.remove(1); // to remove the element at particular place
17 | 		 * name.set(1,"Patrick") // to add it at particular position by replacing
18 | 		 */
19 | 		for (String x:name)
20 | 			System.out.println(x);
21 | 	}
22 | 
23 | }
24 | 


--------------------------------------------------------------------------------
/Pattern Syntax Checker:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | import java.util.regex.*;
 3 | 
 4 | public class Solution
 5 | {
 6 | 	public static void main(String[] args){
 7 | 		Scanner in = new Scanner(System.in);
 8 | 		int testCases = Integer.parseInt(in.nextLine());
 9 | 		while(testCases>0){
10 | 			String pattern = in.nextLine();
11 |             try {
12 |                 Pattern.compile(pattern);
13 |                 System.out.println("Valid");
14 |             } catch (PatternSyntaxException e) {
15 |                 System.out.println("Invalid");
16 |             }
17 |             testCases--;
18 | 		}
19 | 	}
20 | }
21 | 
22 | 
23 | 
24 | 


--------------------------------------------------------------------------------
/Project Euler #145: How many reversible numbers are there below one-billion?:
--------------------------------------------------------------------------------
 1 | n = [int(input()) for i in range(0,int(input()))]
 2 | def reverse(x):
 3 |     return int(str(x)[::-1])
 4 | def isInputOdd(x):
 5 |     lis = str(x)
 6 |     for i in lis:
 7 |         if int(i)%2==0:
 8 |             flag = False
 9 |             return flag
10 |         else:
11 |             flag = True
12 |     return flag
13 | def main(iter):    
14 |     sum1=0
15 |     for i in range(iter):
16 |         k = i + reverse(i)
17 |         if i%10!=0 and isInputOdd(k):
18 |             sum1+=1
19 |     print (sum1)
20 | for i in n:
21 |     main(i)
22 | 


--------------------------------------------------------------------------------
/Project Euler #30: Digit Nth powers:
--------------------------------------------------------------------------------
1 | n=int(input())
2 | print(sum([i for i in range(n**2,10**6) if i==sum(int(z)**n for z in str(i))]))
3 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <h1 align=center><b>Java Hackcerank Solutions</b></h1>
 2 | 
 3 | ---
 4 | <img src=hack.png wigth=40 height=80></img>
 5 | 
 6 | ---
 7 | <p> Here you can find the link of all latest <b><i>Java HackerRank</i></b> Solution</p>
 8 |   
 9 |   - [Array List](https://github.com/Psingh12354/Java-HackeRank/blob/master/ArrayList.java)
10 |   - [Array List Name](https://github.com/Psingh12354/Java-HackeRank/blob/master/ArrayListName.java)
11 |   - [Java 1D Array](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%201D%20Array)
12 |   - [Java 2D Array](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%202D%20Array)
13 |   - [Java Abstract Class](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Abstract%20Class)
14 |   - [Java Big Decimal](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20BigDecimal)
15 |   - [Java Big Integer](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20BigInteger)
16 |   - [Java Comparator](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Comparator)
17 |   - [Java Datatype](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Datatypes)
18 |   - [Java Date and Time](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Date%20and%20Time)
19 |   - [Java End of File](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20End-of-file)
20 |   - [Java Exception Handling(Try Catch)](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Exception%20Handling%20(Try-catch))
21 |   - [Java Generics](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Generics)
22 |   - [Java Hashset](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Hashset)
23 |   - [Java If-Else](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20If-Else.java)
24 |   - [Java Inheritance 1](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Inheritance%20I)
25 |   - [Java Inheritance 2](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Inheritance%20II)
26 |   - [Java Instanceof Keyword](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Instanceof%20keyword)
27 |   - [Java Interface](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Interface)
28 |   - [Java Iterator](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Iterator)
29 |   - [Java List](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20List)
30 |   - [Java Loops 1](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Loops%20I.java)
31 |   - [Java Loops 2](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Loops%20II)
32 |   - [Java Method Overriding](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Method%20Overriding)
33 |   - [Java Method Overriding(Super Keyword)](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Method%20Overriding%202%20(Super%20Keyword))
34 |   - [Java Output Formating](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Output%20Formatting.java)  
35 |   - [Java Primarility Test](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Primality%20Test)
36 |   - [Java Stdin and Stdout 1](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Stdin%20and%20Stdout%20I.java)
37 |   - [Java Stdin and Stdout 1](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Stdin%20and%20Stdout%20II.java)
38 |   - [Java Strings Reverse](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20String%20Reverse) 
39 |   - [Java Strings Reverse Hack](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20String%20Reverse%20Hack)
40 |   - [Java Strings Tokens](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20String%20Tokens)
41 |   - [Java Strings Introduction](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Strings%20Introduction)
42 |   - [Java Substring](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Substring) 
43 |   - [Java SubString Comparision](https://github.com/Psingh12354/Java-HackeRank/blob/master/Java%20Substring%20Comparisons)
44 |   - [Linked List](https://github.com/Psingh12354/Java-HackeRank/blob/master/LinkedListJa.java)
45 |   - [Pattern Syntax Checker](https://github.com/Psingh12354/Java-HackeRank/blob/master/Pattern%20Syntax%20Checker)
46 |   - [Welcome To Java](https://github.com/Psingh12354/Java-HackeRank/blob/master/Welcome%20to%20Java!.java) 
47 | 
48 | <h3 align=center><b><i>Thank You</i></b></h3> 
49 | 


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


--------------------------------------------------------------------------------
/_config.yml:
--------------------------------------------------------------------------------
1 | theme: jekyll-theme-architect


--------------------------------------------------------------------------------
/hack.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Psingh12354/Java-HackeRank/a8f8c3e66a1953e7366d5ab2dce9ec4f4d145394/hack.png


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