Merge branch 'master' of https://github.com/erickcernarequejo/Java-Questions-and-Solutions into erickcernar

Author: erickcernarequejo

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "java.project.sourcePaths": [
+        "Basic Codes",
+        "Number Theory"
+    ]
+}

Arrays/1D Arrays/maxLength_Of_Subarray.java

@@ -0,0 +1,41 @@
+
+import java.util.*;
+
+public class maxLength_Of_Subarray {
+    
+    public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int k = sc.nextInt();
+        int[] arr = new int[n];
+        for(int i = 0; i < n; i++){
+            arr[i] = sc.nextInt();
+        }
+        System.out.println(countSubarrays(arr,n,k));
+        sc.close();
+	}
+
+	public static int countSubarrays(int[] arr, int n, int k) {
+		
+		HashMap<Integer, Integer> map = new HashMap<>();  
+		int sum = 0, maxLen = 0;      // sum = prefix sum which stores sum of every element, maxlen = maximum length of sub array
+		for(int i = 0; i < n; i++){
+			sum += arr[i];
+			if(sum==k){
+				maxLen = i + 1;     // if k itself is present in the array then length will start from 0 to index of k 
+			}
+			if(!map.containsKey(sum)){     // putting frequencies of every sum
+				map.put(sum, i);
+			}
+			if(map.containsKey(sum-k)){
+				if(maxLen < (i-map.get(sum-k))){   // updating the maxlen variable from starting point of sub array to end point
+					maxLen = i - map.get(sum-k);
+				}
+			}
+		}
+		
+		return maxLen;
+			
+	}
+
+}

Bit Manipulation/PrintBinary.java

@@ -0,0 +1,47 @@
+/*
+Given a number print its Binary Representation using Bit Manipulation
+Examples:
+
+Input: 2
+Output: 10
+
+Input: 64
+Output: 1000000
+ */
+ 
+import java.util.Scanner;
+
+public class PrintBinary {
+
+    public static void main(String[] args) {
+
+        Scanner sc = new Scanner(System.in);
+
+        int num = sc.nextInt();
+
+        printBinary(num);
+    }
+
+    public static void printBinary(int num) {
+
+        if (num == 0) {
+            System.out.print(0);
+            return;
+        }
+
+        //Number of bits needed to represent a number in Binary
+        int bits = (int) (Math.log(num) / Math.log(2)) + 1;
+
+        for (int i = bits - 1; i >= 0; --i) {
+            //ith bit is set
+            if ((num & (1 << i)) != 0) {
+                System.out.print("1");
+            }
+            //ith bit is not set
+            else {
+                System.out.print("0");
+            }
+        }
+    }
+}
+

CodeChef/JavelinQualification.java

@@ -0,0 +1,83 @@
+/*
+There are N players with IDs from 1 to N, who are participating in the Javelin throw competition which has two rounds. The first is the qualification round, followed by the final round. The qualification round has gotten over, and you are given the longest distance that each of the N players has thrown as A1,A2,…,AN. Now, the selection process for the final round happens in the following two steps:
+
+If the longest throw of a player in the qualification round is greater than or equal to the qualification mark of M cm, they qualify for the final round.
+
+If after step 1, less than X players have qualified for the finals, the remaining spots are filled by players who have thrown the maximum distance among the players who have not qualified yet.
+
+You are given the best throws of the N players in the qualification round A1,A2,…,AN and the integers M and X. Print the list of the players who will qualify for the finals in increasing order of their IDs.
+
+Sample Input 1 
+3
+3 8000 2
+5000 5001 5002
+3 5000 2
+7999 7998 8000
+4 6000 3
+5999 5998 6000 6001
+
+Sample Output 1 
+2 2 3
+3 1 2 3
+3 1 3 4
+*/
+
+import java.util.*;
+
+public class JavelinQualification
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+		// your code goes here
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while(t-->0){
+		    int n = sc.nextInt();
+		    int m = sc.nextInt();
+		    int x = sc.nextInt();
+		    int[] arr = new int[n];             // creating array which stores throws of each player
+		    int[] player = new int[n];
+		    int count = 0;
+		    HashMap<Integer,Integer> map = new HashMap<>();
+		    int index = 0;
+		    for(int i = 0; i < n; i++){
+		        arr[i] = sc.nextInt();
+		        map.put(arr[i],i+1);
+		        if(arr[i]>=m){                // if the throw is qualified
+		            player[index] = i+1;      // storing selected players in 'player' array
+		            arr[i] = 0;
+		            count++;                  // storing count of qualified players
+		            x--;
+		            index++;
+		        }
+		    }
+		    while(x-->0){                   // getting remaining x player who are left
+		        int max1 = map.getOrDefault(max(arr, n),0); // creating variable to get index of maximum of the remaining players
+		        if(arr[max1-1]>0){          // checking if the player is not selected
+		            player[index] = max1;
+		            arr[max1-1] = 0;
+		            count++;
+		            index++;
+		        }
+		    }
+		    Arrays.sort(player);            // sorting player in increasing order
+		    System.out.print(count+" ");
+		    for(int i = 0; i < n; i++){
+		        if(player[i]!=0){           // if the player is qualified
+		            System.out.print(player[i]+" ");
+		        }
+		    }
+		    System.out.println();
+		}
+        sc.close();
+	}
+	static int max(int[] arr, int n){     // funtion to get maximum throw
+	    int max = Integer.MIN_VALUE;
+	    for(int i = 0; i < n; i++){
+	        if(max<arr[i]){
+	            max=arr[i];
+	        }
+	    }
+	    return max;
+	}
+}

