UPDATED JAVA README'S

Author: chaudharypraveen98

Diff for: .DS_Store

@@ -1,2 +1,42 @@
-## **[Can You Access?](https://www.hackerrank.com/challenges/can-you-access)** 
-You are given a class Solution and an inner class Inner.Private. The main method of class Solution takes an integer as input. The powerof2 in class Inner.Private checks whether a number is a power of . You have to call the method powerof2 of the class Inner.Private from the main method of the class Solution.<br>Constraints<br><br>**Sample Input 0**<br><br>**Sample Output 0**<br><br>
+## [Can You Access?](https://www.hackerrank.com/challenges/can-you-access)
+
+![Java](https://img.shields.io/badge/java-%23ED8B00.svg?style=for-the-badge&logo=openjdk&logoColor=white) ![HackerRank](https://img.shields.io/badge/-Hackerrank-2EC866?style=for-the-badge&logo=HackerRank&logoColor=white)
+
+| Difficulty | Max Score | Success Ratio |
+|:-----------|:------------:|------------:|
+| Medium       | 15      | 96.78%        |
+
+You are given a class *Solution* and an inner class *Inner.Private*. The main method of class *Solution* takes an integer  *[SVG image]*  as input. The *powerof2* in class *Inner.Private* checks whether a number is a power of  *[SVG image]* . You have to call the method *powerof2* of the class *Inner.Private* from the *main* method of the class *Solution*.
+
+
+**Constraints**   
+
+ *[SVG image]* 
+
+**Sample Input**
+
+
+```
+8
+
+```
+**Sample Output**
+
+
+```
+8 is power of 2
+An instance of class: Solution.Inner.Private has been created
+
+```
+
+## 💡 Hints 
+
+## ➡️ Approach 
+
+## ✅ Detailed Solution
+[View Solution : Can You Access?](./Solution.java)
+
+| Submissions | Leaderboard| Discussions | Editorial |
+|:-----------|:------------:|------------:|------------:|
+| [📝 My Submission](https://www.hackerrank.com/challenges/can-you-access/submissions) | [🏆 Track our position](https://www.hackerrank.com/challenges/can-you-access/leaderboard) | [🤔 Help from Community](https://www.hackerrank.com/challenges/can-you-access/forum) | [✍️ Editorial](https://www.hackerrank.com/challenges/can-you-access/editorial) |
+

Diff for: Java/.DS_Store

@@ -1,2 +1,72 @@
-## **[Covariant Return Types](https://www.hackerrank.com/challenges/java-covariance)** 
-Java allows for Covariant Return Types, which means you can vary your return type as long you are returning a subclass of your specified return type.<br><a href="https://docs.oracle.com/javase/tutorial/java/IandI/override.html">Method Overriding</a> allows a subclass to <em>override</em> the behavior of an existing superclass method and specify a return type that is some subclass of the original return type. It is best practice to use the <code>@Override</code> <a href="https://docs.oracle.com/javase/tutorial/java/annotations/basics.html">annotation</a> when overriding a superclass method.<br>Implement the classes and methods detailed in the diagram below:<br><br>You will be given a partially completed code in the editor where the <em>main</em> method takes the name of a state (i.e., <code>WestBengal</code>, or <code>AndhraPradesh</code>) and prints the national flower of that state using the classes and methods written by you. <br>Note: Do not use access modifiers in your class declarations.<br>Resources<br><br>**Sample Input 0**<br><code></code><br><br>**Sample Output 0**<br><code></code><br><br>**Explanation 0**<br><br>
+## [Covariant Return Types](https://www.hackerrank.com/challenges/java-covariance)
+
+![Java](https://img.shields.io/badge/java-%23ED8B00.svg?style=for-the-badge&logo=openjdk&logoColor=white) ![HackerRank](https://img.shields.io/badge/-Hackerrank-2EC866?style=for-the-badge&logo=HackerRank&logoColor=white)
+
+| Difficulty | Max Score | Success Ratio |
+|:-----------|:------------:|------------:|
+| Easy       | 20      | 97.60%        |
+
+Java allows for [Covariant Return Types](https://docs.oracle.com/javase/tutorial/java/javaOO/returnvalue.html), which means you can vary your return type as long you are returning a subclass of your specified return type. 
+
+
+[Method Overriding](https://docs.oracle.com/javase/tutorial/java/IandI/override.html) allows a subclass to *override* the behavior of an existing superclass method and specify a return type that is some subclass of the original return type. It is best practice to use the `@Override` [annotation](https://docs.oracle.com/javase/tutorial/java/annotations/basics.html) when overriding a superclass method.
+
+
+Implement the classes and methods detailed in the diagram below:
+
+
+![image](https://s3.amazonaws.com/hr-assets/0/1523891844-c66f1555af-class.png)
+
+
+You will be given a partially completed code in the editor where the *main* method takes the name of a state (i.e., `WestBengal`, or `AndhraPradesh`) and prints the national flower of that state using the classes and methods written by you. 
+
+
+**Note:** *Do not* use access modifiers in your class declarations.
+
+
+**Resources**   
+
+[Covariant Return Type](http://c2.com/cgi/wiki?CovariantReturnTypes)   
+
+[Java Covariant Type](https://blogs.oracle.com/sundararajan/entry/covariant_return_types_in_java)
+
+**Input Format**
+
+The locked code reads a single string denoting the name of a subclass of *State* (i.e., `WestBengal`, `Karnataka`, or `AndhraPradesh`), then tests the methods associated with that subclass. You are not responsible for reading any input from stdin.
+
+**Output Format**
+
+Output is handled for you by the locked code, which creates the object corresponding to the input string's class name and then prints the name returned by that class' national flower's *whatsYourName* method. You are not responsible for printing anything to stdout.
+
+**Sample Input 0**
+
+
+```
+AndhraPradesh
+
+```
+
+**Sample Output 0**
+
+
+```
+Lily
+
+```
+
+**Explanation 0**
+
+An *AndhraPradesh* object's *yourNationalFlower* method returns an instance of the *Lily* class, and the *Lily* class' *whatsYourName* method returns `Lily`, which is printed by the hidden code checker.
+
+
+## 💡 Hints 
+
+## ➡️ Approach 
+
+## ✅ Detailed Solution
+[View Solution : Covariant Return Types](./Solution.java)
+
+| Submissions | Leaderboard| Discussions | Editorial |
+|:-----------|:------------:|------------:|------------:|
+| [📝 My Submission](https://www.hackerrank.com/challenges/java-covariance/submissions) | [🏆 Track our position](https://www.hackerrank.com/challenges/java-covariance/leaderboard) | [🤔 Help from Community](https://www.hackerrank.com/challenges/java-covariance/forum) | [✍️ Editorial](https://www.hackerrank.com/challenges/java-covariance/editorial) |
+

Diff for: Java/Hackerrank/Can You Access/README.md

@@ -0,0 +1,101 @@
+## [Java 1D Array (Part 2)](https://www.hackerrank.com/challenges/java-1d-array)
+
+![Java](https://img.shields.io/badge/java-%23ED8B00.svg?style=for-the-badge&logo=openjdk&logoColor=white) ![HackerRank](https://img.shields.io/badge/-Hackerrank-2EC866?style=for-the-badge&logo=HackerRank&logoColor=white)
+
+| Difficulty | Max Score | Success Ratio |
+|:-----------|:------------:|------------:|
+| Medium       | 25      | 72.28%        |
+
+Let's play a game on an array! You're standing at index  *[SVG image]*  of an  *[SVG image]* \-element array named  *[SVG image]* . From some index  *[SVG image]*  (where  *[SVG image]* ), you can perform one of the following moves:
+
+
+* *Move Backward:* If cell  *[SVG image]*  exists *and* contains a  *[SVG image]* , you can walk back to cell  *[SVG image]* .
+* *Move Forward:*
+	+ If cell  *[SVG image]*  contains a zero, you can walk to cell  *[SVG image]* .
+	+ If cell  *[SVG image]*  contains a zero, you can jump to cell  *[SVG image]* .
+	+ If you're standing in cell  *[SVG image]*  or the value of  *[SVG image]* , you can walk or jump off the end of the array and win the game.
+
+
+In other words, you can move from index  *[SVG image]*  to index  *[SVG image]* ,  *[SVG image]* , or  *[SVG image]*  as long as the destination index is a cell containing a  *[SVG image]* . If the destination index is greater than  *[SVG image]* , you win the game.
+
+
+**Function Description** 
+
+
+Complete the *canWin* function in the editor below. 
+
+
+*canWin* has the following parameters: 
+
+
+* *int leap:* the size of the leap
+* *int game\[n]:* the array to traverse
+
+
+**Returns** 
+
+
+* *boolean:* true if the game can be won, otherwise false
+**Input Format**
+
+The first line contains an integer,  *[SVG image]* , denoting the number of queries (i.e., function calls).   
+
+The  *[SVG image]*  subsequent lines describe each query over two lines:
+
+
+1. The first line contains two space\-separated integers describing the respective values of  *[SVG image]*  and  *[SVG image]* .
+2. The second line contains  *[SVG image]*  space\-separated binary integers (i.e., zeroes and ones) describing the respective values of  *[SVG image]* .
+**Constraints**
+
+* *[SVG image]*
+* *[SVG image]*
+* *[SVG image]*
+* It is guaranteed that the value of  *[SVG image]*  is always  *[SVG image]* .
+**Sample Input**
+
+
+```
+STDIN           Function
+-----           --------
+4               q = 4 (number of queries)
+5 3             game[] size n = 5, leap = 3 (first query)
+0 0 0 0 0       game = [0, 0, 0, 0, 0]
+6 5             game[] size n = 6, leap = 5 (second query)
+0 0 0 1 1 1     . . .
+6 3
+0 0 1 1 1 0
+3 1
+0 1 0
+
+```
+**Sample Output**
+
+
+```
+YES
+YES
+NO
+NO
+
+```
+**Explanation**
+
+We perform the following  *[SVG image]*  queries:
+
+
+1. For  *[SVG image]*  and  *[SVG image]* , we can walk and/or jump to the end of the array because every cell contains a  *[SVG image]* . Because we can win, we return *true*.
+2. For  *[SVG image]*  and  *[SVG image]* , we can walk to index  *[SVG image]*  and then jump  *[SVG image]*  units to the end of the array. Because we can win, we return *true*.
+3. For  *[SVG image]*  and  *[SVG image]* , there is no way for us to get past the three consecutive ones. Because we cannot win, we return *false*.
+4. For  *[SVG image]*  and  *[SVG image]* , there is no way for us to get past the one at index  *[SVG image]* . Because we cannot win, we return *false*.
+
+## 💡 Hints 
+
+## ➡️ Approach 
+
+## ✅ Detailed Solution
+[View Solution : Java 1D Array (Part 2)](./Solution.java)
+
+| Submissions | Leaderboard| Discussions | Editorial |
+|:-----------|:------------:|------------:|------------:|
+| [📝 My Submission](https://www.hackerrank.com/challenges/java-1d-array/submissions) | [🏆 Track our position](https://www.hackerrank.com/challenges/java-1d-array/leaderboard) | [🤔 Help from Community](https://www.hackerrank.com/challenges/java-1d-array/forum) | [✍️ Editorial](https://www.hackerrank.com/challenges/java-1d-array/editorial) |
+

Diff for: Java/Hackerrank/Covariant Return Types/README.md

@@ -1,2 +1,110 @@
-## **[Java 1D Array](https://www.hackerrank.com/challenges/java-1d-array-introduction)** 
-An array is a simple data structure used to store a collection of data in a contiguous block of memory. Each element in the collection is accessed using an index, and the elements are easy to find because they're stored sequentially in memory.<br>Because the collection of elements in an array is stored as a big block of data, we typically use arrays when we know exactly how many pieces of data we're going to have. For example, you might use an array to store a list of student ID numbers, or the names of state capitals. To create an array of integers named that can hold four integer values, you would write the following code:<br>This sets aside a block of memory that's capable of storing integers. Each integer storage cell is assigned a unique index ranging from to one less than the size of the array, and each cell initially contains a . In the case of , we can store integers at indices , , , and . Let's say we wanted the last cell to store the number ; to do this, we write:<br><br><br><br><br><br><br><br>**Sample Input 0**<br><br>**Sample Output 0**<br><br>**Explanation 0**<br><br>
+## [Java 1D Array](https://www.hackerrank.com/challenges/java-1d-array-introduction)
+
+![Java](https://img.shields.io/badge/java-%23ED8B00.svg?style=for-the-badge&logo=openjdk&logoColor=white) ![HackerRank](https://img.shields.io/badge/-Hackerrank-2EC866?style=for-the-badge&logo=HackerRank&logoColor=white)
+
+| Difficulty | Max Score | Success Ratio |
+|:-----------|:------------:|------------:|
+| Easy       | 5      | 97.29%        |
+
+An array is a simple data structure used to store a collection of data in a contiguous block of memory. Each element in the collection is accessed using an *index*, and the elements are easy to find because they're stored sequentially in memory. 
+
+
+Because the collection of elements in an array is stored as a big block of data, we typically use arrays when we know exactly how many pieces of data we're going to have. For example, you might use an array to store a list of student ID numbers, or the names of state capitals. To create an array of integers named  *[SVG image]*  that can hold four integer values, you would write the following code:
+
+
+
+```
+int[] myArray = new int[4];
+
+```
+
+This sets aside a block of memory that's capable of storing  *[SVG image]*  integers. Each integer storage cell is assigned a unique *index* ranging from  *[SVG image]*  to one less than the size of the array, and each cell initially contains a  *[SVG image]* . In the case of  *[SVG image]* , we can store integers at indices  *[SVG image]* ,  *[SVG image]* ,  *[SVG image]* , and  *[SVG image]* . Let's say we wanted the last cell to store the number  *[SVG image]* ; to do this, we write:
+
+
+
+```
+myArray[3] = 12;
+
+```
+
+Similarly, we can print the contents of the last cell with the following code:
+
+
+
+```
+System.out.println(myArray[3]);
+
+```
+
+The code above prints the value stored at index  *[SVG image]*  of  *[SVG image]* , which is  *[SVG image]*  (the value we previously stored there). It's important to note that while Java initializes each cell of an array of integers with a  *[SVG image]* , not all languages do this.
+
+
+**Task** 
+
+
+The code in your editor does the following:
+
+
+1. Reads an integer from stdin and saves it to a variable,  *[SVG image]* , denoting some number of integers.
+2. Reads  *[SVG image]*  integers corresponding to  *[SVG image]*  from stdin and saves each integer  *[SVG image]*  to a variable,  *[SVG image]* .
+3. Attempts to print each element of an array of integers named  *[SVG image]* .
+
+
+Write the following code in the unlocked portion of your editor:
+
+
+1. Create an array,  *[SVG image]* , capable of holding  *[SVG image]*  integers.
+2. Modify the code in the loop so that it saves each sequential value to its corresponding location in the array. For example, the first value must be stored in  *[SVG image]* , the second value must be stored in  *[SVG image]* , and so on.
+
+
+Good luck!
+
+**Input Format**
+
+The first line contains a single integer,  *[SVG image]* , denoting the size of the array.   
+
+Each line  *[SVG image]*  of the  *[SVG image]*  subsequent lines contains a single integer denoting the value of element  *[SVG image]* .
+
+**Output Format**
+
+You are not responsible for printing any output to stdout. Locked code in the editor loops through array  *[SVG image]*  and prints each sequential element on a new line.
+
+**Sample Input**
+
+
+```
+5
+10
+20
+30
+40
+50
+
+```
+**Sample Output**
+
+
+```
+10
+20
+30
+40
+50
+
+```
+**Explanation**
+
+When we save each integer to its corresponding index in  *[SVG image]* , we get  *[SVG image]* . The locked code prints each array element on a new line from left to right.
+
+
+## 💡 Hints 
+
+## ➡️ Approach 
+
+## ✅ Detailed Solution
+[View Solution : Java 1D Array](./Solution.java)
+
+| Submissions | Leaderboard| Discussions | Editorial |
+|:-----------|:------------:|------------:|------------:|
+| [📝 My Submission](https://www.hackerrank.com/challenges/java-1d-array-introduction/submissions) | [🏆 Track our position](https://www.hackerrank.com/challenges/java-1d-array-introduction/leaderboard) | [🤔 Help from Community](https://www.hackerrank.com/challenges/java-1d-array-introduction/forum) | [✍️ Editorial](https://www.hackerrank.com/challenges/java-1d-array-introduction/editorial) |
+