CodeChef/MagicalDoors.java

@@ -0,0 +1,55 @@
+/* Question; 
+
+Chef wants to cross a hallway of N doors. These N doors are represented as a string. Each door is initially either open or close, represented by 1 or 0 respectively. Chef is required to go through all the doors one by one in the order that they appear, starting from the leftmost door and moving only rightwards at each step.
+
+To make the journey easier, Chef has a magic wand, using which Chef can flip the status of all the doors at once. Determine the minimum number of times Chef has to use this wand to cross the hallway of doors.
+
+For example, the doors are 10011. Chef will start from the left and enter the first door. After passing through that door, the magic wand is waved. This flips the string to 01100. Now Chef passes through the next two doors in one go. Again, just before reaching the 4th door, the magic wand is waved. Now that the string is in its original state, Chef passes through the last two doors as well. The minimum number of times the magic wand needed to be used here was 2.
+Input Format
+First line will contain T, number of testcases. Then the testcases follow.
+Each testcase contains of a single string S, representing the doors as given in the problem.
+Output Format
+For each test case, print a single line containing one integer denoting the minimum number of times the magic wand needs to be used.
+
+Sample Input
+3
+111
+010
+10011
+
+Sample Output
+0
+3
+2
+
+*/
+
+//code
+/* package codechef; // don't place package name! */
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+/* Name of the class has to be "Main" only if the class is public. */
+class MagicalDoors
+{   //Main Function
+    public static void main (String[] args) throws java.lang.Exception
+    {
+        Scanner in = new Scanner(System.in); //Scanner for taking input
+        int t = in.nextInt(); //Variable t for no of test case 
+        while(t>0)  //loop for every test case
+        {
+                
+             StringBuilder str = new StringBuilder(in.next()); //Taking input int String builder str
+             long res = 0;  //Variabe of long type for storing result
+             if(str.charAt(0) == '0')   //checking the first character of the string (Whether it is 0 or 1)
+             res++;  //if 0 then we are adding 1 to result
+             for(int i = 1; i<str.length(); i++) //for loop starting from 2nd character
+             {
+                 if(str.charAt(i) != str.charAt(i-1)) //Checking that is the previous charcter same or not
+                     res++; //if not same then adding 1 to result
+             }
+             System.out.println(res); //printing the result
+             t--; //decrementing the value of t
+        }     
+    }
+}

CodeChef/vaccination_queue.java

@@ -0,0 +1,54 @@
+/** There are N people in the vaccination queue, Chef is standing on the Pth position from the front of the queue. It takes X minutes to vaccinate a child and Y minutes to vaccinate an elderly person. Assume Chef is an elderly person.
+
+You are given a binary array A1,A2,…,AN of length N, where Ai=1 denotes there is an elderly person standing on the ith position of the queue, Ai=0 denotes there is a child standing on the ith position of the queue. You are also given the three integers P,X,Y. Find the number of minutes after which Chef's vaccination will be completed.
+
+Input Format
+First line will contain T, number of testcases. Then the testcases follow.
+The first line of each test case contains four space-separated integers N,P,X,Y.
+The second line of each test case contains N space-separated integer A1,A2,…,AN.
+Output Format
+For each testcase, output in a single line the number of minutes after which Chef's vaccination will be completed.**/
+
+import java.util.*;
+public class vaccination_queue
+{
+    public static void main(String args[]) //main function
+    {
+        Scanner in = new Scanner (System.in);
+        int t = in.nextInt();           // taking variable t for no. of test cases
+        while(t>0)
+        {
+            int n = in.nextInt();       //n = No.of people
+            int p = in.nextInt();       //p = Position of chef from front of the queue
+            int x = in.nextInt();       //x = Minutes taken to vaccinate a child
+            int y = in.nextInt();       //y = Minutes taken to vaccinate an elder
+            int countc =0;              //Counter that counts no of child present ahead of chef. 
+            int counta =0;              //Counter that counts no of elder present ahead of chef. 
+            int arr[] = new int[n];     //Array to store the position of people statnding in line.
+            //Loop For storing position of people where 1 stands for elder person and 0 stands for child.
+            for(int i =0;i<n;i++)       
+            {
+                arr[i] = in.nextInt();
+            }
+            //Loop to count all the children and elder person ahead of chef including the chef 
+            for(int j =0;j<p;j++)
+            {
+                if(arr[j]==0) //checking if the person is child then incrementing the counter
+                {
+                    countc++;
+                }
+                if(arr[j]==1) //checking if the person is elder then incrementing the counter
+                {
+                    counta++;
+                }
+                
+            }
+            int tmin = (countc*x)+(counta*y); //Calculating the total time taken by multiplying with the x and y given.
+            System.out.println(tmin); //printing the result
+            
+            
+            
+         t--;  //decrementing the value after running a testcase. 
+        }
+    }
+}

GeeksForGeeks/diagonal.java

@@ -0,0 +1,85 @@
+/* Given a 2D matrix, print all elements of the given matrix in diagonal order.
+For example, consider the following 5 X 4 input matrix.
+Example:
+
+1   2   3   4
+5   6   7   8
+9  10  11  12
+13 14  15  16
+17 18  19  20
+
+Diagonal printing of the above matrix is
+
+1
+5 2
+9 6 3
+13 10 7 4
+17 14 11 8
+18 15 12
+19 16
+20 */
+
+import java.io.*;
+class diagonal
+{
+    int [][]a;
+    int p,q;
+    diagonal() // A constructor
+    {
+        p=0;
+        q=0;
+    }
+    void input ()throws IOException  // A method to input the array order and elements.
+    {    InputStreamReader inp=new InputStreamReader(System.in); 
+         BufferedReader br=new BufferedReader(inp);
+         System.out.println("Enter the matrix order of the matrix");
+         p=Integer.parseInt(br.readLine());
+         q=Integer.parseInt(br.readLine());
+         a=new int[p][q]; // creating a 2D array.
+        System.out.println("now enter the matrix elements");
+        for(int i=0;i<p;i++)
+         {
+            for(int j=0;j<q;j++)
+            { a[i][j]=Integer.parseInt(br.readLine()); }
+           }
+          System.out.println("the matrix elements are"); 
+         for(int i=0;i<p;i++)
+         {
+            for(int j=0;j<q;j++)
+            { System.out.print(a[i][j]+"\t");}
+            System.out.println("\n");
+          }
+        }
+    void logic() // A method to print the diagonal elements.. 
+    {
+     /* The logic() method prints the elements on the diagonal one by one using their index positions 
+        Firstly starting with the number in the top most left corner. Then the number below it and the
+        number diagonaly oposite to it is printed, thus moving diagonaly from left to right.
+        */ 
+        
+       System.out.println("The diagonal elements of the matrix are"); 
+      for(int i=0;i<p;i++)                         //This part of the for loop prints diagonal elements..
+      {   int j=i;                                //until the principal diagonal(including elements on principal diagonal..
+          for(int x=0;x<=i && x<q;x++,j--)
+          {
+             System.out.print(a[j][x]+"\t");     
+            }
+         System.out.println();
+    }
+     for( int i=1;i<q;i++)                          //This part is for the elements that are below the principal diagonal... 
+     {
+         int j=p-1;
+       for(int x=i;x<q;x++,j--)                   //Doing a dry run of the code with some smaple inputs
+          {                                      // is suggested for understanding the logic() method
+             System.out.print(a[j][x]+"\t");
+            }
+            System.out.println();
+    }
+}
+public static void main(String[] args)throws IOException
+ {  
+    diagonal obj= new diagonal();
+    obj.input();
+    obj.logic();
+ }
+}