├── 2D Arrays ├── Array2D.java ├── JaggedArrays.java ├── LargestRowOrColumn.java ├── RowWiseSum.java ├── SpiralPrint.java └── WavePrint.java ├── Arrays ├── ArrangeElements.java ├── Array.java ├── ArrayIntersection.java ├── ArraySum.java ├── FindDuplicate.java ├── FindUnique.java ├── LinearSearch.java ├── PairSum.java ├── Sort01.java ├── SwapAlternate.java └── Triplet.java ├── Assignment Recursion ├── PairStar.java ├── RemoveX.java ├── ReplacePi.java ├── StringToInteger.java └── TowerOfHanoi.java ├── Conditionals ├── Factors.java ├── FarenheitToCelsius.java ├── IntToString.java ├── Multiplication_Table.java ├── PowerOfNumber.java ├── SumOfEvenAndOdd.java ├── SumOfEvenNoN.java ├── TotalSalary.java ├── checkPrime.java ├── findCharacterCase.java ├── ifElse.java └── whileLoop.java ├── DS Test 1 ├── DoesSContainT.java ├── MaximumProfitonApp.java └── SplitArray.java ├── For Loops ├── AllPrimeNumbers.java ├── BinaryToDecimal.java ├── CheckSequence.java ├── DecimalToBinary.java ├── NthFibonacci.java ├── ReverseOfANumber.java ├── SquareRoot.java ├── SumOrProduct.java └── TermsOfAP.java ├── Function Variables ├── Factorial.java ├── FarenheitToCelsiusTable.java ├── FibonacciNumber.java └── PrimeNumber.java ├── HelloWorld └── FirstProgram.java ├── LICENSE ├── Linked List 1 ├── AppendLastNToFirst.java ├── ArrayListUse.java ├── CheckPalindrome.java ├── DeleteANode.java ├── EliminateDuplicates.java ├── FindANode.java ├── LengthOfLL.java ├── LinkedListNode.java ├── PrintIthNode.java ├── PrintReverseLL.java └── Use.java ├── OOPS 1 ├── ArrayEmptyException.java ├── ComplexNumbers.java ├── ComplexNumbersUse.java ├── DynamicArray.java ├── DynamicArrayUse.java ├── Fraction.java ├── FractionUse.java ├── Polynomial.java ├── PolynomialUse.java ├── Student.java ├── StudentUse.java └── ZeroDenominatorException.java ├── OOPS 2 ├── Car.java ├── DenoMinatorZeroException.java ├── Main.java ├── Truck.java ├── TruckUse.java ├── Use.java ├── Vehicle.java └── VehicleUse.java ├── OOPS 3 ├── Car.java ├── CarInterface.java ├── Pair.java ├── Student.java ├── Use.java ├── Vehicle.java └── VehicleInterface.java ├── Pattern 2 ├── DiamondOfStars.java ├── HalfDiamondPattern.java ├── InvertedNumberPattern.java ├── InvertedTriangle1.java ├── InvertedTriangle2.java ├── IsocelesTriangle.java ├── IsocelesTriangleStarPattern.java ├── MirrorNumberPattern.java ├── OddSquare.java ├── ParallelogramPattern.java ├── ReverseTriangle.java ├── SumPattern.java └── TriangleOfNumbers.java ├── Patterns 1 ├── AlphaTriangle.java ├── CharacterPattern.java ├── CharacterPattern1.java ├── CharacterPattern2.java ├── InterestingAlphabets.java ├── Pattern1.java ├── Pattern2.java ├── Pattern3.java ├── Pattern4.java ├── Pattern5.java ├── RepeatingNumbers.java ├── ReverseNumberPattern.java ├── SquarePattern1.java ├── SquarePattern2.java ├── SquarePattern3.java ├── SquarePattern4.java ├── SquarePattern5.java ├── TraingularNumberPattern.java ├── TraingularStarPattern.java ├── TriangularPattern1.java ├── TriangularPattern2.java └── TriangularPattern3.java ├── README.md ├── Recursion 1 ├── AllIndexs.java ├── CheckNumberInArray.java ├── CheckPalindrome.java ├── CheckSorted.java ├── CountNumberOfDigits.java ├── CountZeroes.java ├── Factorial.java ├── Fibonacci.java ├── FirstIndex.java ├── GeometricSum.java ├── LastIndex.java ├── MultiplyTwoIntegers.java ├── Power.java ├── SumOfArrays.java ├── SumOfTheDigits.java ├── SumToN.java └── printNumbers.java ├── Recursion 2 ├── BinarySearch.java ├── CheckAB.java ├── MergeSort.java ├── QuickSort.java ├── RemoveDuplicates.java ├── RemoveX.java ├── ReplaceCharacters.java ├── Return_Print_Subsequences.java ├── Return_and_Print_Keypad_Problem.java ├── Return_and_Print_SubsetsOfArray.java ├── Return_and_Print_SubsetsSumToK.java ├── Return_and_Print_allCodes.java ├── Return_and_Print_permutations.java └── Staircase.java ├── Searching and Sorting ├── Array.java ├── BinarySearch.java ├── BubbleSort.java ├── CheckArrayRotation.java ├── InsertionSort.java ├── LinearSearch.java ├── MergeTwoArray.java ├── RotateArray.java ├── SecondLargest.java ├── SelectionSort.java ├── ShiftZeroes.java ├── Sort012.java └── SumTwoArrays.java ├── Strings ├── CheckPalindrome.java ├── CheckPermutations.java ├── CompressTheString.java ├── CountWords.java ├── HighestOccuringCharacter.java ├── PrintPrefix.java ├── RemoveAllOccurrencesOfChar.java ├── RemoveConsecutiveDuplicates.java ├── ReverseEachWord.java └── ReverseStringWordWise.java ├── Test 2 ├── LeadersOfArray.java ├── MinimumLengthWord.java └── Print2DArray.java ├── Test1 ├── CheckArmstrong.java ├── NumberStarPattern1.java └── ZeroesAndStarPattern.java ├── Time and Space Complexity ├── ArrayEquilibrium.java ├── ArrayIntersection.java ├── CheckArrayRotation.java ├── DuplicateInArray.java ├── PairSum.java ├── RotateArray.java ├── TripletSum.java └── UniqueElement.java └── Variables ├── Avgerage_Marks.java ├── Initialisation.java └── Input.java /2D Arrays/Array2D.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Array2D { 4 | 5 | public static int[][] takeInput() { 6 | Scanner scan=new Scanner(System.in); 7 | int row=scan.nextInt(); 8 | int col=scan.nextInt(); 9 | int[][] arr=new int[row][col]; 10 | for(int i=0;i=maxColSum ) { 36 | System.out.println("row "+maxRow+" "+maxRowSum); 37 | } 38 | else { 39 | System.out.println("column "+ maxCol+" "+maxColSum); 40 | } 41 | 42 | } 43 | 44 | 45 | public static void main(String[] args) { 46 | int[][] arr=Array2D.takeInput(); 47 | findLargest(arr); 48 | 49 | } 50 | 51 | } 52 | -------------------------------------------------------------------------------- /2D Arrays/RowWiseSum.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class RowWiseSum { 4 | 5 | public static void main(String[] args) { 6 | 7 | Scanner scan=new Scanner(System.in); 8 | int row=scan.nextInt(); 9 | int col=scan.nextInt(); 10 | int[][] arr=new int[row][col]; 11 | for(int i=0;i=cs;i--) { 24 | System.out.print(arr[re][i]+" "); 25 | count++; 26 | } 27 | re--; 28 | for(int i=re;i>=rs;i--) { 29 | System.out.print(arr[i][cs]+" "); 30 | count++; 31 | } 32 | cs++; 33 | } 34 | 35 | 36 | 37 | } 38 | 39 | public static void main(String[] args) { 40 | // TODO Auto-generated method stub 41 | int[][] arr=Array2D.takeInput(); 42 | spiralPrint(arr); 43 | 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /2D Arrays/WavePrint.java: -------------------------------------------------------------------------------- 1 | 2 | public class WavePrint { 3 | 4 | public static void wavePrint(int[][] arr) { 5 | int row=arr.length; 6 | int col=arr[0].length; 7 | for(int i=0;i=0;j--) { 14 | System.out.print(arr[j][i]+" "); 15 | } 16 | } 17 | } 18 | } 19 | 20 | public static void main(String[] args) { 21 | int[][] arr=Array2D.takeInput(); 22 | wavePrint(arr); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Arrays/ArrangeElements.java: -------------------------------------------------------------------------------- 1 | 2 | public class ArrangeElements { 3 | 4 | public static int[] arrange(int n) { 5 | 6 | int[] arr=new int[n]; 7 | int left=0,right=n-1,counter=1; 8 | while(left<=right) { 9 | if(counter%2==1) { 10 | arr[left++]=counter; 11 | }else { 12 | arr[right--]=counter; 13 | } 14 | counter++; 15 | } 16 | 17 | 18 | return arr; 19 | 20 | 21 | } 22 | 23 | public static void main(String[] args) { 24 | // TODO Auto-generated method stub 25 | int[] arr=arrange(11); 26 | for(int i : arr) { 27 | System.out.print(i+" "); 28 | } 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /Arrays/Array.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Array { 4 | 5 | 6 | public static int[] takeInput() { 7 | Scanner s=new Scanner(System.in); 8 | int n=s.nextInt(); 9 | int[] arr=new int[n]; 10 | for(int i=0;i map=new HashMap<>(); 28 | for(int i : arr1) { 29 | if(map.containsKey(i)) { 30 | map.put(i, map.get(i) + 1); 31 | }else { 32 | map.put(i,1); 33 | } 34 | } 35 | for(int j : arr2) { 36 | 37 | if(map.containsKey(j) && map.get(j)!=0 ) { 38 | System.out.println(j); 39 | map.put(j, map.get(j)-1); 40 | } 41 | 42 | } 43 | 44 | 45 | 46 | 47 | } 48 | 49 | public static void main(String[] args) { 50 | // TODO Auto-generated method stub 51 | 52 | int[] arr1=Array.takeInput(); 53 | int[] arr2=Array.takeInput(); 54 | 55 | arrayIntersectionBest(arr1, arr2); 56 | 57 | } 58 | 59 | } 60 | -------------------------------------------------------------------------------- /Arrays/ArraySum.java: -------------------------------------------------------------------------------- 1 | 2 | public class ArraySum { 3 | 4 | public static int sum(int[] input) { 5 | int sum=0; 6 | for(int i : input) { 7 | sum+=i; 8 | } 9 | return sum; 10 | } 11 | public static void main(String[] args) { 12 | 13 | int[] arr= {1,2,3,4,7,8}; 14 | System.out.println(sum(arr)); 15 | 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Arrays/FindDuplicate.java: -------------------------------------------------------------------------------- 1 | 2 | public class FindDuplicate { 3 | 4 | public static int findDuplicate(int[] arr) { 5 | 6 | for(int i=0;i map=new HashMap(); 53 | for(int i : arr) { 54 | 55 | if( map.containsKey(sum-i)) { 56 | for(int count=0;count=b && a>=c && b>=c) { 9 | System.out.println(c+" " +b+" "+a); 10 | }else if(a>=b && a>=c && c>=b) { 11 | System.out.println(b+" " +c+" "+a); 12 | }else if(b>=a && b>=c && a>=c) { 13 | System.out.println(c+" " +a+" "+b); 14 | }else if(b>=a && b >=c && c>=a) { 15 | System.out.println(a+" " +c+" "+b); 16 | }else if(c>=a && c>=b && a>=b) { 17 | System.out.println(b+" " +a+" "+c); 18 | }else if(c>=a && c>=b && b>=a) { 19 | System.out.println(a+" " +b+" "+c); 20 | } 21 | 22 | 23 | } 24 | 25 | public static void tripletSum(int[] arr,int sum) { 26 | 27 | for(int i=0;i0) { 10 | int a=n%10; 11 | if(a%2==0) { 12 | evenSum+=a; 13 | }else { 14 | oddSum+=a; 15 | } 16 | n=n/10; 17 | } 18 | System.out.println("Even Sum= "+evenSum); 19 | System.out.println("Odd Sum="+oddSum); 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /Conditionals/SumOfEvenNoN.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class SumOfEvenNoN { 4 | 5 | 6 | public static void main(String[] args) { 7 | // TODO Auto-generated method stu 8 | 9 | Scanner scan=new Scanner(System.in); 10 | int n=scan.nextInt(); 11 | int sum=0; 12 | for(int i=0;i<=n;i+=2) { 13 | sum+=i; 14 | } 15 | System.out.println(sum); 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Conditionals/TotalSalary.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class TotalSalary { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int bs=scan.nextInt(); 10 | String grade=scan.next(); 11 | double hra=0.2*bs; 12 | double da=0.5*bs; 13 | int allow=1300; 14 | if(grade.charAt(0)=='A') { 15 | allow=1700; 16 | } 17 | else if(grade.charAt(0)=='B') { 18 | allow=1500; 19 | } 20 | double pf=0.11*bs; 21 | 22 | int totalSalary=(int)(Math.round(bs+hra+da+allow-pf)); 23 | System.out.println(totalSalary); 24 | 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /Conditionals/checkPrime.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class checkPrime { 4 | 5 | public static void main(String[] args) { 6 | Scanner scan=new Scanner(System.in); 7 | int i=2; 8 | int n=scan.nextInt(); 9 | while(i='A' && c<='Z') { 12 | System.out.println(1); 13 | }else if(c>='a' && c<='z') { 14 | System.out.println(0); 15 | }else { 16 | System.out.println(-1); 17 | } 18 | 19 | 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /Conditionals/ifElse.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class ifElse { 3 | public static void main(String[] args) { 4 | Scanner scan=new Scanner(System.in); 5 | // int n=scan.nextInt(); 6 | // if(n%2==0) { 7 | // System.out.println("Even"); 8 | // return; 9 | // } 10 | // System.out.println("Odd"); 11 | int a=scan.nextInt(); 12 | int b=scan.nextInt(); 13 | int c=scan.nextInt(); 14 | if(a>=b && a>=c) { 15 | System.out.println(a); 16 | } 17 | else if(b>=a && b>=c) { 18 | System.out.println(b); 19 | }else { 20 | System.out.println(c); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Conditionals/whileLoop.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class whileLoop { 4 | 5 | 6 | 7 | public static void main(String[] args) { 8 | Scanner scan=new Scanner(System.in); 9 | int i=1; 10 | int n=scan.nextInt(); 11 | while(i<=n) { 12 | System.out.println(i); 13 | i++; 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /DS Test 1/DoesSContainT.java: -------------------------------------------------------------------------------- 1 | 2 | public class DoesSContainT { 3 | 4 | 5 | public static boolean doesScontainsT(String s,String t) { 6 | 7 | if(s.length() < t.length()) { 8 | return false; 9 | } 10 | 11 | 12 | int j=0; 13 | 14 | for(int i=0;iend) { 12 | 13 | return lSum==rSum; 14 | 15 | } 16 | if(arr[start] % 5==0) { 17 | return splitArray(arr, start+1, end, lSum + arr[start], rSum); 18 | } 19 | else if(arr[start] %3==0) { 20 | return splitArray(arr, start+1, end, lSum, rSum+arr[start]); 21 | } 22 | else { 23 | return splitArray(arr, start+1, end, lSum+arr[start], rSum) || splitArray(arr, start+1, end, lSum, rSum+arr[start]); 24 | } 25 | 26 | 27 | 28 | } 29 | 30 | public static void main(String[] args) { 31 | int[] arr= {1,4,7,4}; 32 | System.out.println(spiltArray(arr)); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /For Loops/AllPrimeNumbers.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class AllPrimeNumbers { 4 | 5 | public static void main(String[] args) { 6 | 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=2;i<=n;i++) { 10 | boolean isPrime=true; 11 | for(int j=2;j0) { 12 | int a=n%10; 13 | res=res+(a*(int)Math.pow(2, p++)); 14 | n=n/10; 15 | } 16 | System.out.println(res); 17 | 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /For Loops/CheckSequence.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class CheckSequence { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | int pre=scan.nextInt(); 10 | int i=1; 11 | boolean isDec=true; 12 | int count=0; 13 | while(i<=n-1) { 14 | int curr=scan.nextInt(); 15 | if(pre==curr) { 16 | System.out.println(false); 17 | return ; 18 | } 19 | else if(pre0) { 11 | int a=n%2; 12 | res=res+a*(long)Math.pow(10,p++); 13 | n=n/2; 14 | } 15 | System.out.println(res); 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /For Loops/NthFibonacci.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class NthFibonacci { 4 | 5 | public static void main(String[] args) { 6 | Scanner scan=new Scanner(System.in); 7 | int n=scan.nextInt(); 8 | int a=0; 9 | int b=1; 10 | for(int i=1;i<=n;i++) { 11 | int c=a+b; 12 | a=b; 13 | b=c; 14 | } 15 | System.out.println(a); 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /For Loops/ReverseOfANumber.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class ReverseOfANumber { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | int res=0; 10 | while(n>0) { 11 | int a=n%10; 12 | res=res*10+a; 13 | n=n/10; 14 | } 15 | System.out.println(res); 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /For Loops/SquareRoot.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class SquareRoot { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | int i=0,sq=0; 10 | while(i*i<=n) { 11 | sq=i; 12 | i++; 13 | } 14 | 15 | System.out.println(sq); 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /For Loops/SumOrProduct.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class SumOrProduct { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | int a=scan.nextInt(); 10 | if(a==1) { 11 | int sum=0; 12 | for(int i=1;i<=n;i++) { 13 | sum+=i; 14 | } 15 | System.out.println(sum); 16 | } 17 | else if(a==2) { 18 | int p=1; 19 | for(int i=1;i<=n;i++) { 20 | p*=i; 21 | } 22 | System.out.println(p); 23 | } 24 | else { 25 | System.out.println(-1); 26 | } 27 | 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /For Loops/TermsOfAP.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class TermsOfAP { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | int count=1; 10 | int i=1; 11 | while(count<=n) { 12 | int sum=3*i+2; 13 | if(sum%4!=0) { 14 | System.out.print(sum+" "); 15 | count++; 16 | } 17 | i++; 18 | } 19 | 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /Function Variables/Factorial.java: -------------------------------------------------------------------------------- 1 | 2 | public class Factorial { 3 | 4 | 5 | public static int factorial(int n) { 6 | 7 | int fact=1; 8 | for(int i=1;i<=n;i++) { 9 | fact*=i; 10 | } 11 | return fact; 12 | 13 | } 14 | public static int nCr(int n,int r) { 15 | 16 | int num= factorial(n); 17 | int deno=factorial(n-r) * factorial(r); 18 | return num/deno; 19 | 20 | } 21 | public static void main(String[] args) { 22 | int num=factorial(6); 23 | System.out.println(num); 24 | System.out.println(nCr(10, 6)); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /Function Variables/FarenheitToCelsiusTable.java: -------------------------------------------------------------------------------- 1 | 2 | public class FarenheitToCelsiusTable { 3 | 4 | 5 | public static void printFahrenheitTable(int start,int end,int step) { 6 | 7 | for(int i=start;i<=end;i+=step) { 8 | 9 | System.out.println( i +"\t" + (int)((5.0/9)*(i-32)) ); 10 | } 11 | 12 | } 13 | 14 | public static void main(String[] args) { 15 | 16 | printFahrenheitTable(0, 100, 20); 17 | 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /Function Variables/FibonacciNumber.java: -------------------------------------------------------------------------------- 1 | 2 | public class FibonacciNumber { 3 | 4 | public static boolean checkMember(int n) { 5 | 6 | int a=0; 7 | int b=1; 8 | while(a 5 | Everyone is permitted to copy and distribute verbatim copies 6 | of this license document, but changing it is not allowed. 7 | 8 | Preamble 9 | 10 | The GNU General Public License is a free, copyleft license for 11 | software and other kinds of works. 12 | 13 | The licenses for most software and other practical works are designed 14 | to take away your freedom to share and change the works. By contrast, 15 | the GNU General Public License is intended to guarantee your freedom to 16 | share and change all versions of a program--to make sure it remains free 17 | software for all its users. We, the Free Software Foundation, use the 18 | GNU General Public License for most of our software; it applies also to 19 | any other work released this way by its authors. You can apply it to 20 | your programs, too. 21 | 22 | When we speak of free software, we are referring to freedom, not 23 | price. Our General Public Licenses are designed to make sure that you 24 | have the freedom to distribute copies of free software (and charge for 25 | them if you wish), that you receive source code or can get it if you 26 | want it, that you can change the software or use pieces of it in new 27 | free programs, and that you know you can do these things. 28 | 29 | To protect your rights, we need to prevent others from denying you 30 | these rights or asking you to surrender the rights. Therefore, you have 31 | certain responsibilities if you distribute copies of the software, or if 32 | you modify it: responsibilities to respect the freedom of others. 33 | 34 | For example, if you distribute copies of such a program, whether 35 | gratis or for a fee, you must pass on to the recipients the same 36 | freedoms that you received. You must make sure that they, too, receive 37 | or can get the source code. And you must show them these terms so they 38 | know their rights. 39 | 40 | Developers that use the GNU GPL protect your rights with two steps: 41 | (1) assert copyright on the software, and (2) offer you this License 42 | giving you legal permission to copy, distribute and/or modify it. 43 | 44 | For the developers' and authors' protection, the GPL clearly explains 45 | that there is no warranty for this free software. For both users' and 46 | authors' sake, the GPL requires that modified versions be marked as 47 | changed, so that their problems will not be attributed erroneously to 48 | authors of previous versions. 49 | 50 | Some devices are designed to deny users access to install or run 51 | modified versions of the software inside them, although the manufacturer 52 | can do so. This is fundamentally incompatible with the aim of 53 | protecting users' freedom to change the software. The systematic 54 | pattern of such abuse occurs in the area of products for individuals to 55 | use, which is precisely where it is most unacceptable. Therefore, we 56 | have designed this version of the GPL to prohibit the practice for those 57 | products. If such problems arise substantially in other domains, we 58 | stand ready to extend this provision to those domains in future versions 59 | of the GPL, as needed to protect the freedom of users. 60 | 61 | Finally, every program is threatened constantly by software patents. 62 | States should not allow patents to restrict development and use of 63 | software on general-purpose computers, but in those that do, we wish to 64 | avoid the special danger that patents applied to a free program could 65 | make it effectively proprietary. To prevent this, the GPL assures that 66 | patents cannot be used to render the program non-free. 67 | 68 | The precise terms and conditions for copying, distribution and 69 | modification follow. 70 | 71 | TERMS AND CONDITIONS 72 | 73 | 0. Definitions. 74 | 75 | "This License" refers to version 3 of the GNU General Public License. 76 | 77 | "Copyright" also means copyright-like laws that apply to other kinds of 78 | works, such as semiconductor masks. 79 | 80 | "The Program" refers to any copyrightable work licensed under this 81 | License. Each licensee is addressed as "you". "Licensees" and 82 | "recipients" may be individuals or organizations. 83 | 84 | To "modify" a work means to copy from or adapt all or part of the work 85 | in a fashion requiring copyright permission, other than the making of an 86 | exact copy. The resulting work is called a "modified version" of the 87 | earlier work or a work "based on" the earlier work. 88 | 89 | A "covered work" means either the unmodified Program or a work based 90 | on the Program. 91 | 92 | To "propagate" a work means to do anything with it that, without 93 | permission, would make you directly or secondarily liable for 94 | infringement under applicable copyright law, except executing it on a 95 | computer or modifying a private copy. Propagation includes copying, 96 | distribution (with or without modification), making available to the 97 | public, and in some countries other activities as well. 98 | 99 | To "convey" a work means any kind of propagation that enables other 100 | parties to make or receive copies. Mere interaction with a user through 101 | a computer network, with no transfer of a copy, is not conveying. 102 | 103 | An interactive user interface displays "Appropriate Legal Notices" 104 | to the extent that it includes a convenient and prominently visible 105 | feature that (1) displays an appropriate copyright notice, and (2) 106 | tells the user that there is no warranty for the work (except to the 107 | extent that warranties are provided), that licensees may convey the 108 | work under this License, and how to view a copy of this License. If 109 | the interface presents a list of user commands or options, such as a 110 | menu, a prominent item in the list meets this criterion. 111 | 112 | 1. Source Code. 113 | 114 | The "source code" for a work means the preferred form of the work 115 | for making modifications to it. "Object code" means any non-source 116 | form of a work. 117 | 118 | A "Standard Interface" means an interface that either is an official 119 | standard defined by a recognized standards body, or, in the case of 120 | interfaces specified for a particular programming language, one that 121 | is widely used among developers working in that language. 122 | 123 | The "System Libraries" of an executable work include anything, other 124 | than the work as a whole, that (a) is included in the normal form of 125 | packaging a Major Component, but which is not part of that Major 126 | Component, and (b) serves only to enable use of the work with that 127 | Major Component, or to implement a Standard Interface for which an 128 | implementation is available to the public in source code form. A 129 | "Major Component", in this context, means a major essential component 130 | (kernel, window system, and so on) of the specific operating system 131 | (if any) on which the executable work runs, or a compiler used to 132 | produce the work, or an object code interpreter used to run it. 133 | 134 | The "Corresponding Source" for a work in object code form means all 135 | the source code needed to generate, install, and (for an executable 136 | work) run the object code and to modify the work, including scripts to 137 | control those activities. However, it does not include the work's 138 | System Libraries, or general-purpose tools or generally available free 139 | programs which are used unmodified in performing those activities but 140 | which are not part of the work. For example, Corresponding Source 141 | includes interface definition files associated with source files for 142 | the work, and the source code for shared libraries and dynamically 143 | linked subprograms that the work is specifically designed to require, 144 | such as by intimate data communication or control flow between those 145 | subprograms and other parts of the work. 146 | 147 | The Corresponding Source need not include anything that users 148 | can regenerate automatically from other parts of the Corresponding 149 | Source. 150 | 151 | The Corresponding Source for a work in source code form is that 152 | same work. 153 | 154 | 2. Basic Permissions. 155 | 156 | All rights granted under this License are granted for the term of 157 | copyright on the Program, and are irrevocable provided the stated 158 | conditions are met. This License explicitly affirms your unlimited 159 | permission to run the unmodified Program. The output from running a 160 | covered work is covered by this License only if the output, given its 161 | content, constitutes a covered work. This License acknowledges your 162 | rights of fair use or other equivalent, as provided by copyright law. 163 | 164 | You may make, run and propagate covered works that you do not 165 | convey, without conditions so long as your license otherwise remains 166 | in force. You may convey covered works to others for the sole purpose 167 | of having them make modifications exclusively for you, or provide you 168 | with facilities for running those works, provided that you comply with 169 | the terms of this License in conveying all material for which you do 170 | not control copyright. Those thus making or running the covered works 171 | for you must do so exclusively on your behalf, under your direction 172 | and control, on terms that prohibit them from making any copies of 173 | your copyrighted material outside their relationship with you. 174 | 175 | Conveying under any other circumstances is permitted solely under 176 | the conditions stated below. Sublicensing is not allowed; section 10 177 | makes it unnecessary. 178 | 179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law. 180 | 181 | No covered work shall be deemed part of an effective technological 182 | measure under any applicable law fulfilling obligations under article 183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or 184 | similar laws prohibiting or restricting circumvention of such 185 | measures. 186 | 187 | When you convey a covered work, you waive any legal power to forbid 188 | circumvention of technological measures to the extent such circumvention 189 | is effected by exercising rights under this License with respect to 190 | the covered work, and you disclaim any intention to limit operation or 191 | modification of the work as a means of enforcing, against the work's 192 | users, your or third parties' legal rights to forbid circumvention of 193 | technological measures. 194 | 195 | 4. Conveying Verbatim Copies. 196 | 197 | You may convey verbatim copies of the Program's source code as you 198 | receive it, in any medium, provided that you conspicuously and 199 | appropriately publish on each copy an appropriate copyright notice; 200 | keep intact all notices stating that this License and any 201 | non-permissive terms added in accord with section 7 apply to the code; 202 | keep intact all notices of the absence of any warranty; and give all 203 | recipients a copy of this License along with the Program. 204 | 205 | You may charge any price or no price for each copy that you convey, 206 | and you may offer support or warranty protection for a fee. 207 | 208 | 5. Conveying Modified Source Versions. 209 | 210 | You may convey a work based on the Program, or the modifications to 211 | produce it from the Program, in the form of source code under the 212 | terms of section 4, provided that you also meet all of these conditions: 213 | 214 | a) The work must carry prominent notices stating that you modified 215 | it, and giving a relevant date. 216 | 217 | b) The work must carry prominent notices stating that it is 218 | released under this License and any conditions added under section 219 | 7. This requirement modifies the requirement in section 4 to 220 | "keep intact all notices". 221 | 222 | c) You must license the entire work, as a whole, under this 223 | License to anyone who comes into possession of a copy. This 224 | License will therefore apply, along with any applicable section 7 225 | additional terms, to the whole of the work, and all its parts, 226 | regardless of how they are packaged. This License gives no 227 | permission to license the work in any other way, but it does not 228 | invalidate such permission if you have separately received it. 229 | 230 | d) If the work has interactive user interfaces, each must display 231 | Appropriate Legal Notices; however, if the Program has interactive 232 | interfaces that do not display Appropriate Legal Notices, your 233 | work need not make them do so. 234 | 235 | A compilation of a covered work with other separate and independent 236 | works, which are not by their nature extensions of the covered work, 237 | and which are not combined with it such as to form a larger program, 238 | in or on a volume of a storage or distribution medium, is called an 239 | "aggregate" if the compilation and its resulting copyright are not 240 | used to limit the access or legal rights of the compilation's users 241 | beyond what the individual works permit. Inclusion of a covered work 242 | in an aggregate does not cause this License to apply to the other 243 | parts of the aggregate. 244 | 245 | 6. Conveying Non-Source Forms. 246 | 247 | You may convey a covered work in object code form under the terms 248 | of sections 4 and 5, provided that you also convey the 249 | machine-readable Corresponding Source under the terms of this License, 250 | in one of these ways: 251 | 252 | a) Convey the object code in, or embodied in, a physical product 253 | (including a physical distribution medium), accompanied by the 254 | Corresponding Source fixed on a durable physical medium 255 | customarily used for software interchange. 256 | 257 | b) Convey the object code in, or embodied in, a physical product 258 | (including a physical distribution medium), accompanied by a 259 | written offer, valid for at least three years and valid for as 260 | long as you offer spare parts or customer support for that product 261 | model, to give anyone who possesses the object code either (1) a 262 | copy of the Corresponding Source for all the software in the 263 | product that is covered by this License, on a durable physical 264 | medium customarily used for software interchange, for a price no 265 | more than your reasonable cost of physically performing this 266 | conveying of source, or (2) access to copy the 267 | Corresponding Source from a network server at no charge. 268 | 269 | c) Convey individual copies of the object code with a copy of the 270 | written offer to provide the Corresponding Source. This 271 | alternative is allowed only occasionally and noncommercially, and 272 | only if you received the object code with such an offer, in accord 273 | with subsection 6b. 274 | 275 | d) Convey the object code by offering access from a designated 276 | place (gratis or for a charge), and offer equivalent access to the 277 | Corresponding Source in the same way through the same place at no 278 | further charge. You need not require recipients to copy the 279 | Corresponding Source along with the object code. If the place to 280 | copy the object code is a network server, the Corresponding Source 281 | may be on a different server (operated by you or a third party) 282 | that supports equivalent copying facilities, provided you maintain 283 | clear directions next to the object code saying where to find the 284 | Corresponding Source. Regardless of what server hosts the 285 | Corresponding Source, you remain obligated to ensure that it is 286 | available for as long as needed to satisfy these requirements. 287 | 288 | e) Convey the object code using peer-to-peer transmission, provided 289 | you inform other peers where the object code and Corresponding 290 | Source of the work are being offered to the general public at no 291 | charge under subsection 6d. 292 | 293 | A separable portion of the object code, whose source code is excluded 294 | from the Corresponding Source as a System Library, need not be 295 | included in conveying the object code work. 296 | 297 | A "User Product" is either (1) a "consumer product", which means any 298 | tangible personal property which is normally used for personal, family, 299 | or household purposes, or (2) anything designed or sold for incorporation 300 | into a dwelling. In determining whether a product is a consumer product, 301 | doubtful cases shall be resolved in favor of coverage. For a particular 302 | product received by a particular user, "normally used" refers to a 303 | typical or common use of that class of product, regardless of the status 304 | of the particular user or of the way in which the particular user 305 | actually uses, or expects or is expected to use, the product. A product 306 | is a consumer product regardless of whether the product has substantial 307 | commercial, industrial or non-consumer uses, unless such uses represent 308 | the only significant mode of use of the product. 309 | 310 | "Installation Information" for a User Product means any methods, 311 | procedures, authorization keys, or other information required to install 312 | and execute modified versions of a covered work in that User Product from 313 | a modified version of its Corresponding Source. The information must 314 | suffice to ensure that the continued functioning of the modified object 315 | code is in no case prevented or interfered with solely because 316 | modification has been made. 317 | 318 | If you convey an object code work under this section in, or with, or 319 | specifically for use in, a User Product, and the conveying occurs as 320 | part of a transaction in which the right of possession and use of the 321 | User Product is transferred to the recipient in perpetuity or for a 322 | fixed term (regardless of how the transaction is characterized), the 323 | Corresponding Source conveyed under this section must be accompanied 324 | by the Installation Information. But this requirement does not apply 325 | if neither you nor any third party retains the ability to install 326 | modified object code on the User Product (for example, the work has 327 | been installed in ROM). 328 | 329 | The requirement to provide Installation Information does not include a 330 | requirement to continue to provide support service, warranty, or updates 331 | for a work that has been modified or installed by the recipient, or for 332 | the User Product in which it has been modified or installed. Access to a 333 | network may be denied when the modification itself materially and 334 | adversely affects the operation of the network or violates the rules and 335 | protocols for communication across the network. 336 | 337 | Corresponding Source conveyed, and Installation Information provided, 338 | in accord with this section must be in a format that is publicly 339 | documented (and with an implementation available to the public in 340 | source code form), and must require no special password or key for 341 | unpacking, reading or copying. 342 | 343 | 7. Additional Terms. 344 | 345 | "Additional permissions" are terms that supplement the terms of this 346 | License by making exceptions from one or more of its conditions. 347 | Additional permissions that are applicable to the entire Program shall 348 | be treated as though they were included in this License, to the extent 349 | that they are valid under applicable law. If additional permissions 350 | apply only to part of the Program, that part may be used separately 351 | under those permissions, but the entire Program remains governed by 352 | this License without regard to the additional permissions. 353 | 354 | When you convey a copy of a covered work, you may at your option 355 | remove any additional permissions from that copy, or from any part of 356 | it. (Additional permissions may be written to require their own 357 | removal in certain cases when you modify the work.) You may place 358 | additional permissions on material, added by you to a covered work, 359 | for which you have or can give appropriate copyright permission. 360 | 361 | Notwithstanding any other provision of this License, for material you 362 | add to a covered work, you may (if authorized by the copyright holders of 363 | that material) supplement the terms of this License with terms: 364 | 365 | a) Disclaiming warranty or limiting liability differently from the 366 | terms of sections 15 and 16 of this License; or 367 | 368 | b) Requiring preservation of specified reasonable legal notices or 369 | author attributions in that material or in the Appropriate Legal 370 | Notices displayed by works containing it; or 371 | 372 | c) Prohibiting misrepresentation of the origin of that material, or 373 | requiring that modified versions of such material be marked in 374 | reasonable ways as different from the original version; or 375 | 376 | d) Limiting the use for publicity purposes of names of licensors or 377 | authors of the material; or 378 | 379 | e) Declining to grant rights under trademark law for use of some 380 | trade names, trademarks, or service marks; or 381 | 382 | f) Requiring indemnification of licensors and authors of that 383 | material by anyone who conveys the material (or modified versions of 384 | it) with contractual assumptions of liability to the recipient, for 385 | any liability that these contractual assumptions directly impose on 386 | those licensors and authors. 387 | 388 | All other non-permissive additional terms are considered "further 389 | restrictions" within the meaning of section 10. If the Program as you 390 | received it, or any part of it, contains a notice stating that it is 391 | governed by this License along with a term that is a further 392 | restriction, you may remove that term. If a license document contains 393 | a further restriction but permits relicensing or conveying under this 394 | License, you may add to a covered work material governed by the terms 395 | of that license document, provided that the further restriction does 396 | not survive such relicensing or conveying. 397 | 398 | If you add terms to a covered work in accord with this section, you 399 | must place, in the relevant source files, a statement of the 400 | additional terms that apply to those files, or a notice indicating 401 | where to find the applicable terms. 402 | 403 | Additional terms, permissive or non-permissive, may be stated in the 404 | form of a separately written license, or stated as exceptions; 405 | the above requirements apply either way. 406 | 407 | 8. Termination. 408 | 409 | You may not propagate or modify a covered work except as expressly 410 | provided under this License. Any attempt otherwise to propagate or 411 | modify it is void, and will automatically terminate your rights under 412 | this License (including any patent licenses granted under the third 413 | paragraph of section 11). 414 | 415 | However, if you cease all violation of this License, then your 416 | license from a particular copyright holder is reinstated (a) 417 | provisionally, unless and until the copyright holder explicitly and 418 | finally terminates your license, and (b) permanently, if the copyright 419 | holder fails to notify you of the violation by some reasonable means 420 | prior to 60 days after the cessation. 421 | 422 | Moreover, your license from a particular copyright holder is 423 | reinstated permanently if the copyright holder notifies you of the 424 | violation by some reasonable means, this is the first time you have 425 | received notice of violation of this License (for any work) from that 426 | copyright holder, and you cure the violation prior to 30 days after 427 | your receipt of the notice. 428 | 429 | Termination of your rights under this section does not terminate the 430 | licenses of parties who have received copies or rights from you under 431 | this License. If your rights have been terminated and not permanently 432 | reinstated, you do not qualify to receive new licenses for the same 433 | material under section 10. 434 | 435 | 9. Acceptance Not Required for Having Copies. 436 | 437 | You are not required to accept this License in order to receive or 438 | run a copy of the Program. Ancillary propagation of a covered work 439 | occurring solely as a consequence of using peer-to-peer transmission 440 | to receive a copy likewise does not require acceptance. However, 441 | nothing other than this License grants you permission to propagate or 442 | modify any covered work. These actions infringe copyright if you do 443 | not accept this License. Therefore, by modifying or propagating a 444 | covered work, you indicate your acceptance of this License to do so. 445 | 446 | 10. Automatic Licensing of Downstream Recipients. 447 | 448 | Each time you convey a covered work, the recipient automatically 449 | receives a license from the original licensors, to run, modify and 450 | propagate that work, subject to this License. You are not responsible 451 | for enforcing compliance by third parties with this License. 452 | 453 | An "entity transaction" is a transaction transferring control of an 454 | organization, or substantially all assets of one, or subdividing an 455 | organization, or merging organizations. If propagation of a covered 456 | work results from an entity transaction, each party to that 457 | transaction who receives a copy of the work also receives whatever 458 | licenses to the work the party's predecessor in interest had or could 459 | give under the previous paragraph, plus a right to possession of the 460 | Corresponding Source of the work from the predecessor in interest, if 461 | the predecessor has it or can get it with reasonable efforts. 462 | 463 | You may not impose any further restrictions on the exercise of the 464 | rights granted or affirmed under this License. For example, you may 465 | not impose a license fee, royalty, or other charge for exercise of 466 | rights granted under this License, and you may not initiate litigation 467 | (including a cross-claim or counterclaim in a lawsuit) alleging that 468 | any patent claim is infringed by making, using, selling, offering for 469 | sale, or importing the Program or any portion of it. 470 | 471 | 11. Patents. 472 | 473 | A "contributor" is a copyright holder who authorizes use under this 474 | License of the Program or a work on which the Program is based. The 475 | work thus licensed is called the contributor's "contributor version". 476 | 477 | A contributor's "essential patent claims" are all patent claims 478 | owned or controlled by the contributor, whether already acquired or 479 | hereafter acquired, that would be infringed by some manner, permitted 480 | by this License, of making, using, or selling its contributor version, 481 | but do not include claims that would be infringed only as a 482 | consequence of further modification of the contributor version. For 483 | purposes of this definition, "control" includes the right to grant 484 | patent sublicenses in a manner consistent with the requirements of 485 | this License. 486 | 487 | Each contributor grants you a non-exclusive, worldwide, royalty-free 488 | patent license under the contributor's essential patent claims, to 489 | make, use, sell, offer for sale, import and otherwise run, modify and 490 | propagate the contents of its contributor version. 491 | 492 | In the following three paragraphs, a "patent license" is any express 493 | agreement or commitment, however denominated, not to enforce a patent 494 | (such as an express permission to practice a patent or covenant not to 495 | sue for patent infringement). To "grant" such a patent license to a 496 | party means to make such an agreement or commitment not to enforce a 497 | patent against the party. 498 | 499 | If you convey a covered work, knowingly relying on a patent license, 500 | and the Corresponding Source of the work is not available for anyone 501 | to copy, free of charge and under the terms of this License, through a 502 | publicly available network server or other readily accessible means, 503 | then you must either (1) cause the Corresponding Source to be so 504 | available, or (2) arrange to deprive yourself of the benefit of the 505 | patent license for this particular work, or (3) arrange, in a manner 506 | consistent with the requirements of this License, to extend the patent 507 | license to downstream recipients. "Knowingly relying" means you have 508 | actual knowledge that, but for the patent license, your conveying the 509 | covered work in a country, or your recipient's use of the covered work 510 | in a country, would infringe one or more identifiable patents in that 511 | country that you have reason to believe are valid. 512 | 513 | If, pursuant to or in connection with a single transaction or 514 | arrangement, you convey, or propagate by procuring conveyance of, a 515 | covered work, and grant a patent license to some of the parties 516 | receiving the covered work authorizing them to use, propagate, modify 517 | or convey a specific copy of the covered work, then the patent license 518 | you grant is automatically extended to all recipients of the covered 519 | work and works based on it. 520 | 521 | A patent license is "discriminatory" if it does not include within 522 | the scope of its coverage, prohibits the exercise of, or is 523 | conditioned on the non-exercise of one or more of the rights that are 524 | specifically granted under this License. You may not convey a covered 525 | work if you are a party to an arrangement with a third party that is 526 | in the business of distributing software, under which you make payment 527 | to the third party based on the extent of your activity of conveying 528 | the work, and under which the third party grants, to any of the 529 | parties who would receive the covered work from you, a discriminatory 530 | patent license (a) in connection with copies of the covered work 531 | conveyed by you (or copies made from those copies), or (b) primarily 532 | for and in connection with specific products or compilations that 533 | contain the covered work, unless you entered into that arrangement, 534 | or that patent license was granted, prior to 28 March 2007. 535 | 536 | Nothing in this License shall be construed as excluding or limiting 537 | any implied license or other defenses to infringement that may 538 | otherwise be available to you under applicable patent law. 539 | 540 | 12. No Surrender of Others' Freedom. 541 | 542 | If conditions are imposed on you (whether by court order, agreement or 543 | otherwise) that contradict the conditions of this License, they do not 544 | excuse you from the conditions of this License. If you cannot convey a 545 | covered work so as to satisfy simultaneously your obligations under this 546 | License and any other pertinent obligations, then as a consequence you may 547 | not convey it at all. For example, if you agree to terms that obligate you 548 | to collect a royalty for further conveying from those to whom you convey 549 | the Program, the only way you could satisfy both those terms and this 550 | License would be to refrain entirely from conveying the Program. 551 | 552 | 13. Use with the GNU Affero General Public License. 553 | 554 | Notwithstanding any other provision of this License, you have 555 | permission to link or combine any covered work with a work licensed 556 | under version 3 of the GNU Affero General Public License into a single 557 | combined work, and to convey the resulting work. The terms of this 558 | License will continue to apply to the part which is the covered work, 559 | but the special requirements of the GNU Affero General Public License, 560 | section 13, concerning interaction through a network will apply to the 561 | combination as such. 562 | 563 | 14. Revised Versions of this License. 564 | 565 | The Free Software Foundation may publish revised and/or new versions of 566 | the GNU General Public License from time to time. Such new versions will 567 | be similar in spirit to the present version, but may differ in detail to 568 | address new problems or concerns. 569 | 570 | Each version is given a distinguishing version number. If the 571 | Program specifies that a certain numbered version of the GNU General 572 | Public License "or any later version" applies to it, you have the 573 | option of following the terms and conditions either of that numbered 574 | version or of any later version published by the Free Software 575 | Foundation. If the Program does not specify a version number of the 576 | GNU General Public License, you may choose any version ever published 577 | by the Free Software Foundation. 578 | 579 | If the Program specifies that a proxy can decide which future 580 | versions of the GNU General Public License can be used, that proxy's 581 | public statement of acceptance of a version permanently authorizes you 582 | to choose that version for the Program. 583 | 584 | Later license versions may give you additional or different 585 | permissions. However, no additional obligations are imposed on any 586 | author or copyright holder as a result of your choosing to follow a 587 | later version. 588 | 589 | 15. Disclaimer of Warranty. 590 | 591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY 592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT 593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY 594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM 597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF 598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 599 | 600 | 16. Limitation of Liability. 601 | 602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS 604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY 605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE 606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF 607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD 608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), 609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF 610 | SUCH DAMAGES. 611 | 612 | 17. Interpretation of Sections 15 and 16. 613 | 614 | If the disclaimer of warranty and limitation of liability provided 615 | above cannot be given local legal effect according to their terms, 616 | reviewing courts shall apply local law that most closely approximates 617 | an absolute waiver of all civil liability in connection with the 618 | Program, unless a warranty or assumption of liability accompanies a 619 | copy of the Program in return for a fee. 620 | 621 | END OF TERMS AND CONDITIONS 622 | 623 | How to Apply These Terms to Your New Programs 624 | 625 | If you develop a new program, and you want it to be of the greatest 626 | possible use to the public, the best way to achieve this is to make it 627 | free software which everyone can redistribute and change under these terms. 628 | 629 | To do so, attach the following notices to the program. It is safest 630 | to attach them to the start of each source file to most effectively 631 | state the exclusion of warranty; and each file should have at least 632 | the "copyright" line and a pointer to where the full notice is found. 633 | 634 | 635 | Copyright (C) 636 | 637 | This program is free software: you can redistribute it and/or modify 638 | it under the terms of the GNU General Public License as published by 639 | the Free Software Foundation, either version 3 of the License, or 640 | (at your option) any later version. 641 | 642 | This program is distributed in the hope that it will be useful, 643 | but WITHOUT ANY WARRANTY; without even the implied warranty of 644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 645 | GNU General Public License for more details. 646 | 647 | You should have received a copy of the GNU General Public License 648 | along with this program. If not, see . 649 | 650 | Also add information on how to contact you by electronic and paper mail. 651 | 652 | If the program does terminal interaction, make it output a short 653 | notice like this when it starts in an interactive mode: 654 | 655 | Copyright (C) 656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. 657 | This is free software, and you are welcome to redistribute it 658 | under certain conditions; type `show c' for details. 659 | 660 | The hypothetical commands `show w' and `show c' should show the appropriate 661 | parts of the General Public License. Of course, your program's commands 662 | might be different; for a GUI interface, you would use an "about box". 663 | 664 | You should also get your employer (if you work as a programmer) or school, 665 | if any, to sign a "copyright disclaimer" for the program, if necessary. 666 | For more information on this, and how to apply and follow the GNU GPL, see 667 | . 668 | 669 | The GNU General Public License does not permit incorporating your program 670 | into proprietary programs. If your program is a subroutine library, you 671 | may consider it more useful to permit linking proprietary applications with 672 | the library. If this is what you want to do, use the GNU Lesser General 673 | Public License instead of this License. But first, please read 674 | . 675 | -------------------------------------------------------------------------------- /Linked List 1/AppendLastNToFirst.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | public class AppendLastNToFirst { 4 | 5 | public static LinkedListNode appendLastNToFirst(LinkedListNode head,int n){ 6 | 7 | if(n==0) { 8 | return head; 9 | } 10 | 11 | LinkedListNode tempHead=head; 12 | int length=LengthOfLL.lengthOfLinkedList(head); 13 | 14 | if(length==n) { 15 | 16 | //reverse 17 | 18 | } 19 | int pos= length-n -1; 20 | int i=1; 21 | while(i<=pos) { 22 | head=head.next; 23 | i++; 24 | } 25 | LinkedListNode newHead= head.next,temp=newHead; 26 | head.next=null; 27 | while(temp.next!=null) { 28 | temp=temp.next; 29 | } 30 | temp.next=tempHead; 31 | 32 | return newHead; 33 | 34 | 35 | } 36 | 37 | public static void main(String[] args) { 38 | 39 | LinkedListNode head=Use.takeInput(); 40 | head=appendLastNToFirst(head, 5); 41 | Use.print(head); 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /Linked List 1/ArrayListUse.java: -------------------------------------------------------------------------------- 1 | import java.util.ArrayList; 2 | 3 | public class ArrayListUse { 4 | 5 | public static void main(String[] args) { 6 | ArrayList arr=new ArrayList(); 7 | arr.add(5); 8 | arr.add(10); 9 | arr.add(20); 10 | arr.add(2,15); 11 | System.out.println(arr.get(3)); 12 | 13 | for(int i : arr) { 14 | System.out.print(i+" "); 15 | } 16 | System.out.println(); 17 | for(int i=0;i=0;i--) { 22 | System.out.println(arr.remove(i)); 23 | } 24 | System.out.println(arr.isEmpty()); 25 | 26 | 27 | 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /Linked List 1/CheckPalindrome.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | 4 | public class CheckPalindrome { 5 | 6 | public static LinkedListNode reverse(LinkedListNode head){ 7 | 8 | 9 | if(head.next==null) { 10 | return head; 11 | } 12 | LinkedListNode tail=head.next; 13 | LinkedListNode newHead= reverse(head.next); 14 | tail.next=head; 15 | head.next=null; 16 | return newHead; 17 | } 18 | 19 | 20 | public static boolean checkPalindrome(LinkedListNode head) { 21 | 22 | 23 | LinkedListNode slow=head,fast=head; 24 | 25 | while(fast.next!=null && fast.next.next!=null) { 26 | 27 | slow=slow.next; 28 | fast=fast.next.next; 29 | } 30 | LinkedListNode head1=slow.next; 31 | LinkedListNode head2= head; 32 | head1=reverse(head1); 33 | 34 | while(head1!=null && head2!=null) { 35 | 36 | if(!head1.data.equals(head2.data)) { 37 | return false; 38 | } 39 | head1=head1.next; 40 | head2=head2.next; 41 | } 42 | return true; 43 | 44 | } 45 | public static void main(String[] args) { 46 | LinkedListNode head=Use.takeInput(); 47 | System.out.println(checkPalindrome(head)); 48 | // Use.print(head); 49 | } 50 | 51 | 52 | } 53 | -------------------------------------------------------------------------------- /Linked List 1/DeleteANode.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | public class DeleteANode { 4 | 5 | public static LinkedListNode delete(LinkedListNode head,int index){ 6 | 7 | if(head==null) { 8 | return head; 9 | } 10 | if(index>=LengthOfLL.lengthOfLinkedList(head)) { 11 | return head; 12 | } 13 | if(index==0) { 14 | return head.next; 15 | } 16 | int i=1; 17 | LinkedListNode curr=head,prev=null; 18 | while(i<=index) { 19 | prev=curr; 20 | curr=curr.next; 21 | i++; 22 | } 23 | prev.next=curr.next; 24 | return head; 25 | 26 | 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /Linked List 1/EliminateDuplicates.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | public class EliminateDuplicates { 4 | 5 | public static LinkedListNode eliminateDuplicates(LinkedListNode head){ 6 | 7 | 8 | LinkedListNode curr=head; 9 | while(curr.next!=null) { 10 | 11 | if(curr.data.equals(curr.next.data)) { 12 | curr.next=curr.next.next; 13 | }else { 14 | curr=curr.next; 15 | } 16 | 17 | } 18 | return head; 19 | 20 | } 21 | public static void main(String[] args) { 22 | LinkedListNode head=Use.takeInput(); 23 | head=eliminateDuplicates(head); 24 | Use.print(head); 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /Linked List 1/FindANode.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | public class FindANode { 4 | 5 | public static int findNode(LinkedListNode head,int data){ 6 | 7 | if(head==null) { 8 | return -1; 9 | } 10 | 11 | int i=0; 12 | while(head!=null) { 13 | if(head.data==data) { 14 | return i; 15 | } 16 | i++; 17 | head=head.next; 18 | } 19 | return -1; 20 | 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /Linked List 1/LengthOfLL.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | public class LengthOfLL { 4 | 5 | public static int lengthOfLinkedList(LinkedListNode head) { 6 | 7 | int l=0; 8 | while(head!=null) { 9 | l++; 10 | head=head.next; 11 | } 12 | return l; 13 | 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /Linked List 1/LinkedListNode.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | public class LinkedListNode { 4 | 5 | T data; 6 | LinkedListNode next; 7 | 8 | public LinkedListNode(T data) { 9 | this.data=data; 10 | this.next=null; 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Linked List 1/PrintIthNode.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | public class PrintIthNode { 4 | 5 | public static void printIthNode(LinkedListNode head,int posn) { 6 | 7 | if(head==null) { 8 | return ; 9 | } 10 | if(posn>=LengthOfLL.lengthOfLinkedList(head)) { 11 | return ; 12 | } 13 | 14 | int i=1; 15 | while(i<=posn) { 16 | head=head.next; 17 | i++; 18 | } 19 | System.out.println(head.data); 20 | 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /Linked List 1/PrintReverseLL.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | public class PrintReverseLL { 4 | 5 | public static void printReverse(LinkedListNode head) { 6 | 7 | if(head==null) { 8 | return; 9 | } 10 | 11 | printReverse(head.next); 12 | System.out.println(head.data); 13 | 14 | 15 | } 16 | 17 | public static void main(String[] args) { 18 | LinkedListNode head=Use.takeInput(); 19 | // head=eliminateDuplicates(head); 20 | printReverse(head); 21 | Use.print(head); 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /Linked List 1/Use.java: -------------------------------------------------------------------------------- 1 | package LinkedList; 2 | 3 | import java.util.Scanner; 4 | 5 | public class Use { 6 | 7 | public static void main(String[] args) { 8 | 9 | // LinkedListNode node=new LinkedListNode(1); 10 | // LinkedListNode node1=new LinkedListNode(2); 11 | // LinkedListNode node2=new LinkedListNode(3); 12 | // LinkedListNode tail=new LinkedListNode(4); 13 | // node.next=node1; 14 | // node1.next=node2; 15 | // node2.next=tail; 16 | LinkedListNode head=takeInput(); 17 | print(head); 18 | System.out.println(LengthOfLL.lengthOfLinkedList(head)); 19 | //head=insert(head, 2, 80); 20 | System.out.println(FindANode.findNode(head,5)); 21 | head=DeleteANode.delete(head,2); 22 | print(head); 23 | System.out.println(FindANode.findNode(head,5)); 24 | 25 | 26 | // print(head); 27 | // while(head!=null) { 28 | // System.out.print(head.data+" "); 29 | // head=head.next; 30 | // } 31 | 32 | 33 | 34 | } 35 | public static LinkedListNode takeInput(){ 36 | 37 | Scanner scan=new Scanner(System.in); 38 | int data=scan.nextInt(); 39 | LinkedListNode head=null,tail=null; 40 | 41 | while(data!=-1) { 42 | 43 | LinkedListNode newNode=new LinkedListNode(data); 44 | 45 | if(head==null) { 46 | head=newNode; 47 | tail=newNode; 48 | }else { 49 | tail.next=newNode; 50 | tail=newNode; 51 | // LinkedListNode temp=head; 52 | // while(temp.next!=null) { 53 | // temp=temp.next; 54 | // } 55 | // temp.next=newNode; 56 | } 57 | 58 | data=scan.nextInt(); 59 | } 60 | return head; 61 | } 62 | public static void print(LinkedListNode head) { 63 | while(head!=null) { 64 | System.out.print(head.data+" "); 65 | head=head.next; 66 | } 67 | System.out.println(); 68 | } 69 | 70 | public static LinkedListNode insert(LinkedListNode head,int posn,int data){ 71 | 72 | LinkedListNode newNode=new LinkedListNode(data); 73 | 74 | if(posn>LengthOfLL.lengthOfLinkedList(head)) { 75 | return head; 76 | } 77 | if(posn==0) { 78 | newNode.next=head; 79 | return newNode; 80 | } 81 | LinkedListNode prev=null,curr=head; 82 | int i=1; 83 | while(i<=posn) { 84 | prev=curr; 85 | curr=curr.next; 86 | i++; 87 | } 88 | prev.next=newNode; 89 | newNode.next=curr; 90 | return head; 91 | } 92 | } 93 | -------------------------------------------------------------------------------- /OOPS 1/ArrayEmptyException.java: -------------------------------------------------------------------------------- 1 | package DynamicArray; 2 | 3 | public class ArrayEmptyException extends Exception { 4 | 5 | /** 6 | * 7 | */ 8 | private static final long serialVersionUID = 1L; 9 | 10 | } 11 | -------------------------------------------------------------------------------- /OOPS 1/ComplexNumbers.java: -------------------------------------------------------------------------------- 1 | package ComplexNumbers; 2 | public class ComplexNumbers { 3 | // Complete this class 4 | private int real; 5 | private int imag; 6 | 7 | public ComplexNumbers(int real,int imag) { 8 | this.real=real; 9 | this.imag=imag; 10 | } 11 | 12 | public int getImag() { 13 | return imag; 14 | } 15 | 16 | public int getReal() { 17 | return real; 18 | } 19 | 20 | public void setImag(int imag) { 21 | this.imag = imag; 22 | } 23 | 24 | public void setReal(int real) { 25 | this.real = real; 26 | } 27 | 28 | public void plus(ComplexNumbers c) { 29 | int real=this.real + c.real; 30 | int imag=this.imag+c.imag; 31 | this.real=real; 32 | this.imag=imag; 33 | } 34 | public void multiply(ComplexNumbers c) { 35 | int real= this.real * c.real - this.imag * c.imag; 36 | int imag= this.real * c.imag + c.real * this.imag; 37 | this.real=real; 38 | this.imag=imag; 39 | } 40 | public static ComplexNumbers add(ComplexNumbers c1,ComplexNumbers c2) { 41 | int real=c1.real + c2.real; 42 | int imag=c1.imag+c2.imag; 43 | return new ComplexNumbers(real, imag); 44 | } 45 | public static ComplexNumbers multiply(ComplexNumbers c1,ComplexNumbers c2) { 46 | int real= c1.real * c2.real - c1.imag * c2.imag; 47 | int imag= c1.real * c2.imag + c2.real * c1.imag; 48 | return new ComplexNumbers(real, imag); 49 | } 50 | public void print() { 51 | System.out.println(this.real + " + i"+ this.imag); 52 | } 53 | public ComplexNumbers conjugate() { 54 | int imag=-this.imag; 55 | return new ComplexNumbers(this.real, imag); 56 | } 57 | 58 | } 59 | -------------------------------------------------------------------------------- /OOPS 1/ComplexNumbersUse.java: -------------------------------------------------------------------------------- 1 | package ComplexNumbers; 2 | 3 | public class ComplexNumbersUse { 4 | 5 | public static void main(String[] args) { 6 | 7 | ComplexNumbers c=new ComplexNumbers(5, 6); 8 | c.multiply(new ComplexNumbers(1, 1)); 9 | c.conjugate().print(); 10 | 11 | } 12 | 13 | } 14 | -------------------------------------------------------------------------------- /OOPS 1/DynamicArray.java: -------------------------------------------------------------------------------- 1 | package DynamicArray; 2 | 3 | public class DynamicArray { 4 | 5 | private int[] arr; 6 | private int size; 7 | 8 | public DynamicArray() { 9 | arr=new int[5]; 10 | size=0; 11 | } 12 | public int size() { 13 | return size; 14 | } 15 | public boolean isEmpty() { 16 | return size==0; 17 | } 18 | public void set(int index,int item) throws ArrayEmptyException { 19 | 20 | if(size==0) { 21 | throw new ArrayEmptyException(); 22 | } 23 | if(index > size) { 24 | return ; 25 | } 26 | if(index==size) { 27 | addLast(item); 28 | } 29 | arr[index]=item; 30 | } 31 | public void addLast(int item) { 32 | if(size==arr.length) { 33 | restructure(); 34 | } 35 | arr[size]=item; 36 | size++; 37 | } 38 | private void restructure() { 39 | 40 | int[] temp=arr; 41 | arr=new int[temp.length * 2]; 42 | 43 | for(int i=0;i= size) { 62 | return Integer.MIN_VALUE; 63 | } 64 | 65 | return arr[index]; 66 | 67 | } 68 | 69 | 70 | 71 | 72 | } 73 | -------------------------------------------------------------------------------- /OOPS 1/DynamicArrayUse.java: -------------------------------------------------------------------------------- 1 | package DynamicArray; 2 | 3 | public class DynamicArrayUse { 4 | 5 | public static void main(String[] args) throws ArrayEmptyException { 6 | 7 | DynamicArray arr=new DynamicArray(); 8 | for(int i=0;i<100;i++) { 9 | arr.addLast(i+1); 10 | } 11 | arr.set(10, 79); 12 | System.out.println(arr.get(99) + " " + arr.size()); 13 | while(!arr.isEmpty()) { 14 | System.out.println(arr.removeLast() +" "+ arr.size()); 15 | } 16 | System.out.println(arr.size()); 17 | 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /OOPS 1/Fraction.java: -------------------------------------------------------------------------------- 1 | package Fraction; 2 | 3 | public class Fraction { 4 | 5 | private int num; 6 | private int deno; 7 | 8 | public Fraction(int num,int deno) throws ZeroDenominatorException { 9 | 10 | this.num=num; 11 | if(deno==0) { 12 | throw new ZeroDenominatorException(); 13 | } 14 | this.deno=deno; 15 | simplify(); 16 | 17 | } 18 | 19 | private void simplify() { 20 | int gcd=1; 21 | for(int i=1;i<=Math.min(num, deno);i++) { 22 | if(num%i==0 && deno%i==0) { 23 | gcd=i; 24 | } 25 | } 26 | num=num/gcd; 27 | deno=deno/gcd; 28 | } 29 | public void print() { 30 | if(deno==1) { 31 | System.out.println(num); 32 | } 33 | else { 34 | System.out.println(num+"/"+deno); 35 | } 36 | } 37 | public int getNum() { 38 | return num; 39 | } 40 | public int getDeno() { 41 | return deno; 42 | } 43 | public void setDeno(int deno) throws ZeroDenominatorException { 44 | if(deno==0) { 45 | throw new ZeroDenominatorException(); 46 | } 47 | this.deno=deno; 48 | } 49 | public void setNum(int num) { 50 | this.num = num; 51 | } 52 | 53 | public void add(Fraction f) { 54 | int num=this.num*f.deno + f.num*this.deno; 55 | int deno=this.deno*f.deno; 56 | this.num=num; 57 | this.deno=deno; 58 | simplify(); 59 | } 60 | public void multiply(Fraction f) { 61 | int num= this.num * f.num; 62 | int deno=this.deno*f.deno; 63 | this.num=num; 64 | this.deno=deno; 65 | simplify(); 66 | } 67 | public static Fraction add(Fraction f1,Fraction f2) throws ZeroDenominatorException { // method overloading (Same function name with different arguments. 68 | 69 | int num=f1.num*f2.deno + f2.num * f1.deno; 70 | int deno=f1.deno * f2.deno; 71 | Fraction f=new Fraction(num, deno); 72 | return f; 73 | 74 | } 75 | 76 | public static Fraction multiply(Fraction f1,Fraction f2) throws ZeroDenominatorException { 77 | int num=f1.num*f2.num; 78 | int deno=f1.deno*f2.deno; 79 | Fraction f=new Fraction(num, deno); 80 | return f; 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /OOPS 1/FractionUse.java: -------------------------------------------------------------------------------- 1 | package Fraction; 2 | 3 | public class FractionUse { 4 | 5 | public static void main(String[] args) throws ZeroDenominatorException { 6 | Fraction f1=new Fraction(5, 10); 7 | Fraction f2=new Fraction(10,50); 8 | f1.multiply(f2); 9 | f1.print(); 10 | Fraction f= Fraction.multiply(f1, f2); 11 | 12 | f.print(); 13 | } 14 | 15 | } 16 | -------------------------------------------------------------------------------- /OOPS 1/Polynomial.java: -------------------------------------------------------------------------------- 1 | package Polynomial; 2 | 3 | public class Polynomial { 4 | 5 | private int[] coeff; 6 | private int degree; 7 | 8 | public Polynomial() { 9 | coeff=new int[5]; 10 | degree=-1; 11 | } 12 | public void setCoefficient(int degree,int coefficient) { 13 | if(degree >=coeff.length) { 14 | restructure(degree); 15 | } 16 | coeff[degree]=coefficient; 17 | if(degree >= this.degree) { 18 | this.degree=degree; 19 | } 20 | } 21 | public Polynomial add(Polynomial p) { 22 | 23 | Polynomial x=new Polynomial(); 24 | 25 | int i=0,j=0,k=0; 26 | while(i < p.coeff.length && j < this.coeff.length) { 27 | x.setCoefficient(k, p.coeff[i] + this.coeff[i]); 28 | i++; 29 | j++; 30 | k++; 31 | } 32 | while(i { 3 | 4 | private T first; 5 | private V second; 6 | 7 | public Pair(T first,V second) { 8 | this.first=first; 9 | this.second=second; 10 | } 11 | 12 | public T getFirst() { 13 | return first; 14 | } 15 | public V getSecond() { 16 | return second; 17 | } 18 | public void setFirst(T first) { 19 | this.first=first; 20 | } 21 | public void setSecond(V second) { 22 | this.second=second; 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /OOPS 3/Student.java: -------------------------------------------------------------------------------- 1 | 2 | public class Student implements CarInterface { 3 | public void print() { 4 | System.out.println("Student"); 5 | } 6 | } 7 | -------------------------------------------------------------------------------- /OOPS 3/Use.java: -------------------------------------------------------------------------------- 1 | 2 | public class Use { 3 | 4 | 5 | public static void printArray(T arr[]) { // classes that implements Interface only works 6 | for(int i=0;i p=new Pair<>("xy","yz"); 21 | // 22 | // System.out.println(p.getFirst()+" "+p.getSecond()); 23 | // Pair, Integer> triplet=new Pair<>(p,5); 24 | // System.out.println(triplet.getFirst().getFirst()); 25 | // 26 | // Integer arr[]= {1,2,3,4,5,6,7}; 27 | // printArray(arr); 28 | // Student[] s =new Student[1]; 29 | // s[0]= new Student(); 30 | // printArray(s); 31 | 32 | 33 | Integer i =new Integer(6); 34 | System.out.println(i); // i is a variable ( wrapper class object is a object that contains value not address) 35 | 36 | String s="abc"; 37 | s="def"; 38 | System.out.println(s); // printing s gives value ....beacuse String is a speacial class that prints values not adrress. 39 | 40 | 41 | } 42 | 43 | 44 | } 45 | -------------------------------------------------------------------------------- /OOPS 3/Vehicle.java: -------------------------------------------------------------------------------- 1 | 2 | // final 3 | public abstract class Vehicle { 4 | 5 | 6 | final int a; 7 | 8 | public abstract boolean isMotorised(); 9 | 10 | public Vehicle() { 11 | a=10; 12 | } 13 | 14 | // final void print() { 15 | // System.out.println("Vehicle Print Fn"); 16 | // } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /OOPS 3/VehicleInterface.java: -------------------------------------------------------------------------------- 1 | 2 | public interface VehicleInterface extends CarInterface { 3 | // class-----extends------ class 4 | //interface----extends------interface 5 | // class ---implements---interface 6 | public static final double PI=3.14; 7 | public boolean isMotorised(); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /Pattern 2/DiamondOfStars.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class DiamondOfStars { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | 11 | int n1=n/2+1; 12 | int n2=n-n1; 13 | for(int i=1;i<=n1;i++) { 14 | 15 | for(int space=1;space<=(n1-i);space++) { 16 | System.out.print(" "); 17 | } 18 | for(int j=1;j<=(2*i-1);j++) { 19 | System.out.print("*"); 20 | } 21 | System.out.println(); 22 | } 23 | int k=n2-1; 24 | for(int i=1;i<=n2;i++) { 25 | for(int space=1;space<=i;space++) { 26 | System.out.print(" "); 27 | } 28 | for(int j=1;j<=(2*k+1);j++) { 29 | System.out.print("*"); 30 | } 31 | k--; 32 | System.out.println(); 33 | } 34 | 35 | 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /Pattern 2/HalfDiamondPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class Solution { 3 | 4 | public static void main(String[] args) { 5 | // Write your code here 6 | Scanner scan=new Scanner(System.in); 7 | int n=scan.nextInt(); 8 | 9 | for(int i=1;i<=n+1;i++){ 10 | 11 | 12 | for(int j=1;j<=i;j++){ 13 | 14 | if(j==1){ 15 | System.out.print("*"); 16 | } 17 | else{ 18 | System.out.print(j-1); 19 | } 20 | } 21 | 22 | for(int j= i-1;j>=1;j--){ 23 | 24 | if(j==1){ 25 | System.out.print("*"); 26 | } 27 | else{ 28 | System.out.print(j-1); 29 | } 30 | 31 | } 32 | 33 | System.out.println(); 34 | 35 | 36 | } 37 | 38 | if(n==0){ 39 | System.out.println("*"); 40 | return ; 41 | } 42 | 43 | 44 | for(int i=1;i<=n;i++){ 45 | 46 | 47 | for(int j=1;j<= (n-i+1 ) ;j++ ){ 48 | 49 | if(j==1){ 50 | System.out.print("*"); 51 | } 52 | else{ 53 | System.out.print(j-1); 54 | } 55 | 56 | } 57 | for(int j=n-i;j>=1;j--){ 58 | if(j==1){ 59 | System.out.print("*"); 60 | }else{ 61 | System.out.print(j-1); 62 | } 63 | } 64 | System.out.println(); 65 | 66 | 67 | } 68 | 69 | 70 | 71 | 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /Pattern 2/InvertedNumberPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class InvertedNumberPattern { 4 | 5 | 6 | public static void main(String[] args) { 7 | 8 | 9 | Scanner scan=new Scanner(System.in); 10 | int n=scan.nextInt(); 11 | for(int i=1;i<=n;i++) { 12 | 13 | for(int j=1;j<=(n-i+1);j++) { 14 | System.out.print(n-i+1); 15 | } 16 | System.out.println(); 17 | } 18 | 19 | 20 | 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Pattern 2/InvertedTriangle1.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class InvertedTriangle1 { 4 | 5 | 6 | public static void main(String[] args) { 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | 12 | 13 | for(int j=1;j<=(n-i+1);j++) { 14 | System.out.print("*"); 15 | } 16 | System.out.println(); 17 | } 18 | 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /Pattern 2/InvertedTriangle2.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class InvertedTriangle2 { 4 | 5 | public static void main(String[] args) { 6 | 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | 12 | for(int space=1;space<=(i-1);space++) { 13 | System.out.print(" "); 14 | } 15 | for(int j=1;j<=(n-i+1);j++) { 16 | System.out.print("*"); 17 | } 18 | System.out.println(); 19 | } 20 | 21 | 22 | 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Pattern 2/IsocelesTriangle.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class IsocelesTriangle { 4 | 5 | 6 | public static void main(String[] args) { 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | 11 | for(int space=1;space<=(n-i);space++) { 12 | System.out.print(" "); 13 | } 14 | for(int j=1;j<=i;j++) { 15 | System.out.print(j); 16 | } 17 | for(int k=i-1;k>=1;k--) { 18 | System.out.print(k); 19 | } 20 | System.out.println(); 21 | } 22 | 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Pattern 2/IsocelesTriangleStarPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class IsocelesTriangleStarPattern { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | 9 | Scanner scan=new Scanner(System.in); 10 | int n=scan.nextInt(); 11 | 12 | for(int i=1;i<=n;i++) { 13 | for(int space=1;space<=(n-i);space++) { 14 | System.out.print(" "); 15 | } 16 | for(int j=1;j<=(2*i-1);j++) { 17 | System.out.print("*"); 18 | } 19 | System.out.println(); 20 | } 21 | 22 | 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Pattern 2/MirrorNumberPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class MirrorNumberPattern { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | 12 | for(int space=1;space<=(n-i);space++) { 13 | System.out.print(" "); 14 | } 15 | 16 | for(int j=1;j<=i;j++) { 17 | System.out.print(j); 18 | } 19 | System.out.println(); 20 | 21 | 22 | } 23 | 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /Pattern 2/OddSquare.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class Main { 3 | 4 | public static void main(String[] args) { 5 | // Write your code here 6 | Scanner scan=new Scanner(System.in); 7 | int n=scan.nextInt(); 8 | 9 | 10 | for(int i=1;i<=n;i++){ 11 | 12 | int oddNum=2*i-1; 13 | for(int j=1;j<=n;j++){ 14 | System.out.print(oddNum); 15 | oddNum+=2; 16 | 17 | if(oddNum==(2*n+1)){ 18 | oddNum=1; 19 | } 20 | 21 | } 22 | System.out.println(); 23 | 24 | } 25 | 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /Pattern 2/ParallelogramPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class Main { 3 | 4 | public static void main(String[] args) { 5 | // Write your code here 6 | Scanner scan=new Scanner(System.in); 7 | int n=scan.nextInt(); 8 | 9 | for(int i=1;i<=n;i++){ 10 | 11 | for(int space=1;space<=i-1;space++){ 12 | System.out.print(" "); 13 | } 14 | for(int j=1;j<=n;j++){ 15 | System.out.print("*"); 16 | } 17 | System.out.println(); 18 | 19 | 20 | } 21 | 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /Pattern 2/ReverseTriangle.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class ReverseTriangle { 4 | 5 | public static void main(String[] args) { 6 | 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | 12 | for(int space=1;space<=(n-i);space++) { 13 | System.out.print(" "); 14 | } 15 | 16 | for(int j=1;j<=i;j++) { 17 | System.out.print("*"); 18 | } 19 | System.out.println(); 20 | 21 | 22 | } 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Pattern 2/SumPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class Main { 3 | 4 | public static void main(String[] args) { 5 | // Write your code here 6 | Scanner scan=new Scanner(System.in); 7 | int n=scan.nextInt(); 8 | 9 | for(int i=1;i<=n;i++){ 10 | int sum=0; 11 | for(int j=1;j<=i;j++){ 12 | sum+=j; 13 | System.out.print(j); 14 | if(j!=i){ 15 | System.out.print("+"); 16 | } 17 | } 18 | System.out.println("="+sum); 19 | 20 | 21 | } 22 | 23 | 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /Pattern 2/TriangleOfNumbers.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class TriangleOfNumbers { 4 | 5 | public static void main(String[] args) { 6 | 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | 11 | for(int i=1;i<=n;i++) { 12 | for(int space=1;space<=(n-i);space++) { 13 | System.out.print(" "); 14 | } 15 | int k=i; 16 | for(int j=1;j<=i;j++) { 17 | System.out.print(k++); 18 | } 19 | k=k-2; 20 | for(int j=k;j>=i;j--) { 21 | System.out.print(j); 22 | } 23 | System.out.println(); 24 | } 25 | 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /Patterns 1/AlphaTriangle.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class AlphaTriangle { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | for(int j=1;j<=i;j++) { 11 | System.out.print((char)('A'+i-1)); 12 | } 13 | System.out.println(); 14 | } 15 | 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Patterns 1/CharacterPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class CharacterPattern { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | int k=i; 11 | for(int j=1;j<=i;j++) { 12 | System.out.print((char)('A'+(k++)-1)); 13 | } 14 | System.out.println(); 15 | } 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/CharacterPattern1.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class CharacterPattern1 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | for(int j=1;j<=n;j++) { 11 | System.out.print((char)('A'+j-1)); 12 | } 13 | System.out.println(); 14 | } 15 | 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/CharacterPattern2.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class CharacterPattern2 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | int k=i; 11 | for(int j=1;j<=n;j++) { 12 | System.out.print((char)('A'+k-1)); 13 | k++; 14 | } 15 | System.out.println(); 16 | } 17 | 18 | 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Patterns 1/InterestingAlphabets.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class InterestingAlphabets { 4 | 5 | 6 | public static void main(String[] args) { 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | int k=n-i; 11 | for(int j=1;j<=i;j++) { 12 | System.out.print((char)('A'+k)); 13 | k++; 14 | } 15 | System.out.println(); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Patterns 1/Pattern1.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class Pattern1 { 3 | 4 | public static void main(String[] args) { 5 | 6 | 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | for(int j=1;j<=i;j++) { 11 | System.out.print(j+" "); 12 | } 13 | System.out.println(); 14 | } 15 | 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Patterns 1/Pattern2.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Pattern2 { 4 | 5 | public static void main(String[] args) { 6 | 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | int k=1; 10 | for(int i=1;i<=n;i++) { 11 | for(int j=1;j<=i;j++) { 12 | System.out.print(k++ + " "); 13 | } 14 | System.out.println(); 15 | } 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Patterns 1/Pattern3.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Pattern3 { 4 | 5 | public static void main(String[] args) { 6 | Scanner scan=new Scanner(System.in); 7 | int n=scan.nextInt(); 8 | int k=1; 9 | for(int i=1;i<=n;i++) { 10 | for(int space=1;space<=(n-i);space++) { 11 | System.out.print(" "); 12 | } 13 | for(int j=1;j<=i;j++) { 14 | System.out.print(k++); 15 | } 16 | System.out.println(); 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/Pattern4.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class Pattern4 { 4 | 5 | public static void main(String[] args) { 6 | Scanner scan=new Scanner(System.in); 7 | int n=scan.nextInt(); 8 | for(int i=1;i<=n;i++) { 9 | for(int space=1;space<=n-i;space++) { 10 | System.out.print(" "); 11 | } 12 | int k=i; 13 | for(int j=1;j<=i;j++) { 14 | System.out.print(k+++""); 15 | } 16 | System.out.println(); 17 | } 18 | 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /Patterns 1/Pattern5.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | public class Pattern5 { 3 | 4 | public static void main(String[] args) { 5 | Scanner scan=new Scanner(System.in); 6 | int n=scan.nextInt(); 7 | for(int i=1;i<=n;i++) { 8 | for(int space=1;space<=n-i;space++) { 9 | System.out.print(" "); 10 | } 11 | for(int j=1;j<=2*i-1;j++) { 12 | System.out.print("*"); 13 | } 14 | 15 | System.out.println(); 16 | } 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/RepeatingNumbers.java: -------------------------------------------------------------------------------- 1 | 2 | public class RepeatingNumbers { 3 | 4 | public static void print(int n) { 5 | //Write your code here 6 | int val=1; 7 | for(int i=1;i<=n;i++){ 8 | for(int j=1;j<=Math.pow(2,i-1);j++){ 9 | System.out.print(val++); 10 | if(val==10){ 11 | val=1; 12 | } 13 | } 14 | System.out.println(); 15 | } 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/ReverseNumberPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class ReverseNumberPattern { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | int val=i; 12 | for(int j=1;j<=i;j++) { 13 | System.out.print(val--); 14 | } 15 | System.out.println(); 16 | } 17 | 18 | 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Patterns 1/SquarePattern1.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class SquarePattern1 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | for(int j=1;j<=n;j++) { 12 | System.out.print("*"); 13 | } 14 | System.out.println(); 15 | } 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/SquarePattern2.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class SquarePattern2 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | for(int j=1;j<=n;j++) { 12 | System.out.print(n); 13 | } 14 | System.out.println(); 15 | } 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/SquarePattern3.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class SquarePattern3 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | for(int j=1;j<=n;j++) { 12 | System.out.print(i); 13 | } 14 | System.out.println(); 15 | } 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/SquarePattern4.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class SquarePattern4 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | for(int j=1;j<=n;j++) { 12 | System.out.print(j); 13 | } 14 | System.out.println(); 15 | } 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/SquarePattern5.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class SquarePattern5 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | 8 | Scanner scan=new Scanner(System.in); 9 | int n=scan.nextInt(); 10 | for(int i=1;i<=n;i++) { 11 | for(int j=1;j<=n;j++) { 12 | System.out.print(n-j+1); 13 | } 14 | System.out.println(); 15 | } 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/TraingularNumberPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class TraingularNumberPattern { 4 | public static void main(String[] args) { 5 | 6 | 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | for(int j=1;j<=i;j++) { 11 | System.out.print(i); 12 | } 13 | System.out.println(); 14 | } 15 | 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Patterns 1/TraingularStarPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class TraingularStarPattern { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | for(int j=1;j<=i;j++) { 11 | System.out.print("*"); 12 | } 13 | System.out.println(); 14 | } 15 | 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Patterns 1/TriangularPattern1.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class TriangularPattern1 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | for(int j=1;j<=i;j++) { 11 | System.out.print(j+" "); 12 | } 13 | System.out.println(); 14 | } 15 | 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Patterns 1/TriangularPattern2.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class TriangularPattern2 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | int k=i; 11 | for(int j=1;j<=i;j++) { 12 | System.out.print(k++); 13 | } 14 | System.out.println(); 15 | } 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Patterns 1/TriangularPattern3.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class TriangularPattern3 { 4 | 5 | public static void main(String[] args) { 6 | // TODO Auto-generated method stub 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | int k=1; 10 | for(int i=1;i<=n;i++) { 11 | 12 | for(int j=1;j<=i;j++) { 13 | System.out.print(k+++" "); 14 | } 15 | System.out.println(); 16 | } 17 | 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Coding-Ninjas-Java-Solutions | 1 Jan 2020 2 | # Introduction-To-Java | Data-Structures-In-Java 3 | All Codes are perfectly fine and working on codezen/Eclipse/Any IDE Platform.
4 | If you find any doubts, feel free to contact me!
5 | Star the repo if you like it. 6 | 7 | 8 | -------------------------------------------------------------------------------- /Recursion 1/AllIndexs.java: -------------------------------------------------------------------------------- 1 | 2 | public class AllIndexs { 3 | 4 | 5 | public static int[] allIndexes(int[] arr,int num) { 6 | return allIndexes(arr, 0, arr.length-1, num); 7 | } 8 | public static int[] allIndexes(int[] arr,int start,int end,int num) { 9 | if(start > end) { 10 | return new int[0]; 11 | } 12 | 13 | int[] smallAns=allIndexes(arr, start+1, end, num); 14 | if(arr[start]==num) { 15 | int[] ans=new int[smallAns.length+1]; 16 | ans[0]=start; 17 | for(int i=0;i end) { 13 | return false; 14 | } 15 | if(arr[start]==num) { 16 | return true; 17 | } 18 | return checkNumberInArray(arr, start+1, end, num); 19 | } 20 | 21 | public static void main(String[] args) { 22 | // TODO Auto-generated method stub 23 | int[] arr= {1,2,3,4,5,6,7,8}; 24 | System.out.println(checkNumberInArray(arr, 1)); 25 | 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /Recursion 1/CheckPalindrome.java: -------------------------------------------------------------------------------- 1 | 2 | public class CheckPalindrome { 3 | 4 | public static boolean checkPalindrome(String str,int start) { 5 | 6 | if(start == str.length() /2) { 7 | return true; 8 | } 9 | if(str.charAt(start)!=str.charAt(str.length()-start-1)) { 10 | return false; 11 | } 12 | return checkPalindrome(str, start + 1); 13 | } 14 | public static boolean checkPalindrome(String str) { 15 | return checkPalindrome(str, 0); 16 | } 17 | public static void main(String[] args) { 18 | String str="NikhkiN"; 19 | System.out.println(checkPalindrome(str)); 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /Recursion 1/CheckSorted.java: -------------------------------------------------------------------------------- 1 | 2 | public class CheckSorted { 3 | 4 | 5 | public static boolean checkSorted(int[] arr) { 6 | return checkSorted(arr,0,arr.length-1); 7 | } 8 | public static boolean checkSorted(int[] arr,int start,int end) { 9 | 10 | if(start >= end) { 11 | return true; 12 | } 13 | if(arr[start] > arr[start +1]) { 14 | return false; 15 | } 16 | return checkSorted(arr, start+1, end); 17 | 18 | } 19 | public static void main(String[] args) { 20 | int[] arr= {2,4,6,7,8,3}; 21 | System.out.println(checkSorted(arr)); 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /Recursion 1/CountNumberOfDigits.java: -------------------------------------------------------------------------------- 1 | 2 | public class CountNumberOfDigits { 3 | 4 | public static int countNumberOfDigits(int n) { 5 | 6 | 7 | if(n==0) { 8 | return 0; 9 | } 10 | return 1 + countNumberOfDigits(n/10); 11 | 12 | } 13 | 14 | 15 | public static void main(String[] args) { 16 | int n=153; 17 | System.out.println(countNumberOfDigits(n)); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /Recursion 1/CountZeroes.java: -------------------------------------------------------------------------------- 1 | 2 | public class CountZeroes { 3 | 4 | 5 | public static int countZerosRec(int n) { 6 | 7 | if(n==0) { 8 | return 0; 9 | } 10 | int temp= countZerosRec(n/10); 11 | if(n%10==0) { 12 | return temp +1; 13 | } 14 | return temp; 15 | 16 | } 17 | 18 | public static void main(String[] args) { 19 | // TODO Auto-generated method stub 20 | 21 | int n=10204; 22 | System.out.println(countZerosRec(n)); 23 | 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /Recursion 1/Factorial.java: -------------------------------------------------------------------------------- 1 | 2 | public class Factorial { 3 | 4 | public static int factorial(int n) { 5 | 6 | if(n==0) { 7 | return 1; 8 | } 9 | return n * factorial (n-1); 10 | 11 | } 12 | public static void main(String[] args) { 13 | int n=6; 14 | System.out.println(factorial(n)); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Recursion 1/Fibonacci.java: -------------------------------------------------------------------------------- 1 | 2 | public class Fibonacci { 3 | 4 | public static int fibonacci(int n) { 5 | 6 | if(n==0 || n==1) { 7 | return n; 8 | } 9 | return fibonacci(n-1) + fibonacci(n-2); 10 | 11 | } 12 | 13 | //Dp 14 | public static int fibonacciDP(int n) { 15 | 16 | if(n==0 || n==1) { 17 | return n; 18 | } 19 | 20 | int[] arr=new int[n+1]; 21 | 22 | arr[0]=0; 23 | arr[1]=1; 24 | 25 | for(int i=2;i<=n;i++) { 26 | arr[i]=arr[i-1]+arr[i-2]; 27 | } 28 | return arr[n]; 29 | 30 | } 31 | public static void main(String[] args) { 32 | int n=7; 33 | System.out.println(fibonacci(n)); 34 | System.out.println(fibonacciDP(n)); 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /Recursion 1/FirstIndex.java: -------------------------------------------------------------------------------- 1 | 2 | public class FirstIndex { 3 | 4 | 5 | public static int firstIndex(int[] arr ,int start ,int end,int num) { 6 | 7 | if(start > end){ 8 | return -1; 9 | } 10 | if(arr[start]==num) { 11 | return start; 12 | } 13 | return firstIndex(arr, start+1, end, num); 14 | } 15 | public static int firstIndex(int[] arr,int num) { 16 | return firstIndex(arr, 0, arr.length-1, num); 17 | } 18 | 19 | public static void main(String[] args) { 20 | // TODO Auto-generated method stub 21 | int[] arr= {1,2,4,4,6,7,8,4}; 22 | System.out.println(firstIndex(arr, 4)); 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Recursion 1/GeometricSum.java: -------------------------------------------------------------------------------- 1 | 2 | public class GeometricSum { 3 | 4 | 5 | public static double findGeometricSum(int n) { 6 | 7 | 8 | if(n==0) { 9 | return 1; 10 | } 11 | return 1/Math.pow(2, n) + findGeometricSum(n-1); 12 | 13 | } 14 | public static void main(String[] args) { 15 | int n=3; 16 | System.out.println(findGeometricSum(n)); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Recursion 1/LastIndex.java: -------------------------------------------------------------------------------- 1 | 2 | public class LastIndex { 3 | 4 | public static void main(String[] args) { 5 | // TODO Auto-generated method stub 6 | int[] arr= {1,2,6,7,8}; 7 | System.out.println(lastIndex(arr, 4)); 8 | } 9 | 10 | public static int lastIndex(int[] arr, int num) { 11 | 12 | return lastIndex(arr,0,arr.length-1,num); 13 | } 14 | public static int lastIndex(int[] arr,int start,int end,int num) { 15 | 16 | if(start > end) { 17 | return -1; 18 | } 19 | if(arr[end] == num){ 20 | return end; 21 | } 22 | return lastIndex(arr, start, end-1, num); 23 | 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /Recursion 1/MultiplyTwoIntegers.java: -------------------------------------------------------------------------------- 1 | 2 | public class MultiplyTwoIntegers { 3 | 4 | public static int multiplyTwoIntegers(int a,int b) { 5 | 6 | if(b==0) { 7 | return 0; 8 | } 9 | return a + multiplyTwoIntegers(a, b-1); 10 | 11 | } 12 | 13 | public static void main(String[] args) { 14 | // TODO Auto-generated method stub 15 | System.out.println(multiplyTwoIntegers(12, 5)); 16 | 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Recursion 1/Power.java: -------------------------------------------------------------------------------- 1 | 2 | public class Power { 3 | 4 | public static long power(int a,int b) { 5 | 6 | if(b==0) { 7 | return 1; 8 | } 9 | return a * power(a,b-1); 10 | 11 | 12 | } 13 | 14 | public static void main(String[] args) { 15 | // TODO Auto-generated method stub 16 | int a=5,b=5; 17 | System.out.println(power(a, b)); 18 | 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Recursion 1/SumOfArrays.java: -------------------------------------------------------------------------------- 1 | 2 | public class SumOfArrays { 3 | 4 | 5 | public static int sumOfArrays(int[] arr) { 6 | return sumOfArrays(arr,0,arr.length-1); 7 | } 8 | private static int sumOfArrays(int[] arr,int start,int end) { 9 | 10 | if(start>end) { 11 | return 0; 12 | } 13 | return arr[start] + sumOfArrays(arr, start+1, end); 14 | 15 | } 16 | 17 | public static void main(String[] args) { 18 | // TODO Auto-generated method stub 19 | 20 | int[] arr= {1,2,3,4,5}; 21 | System.out.println(sumOfArrays(arr)); 22 | 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Recursion 1/SumOfTheDigits.java: -------------------------------------------------------------------------------- 1 | 2 | public class SumOfTheDigits { 3 | 4 | public static int sumOfTheDigits(int n) { 5 | 6 | if(n==0) { 7 | return 0; 8 | } 9 | return n%10 + sumOfTheDigits(n/10); 10 | 11 | } 12 | 13 | public static void main(String[] args) { 14 | // TODO Auto-generated method stub 15 | int n=123456; 16 | System.out.println(sumOfTheDigits(n)); 17 | } 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Recursion 1/SumToN.java: -------------------------------------------------------------------------------- 1 | 2 | public class SumToN { 3 | 4 | public static int sumToN(int n) { 5 | 6 | if(n==0) { 7 | return 0; 8 | } 9 | return n + sumToN(n-1); 10 | 11 | } 12 | 13 | 14 | public static void main(String[] args) { 15 | // TODO Auto-generated method stub 16 | int n=10; 17 | System.out.println(sumToN(n)); 18 | 19 | } 20 | 21 | } 22 | -------------------------------------------------------------------------------- /Recursion 1/printNumbers.java: -------------------------------------------------------------------------------- 1 | 2 | public class printNumbers { 3 | 4 | public static void printNumbersToN(int n) { 5 | 6 | if(n==0) { 7 | return ; 8 | } 9 | printNumbersToN(n-1); 10 | System.out.print(n +" "); 11 | 12 | 13 | 14 | } 15 | public static void main(String[] args) { 16 | int n=10; 17 | printNumbersToN(n); 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /Recursion 2/BinarySearch.java: -------------------------------------------------------------------------------- 1 | 2 | public class BinarySearch { 3 | 4 | public static int binarySearch(int arr[],int num) { 5 | return binarySearch(arr,0,arr.length-1,num); 6 | } 7 | public static int binarySearch(int arr[],int start,int end,int num) { 8 | 9 | if(start>end){ 10 | return -1; 11 | } 12 | int mid=(start + end)/2; 13 | if(arr[mid]==num) { 14 | return mid; 15 | } 16 | else if(num < arr[mid]) { 17 | return binarySearch(arr, start, mid-1, num); 18 | } 19 | else { 20 | return binarySearch(arr, mid+1, end, num); 21 | } 22 | 23 | } 24 | public static void main(String[] args) { 25 | 26 | int[] arr= {2,3,4,5,6,7,20}; 27 | System.out.println(binarySearch(arr, 20)); 28 | 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /Recursion 2/CheckAB.java: -------------------------------------------------------------------------------- 1 | 2 | public class CheckAB { 3 | 4 | public static boolean checkAB(String str) { 5 | 6 | if(str.length()==0) { 7 | return true; 8 | } 9 | if(str.charAt(0)!='a') { 10 | return false; 11 | } 12 | if(str.length()>=3 && str.substring(0,3).equals("abb")) { 13 | return checkAB(str.substring(3)); 14 | } 15 | return checkAB(str.substring(1)); 16 | } 17 | public static void main(String[] args) { 18 | String str="abba"; 19 | 20 | System.out.println(checkAB(str)); 21 | } 22 | 23 | 24 | } 25 | 26 | 27 | -------------------------------------------------------------------------------- /Recursion 2/MergeSort.java: -------------------------------------------------------------------------------- 1 | 2 | public class MergeSort { 3 | 4 | 5 | public static void mergeSort(int[] arr) { 6 | mergeSort(arr,0,arr.length-1); 7 | } 8 | public static void mergeSort(int[] arr,int start,int end) { 9 | if(start>=end) { 10 | return ; 11 | } 12 | int mid= (start + end)/2; 13 | mergeSort(arr, start, mid); 14 | mergeSort(arr,mid+1,end); 15 | merge(arr,start,end); 16 | } 17 | private static void merge(int[] arr, int start, int end) { 18 | 19 | int mid=(start + end)/2; 20 | int i=start,j=mid+1,k=0; 21 | int[] temp=new int[end-start+1]; 22 | 23 | while(i<=mid && j <=end) { 24 | if(arr[i] <= arr[j]) { 25 | temp[k++]=arr[i++]; 26 | } 27 | else { 28 | temp[k++]=arr[j++]; 29 | } 30 | } 31 | 32 | while(i<=mid) { 33 | temp[k++]=arr[i++]; 34 | } 35 | while(j<=end) { 36 | temp[k++]=arr[j++]; 37 | } 38 | int x=0; 39 | for(int m=start;m<=end;m++) { 40 | arr[m]=temp[x++]; 41 | } 42 | 43 | 44 | 45 | } 46 | 47 | public static void main(String[] args) { 48 | int[] arr= {9,8,7,6,4,3,3,7,8,5}; 49 | mergeSort(arr); 50 | for(int i : arr) { 51 | System.out.print(i+" "); 52 | } 53 | } 54 | 55 | } 56 | -------------------------------------------------------------------------------- /Recursion 2/QuickSort.java: -------------------------------------------------------------------------------- 1 | 2 | public class QuickSort { 3 | 4 | 5 | public static void quickSort(int[] arr) { 6 | quickSort(arr,0,arr.length-1); 7 | } 8 | 9 | public static void quickSort(int[] arr,int start,int end) { 10 | 11 | if(start>=end) { 12 | return ; 13 | } 14 | int pivotPos=partition(arr,start,end); 15 | quickSort(arr, start, pivotPos-1); 16 | quickSort(arr, pivotPos+1, end); 17 | 18 | } 19 | public static int partition(int[] arr,int start,int end) { 20 | 21 | int pivot=arr[start]; 22 | int count=0; 23 | for(int i=start+1;i<=end;i++) { 24 | if(arr[i] <= pivot) { 25 | count++; 26 | } 27 | } 28 | 29 | int pivotPos=start+count; 30 | int temp=arr[pivotPos]; 31 | arr[pivotPos]=arr[start]; 32 | arr[start]=temp; 33 | 34 | int i=start,j=end; 35 | while(i < pivotPos && j> pivotPos) { 36 | if(arr[i] <= pivot) { 37 | i++; 38 | } 39 | else if(arr[j] > pivot) { 40 | j--; 41 | } 42 | else { 43 | int temp2=arr[i]; 44 | arr[i]=arr[j]; 45 | arr[j]=temp2; 46 | i++; 47 | j--; 48 | 49 | } 50 | } 51 | return pivotPos; 52 | 53 | } 54 | 55 | public static void main(String[] args) { 56 | int[] arr= {9,8,7,6,4,3,3,7,8,5}; 57 | quickSort(arr); 58 | for(int i : arr) { 59 | System.out.print(i+" "); 60 | } 61 | } 62 | 63 | } 64 | -------------------------------------------------------------------------------- /Recursion 2/RemoveDuplicates.java: -------------------------------------------------------------------------------- 1 | 2 | public class RemoveDuplicates { 3 | 4 | public static String removeDuplicates(String str) { 5 | 6 | if(str.length()==1) { 7 | return str; 8 | } 9 | String smallAns=removeDuplicates(str.substring(1)); 10 | 11 | if(smallAns.charAt(0)==str.charAt(0)) { 12 | return smallAns; 13 | } 14 | return str.charAt(0) + smallAns; 15 | 16 | } 17 | public static void main(String[] args) { 18 | String str="aabbbaacccba"; 19 | System.out.println(removeDuplicates(str)); 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /Recursion 2/RemoveX.java: -------------------------------------------------------------------------------- 1 | 2 | public class RemoveX { 3 | 4 | 5 | public static String removeX(String str) { 6 | 7 | if(str.length()==0) { 8 | return str; 9 | } 10 | String smallAns=removeX(str.substring(1)); 11 | if(str.charAt(0)=='x') { 12 | return smallAns; 13 | } 14 | return str.charAt(0) + smallAns; 15 | 16 | } 17 | 18 | public static void main(String[] args) { 19 | // TODO Auto-generated method stub 20 | String str="xxxaxbxcdsxexxxx"; 21 | System.out.println(removeX(str)); 22 | 23 | } 24 | 25 | } 26 | -------------------------------------------------------------------------------- /Recursion 2/ReplaceCharacters.java: -------------------------------------------------------------------------------- 1 | 2 | public class ReplaceCharacters { 3 | 4 | 5 | public static String replaceCharacters(String str,char c1,char c2) { 6 | 7 | if(str.length()==0) { 8 | return str; 9 | } 10 | 11 | String smallAns=replaceCharacters(str.substring(1), c1, c2); 12 | if(str.charAt(0)==c1) { 13 | return c2 + smallAns; 14 | } 15 | 16 | return str.charAt(0) + smallAns; 17 | 18 | } 19 | 20 | public static void main(String[] args) { 21 | 22 | String str="Nikhil"; 23 | System.out.println(replaceCharacters(str, 'i', 'a')); 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Recursion 2/Return_Print_Subsequences.java: -------------------------------------------------------------------------------- 1 | 2 | public class Return_Print_Subsequences { 3 | 4 | //O(n^2) 5 | public static String[] returnSubsequences(String str) { 6 | if(str.length()==0) { 7 | String[] ans= {""}; 8 | return ans; 9 | } 10 | String[] smallAns=returnSubsequences(str.substring(1)); 11 | String[] ans=new String[2*smallAns.length]; 12 | for(int i=0;iend) { 11 | return new int[1][0]; 12 | } 13 | int[][] smallAns=subsetsOfArray(arr, start+1, end); 14 | int[][] ans=new int[smallAns.length * 2][]; 15 | 16 | for(int i=0;iend) { 40 | for(int i : output) { 41 | System.out.print(i+" "); 42 | } 43 | System.out.println(); 44 | return ; 45 | } 46 | int[] temp=new int[output.length + 1]; 47 | 48 | for(int i=0;iend) { 10 | if(k==0) { 11 | return new int[1][0]; 12 | }else { 13 | return new int[0][0]; 14 | } 15 | } 16 | int[][] smallAns1=subsetsToK(arr, start+1, end, k-arr[start]); 17 | int[][] smallAns2=subsetsToK(arr, start+1, end, k); 18 | int[][] ans=new int[smallAns1.length + smallAns2.length][]; 19 | for(int i=0;iend) { 41 | if(k==0) { 42 | //valid pair 43 | for(int i : output) { 44 | System.out.print(i+" "); 45 | } 46 | System.out.println(); 47 | return ; 48 | }else { 49 | return ; 50 | } 51 | } 52 | int[] temp = new int[output.length+1]; 53 | for(int i=0;i=2) { 17 | char firstTwoChar=(char)( (str.charAt(0) -'0') * 10 + (str.charAt(1)-'0') +'a' -1); 18 | if(firstTwoChar>='a' && firstTwoChar<='z') { 19 | smallAns2=returnAllCodes(str.substring(2)); 20 | for(int i=0;i=2) { 48 | char firstTwoChar= (char)( (str.charAt(0) -'0')*10 +(str.charAt(1)-'0') + 'a' -1 ); 49 | 50 | if(firstTwoChar >='a' && firstTwoChar <='z') { 51 | printAllCodes(str.substring(2), output + firstTwoChar); 52 | } 53 | 54 | } 55 | 56 | } 57 | 58 | public static void main(String[] args) { 59 | String str="35411"; 60 | // String[] ans=returnAllCodes(str); 61 | // for(String s : ans) { 62 | // System.out.println(s); 63 | // } 64 | printAllCodes(str); 65 | } 66 | } 67 | -------------------------------------------------------------------------------- /Recursion 2/Return_and_Print_permutations.java: -------------------------------------------------------------------------------- 1 | 2 | public class Return_and_Print_permutations { 3 | 4 | public static String[] permutations(String str) { 5 | 6 | if(str.length()==0) { 7 | String[] ans= {""}; 8 | return ans; 9 | } 10 | String[] smallAns=permutations(str.substring(1)); 11 | String[] ans= new String[smallAns.length * str.length()]; 12 | int k=0; 13 | for(int i=0;i arr[j+1]) { 18 | int temp=arr[j]; 19 | arr[j]=arr[j+1]; 20 | arr[j+1]=temp; 21 | swapped=true; 22 | } 23 | } 24 | if(!swapped) { 25 | return; 26 | } 27 | } 28 | 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /Searching and Sorting/CheckArrayRotation.java: -------------------------------------------------------------------------------- 1 | 2 | public class CheckArrayRotation { 3 | 4 | public static int checkRotation(int[] arr) { 5 | int min=Integer.MAX_VALUE; 6 | int minIndex=Integer.MAX_VALUE; 7 | for(int i=0;i=0 && temp < arr[j]) { 12 | arr[j+1]=arr[j]; 13 | j--; 14 | 15 | } 16 | arr[j+1]=temp; 17 | } 18 | 19 | 20 | } 21 | 22 | public static void main(String[] args) { 23 | // TODO Auto-generated method stub 24 | int[] arr=Array.takeInput(); 25 | insertionSort(arr); 26 | Array.printArray(arr); 27 | 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /Searching and Sorting/LinearSearch.java: -------------------------------------------------------------------------------- 1 | 2 | public class LinearSearch { 3 | 4 | 5 | public static int linearSearch(int[] arr,int n) { 6 | for(int i=0 ;isecondLargest) { 14 | secondLargest=arr[i]; 15 | } 16 | } 17 | return secondLargest; 18 | } 19 | 20 | 21 | public static void main(String[] args) { 22 | int[] arr=Array.takeInput(); 23 | System.out.println(secondLargest(arr)); 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /Searching and Sorting/SelectionSort.java: -------------------------------------------------------------------------------- 1 | 2 | public class SelectionSort { 3 | 4 | public static void main(String[] args) { 5 | // TODO Auto-generated method stub 6 | int[] arr=Array.takeInput(); 7 | selectionSort(arr); 8 | Array.printArray(arr); 9 | 10 | } 11 | 12 | public static void selectionSort(int[] arr) { 13 | 14 | for(int i=0;i=0 && j>=0) { 11 | 12 | int sum=arr1[i--]+arr2[j--] + carry; 13 | arr[k--]=sum%10; 14 | carry=sum/10; 15 | 16 | } 17 | while(i>=0) { 18 | int sum=arr1[i--]+carry; 19 | arr[k--]=sum%10; 20 | carry=sum/10; 21 | } 22 | while(j>=0) { 23 | int sum=arr2[j--]+carry; 24 | arr[k--]=sum%10; 25 | carry=sum/10; 26 | } 27 | arr[0]=carry; 28 | 29 | return arr; 30 | } 31 | 32 | 33 | public static void main(String[] args) { 34 | int[] arr1= {3,9,9}; 35 | int[] arr2={4,1,1}; 36 | int[] arr=sumOfArrays(arr1, arr2); 37 | Array.printArray(arr); 38 | 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /Strings/CheckPalindrome.java: -------------------------------------------------------------------------------- 1 | 2 | public class CheckPalindrome { 3 | 4 | public static boolean checkPalindrome(String str) { 5 | 6 | int i=0,j=str.length()-1; 7 | while(i map=new HashMap(); 9 | for(int i=0;i1) { 20 | x=x+(char)(count+'0'); 21 | } 22 | 23 | } 24 | 25 | else if(x.charAt(x.length()-1)==str.charAt(i)) { 26 | count++; 27 | } 28 | else { 29 | if(count>1) { 30 | x=x+(char)(count+'0'); 31 | } 32 | x=x+str.charAt(i); 33 | count=1; 34 | } 35 | 36 | } 37 | return x; 38 | 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /Strings/CountWords.java: -------------------------------------------------------------------------------- 1 | 2 | public class CountWords { 3 | 4 | 5 | public static int countWords(String str) { 6 | int words=1; 7 | for(int i=0;i map=new HashMap(); 7 | 8 | for(int i=0;i=0;i--) 20 | x=x+str.charAt(i); 21 | return x; 22 | } 23 | public static void main(String[] args) { 24 | String str="Welcome to Coding Ninjas"; 25 | System.out.println(reverseEachWord(str)); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /Strings/ReverseStringWordWise.java: -------------------------------------------------------------------------------- 1 | 2 | public class ReverseStringWordWise { 3 | 4 | public static String reverseStringWordWise(String str) { 5 | 6 | String x=""; 7 | int space=str.length(); 8 | for(int i=str.length()-1;i>=0;i--) { 9 | 10 | if(i==0) { 11 | x=x+str.substring(0,space); 12 | } 13 | 14 | else if(str.charAt(i)==' ') { 15 | x=x+str.substring(i+1,space)+" "; 16 | space=i; 17 | } 18 | } 19 | return x; 20 | 21 | } 22 | 23 | public static void main(String[] args) { 24 | String str="Welcome To Coding Ninjas"; 25 | System.out.println(reverseStringWordWise(str)); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /Test 2/LeadersOfArray.java: -------------------------------------------------------------------------------- 1 | 2 | public class LeadersOfArray { 3 | 4 | public static void leaders(int[] arr) { 5 | 6 | 7 | for(int i=0;i length) { 15 | minLength=length; 16 | startIndex=spaceIndex; 17 | endIndex=i; 18 | } 19 | spaceIndex=i+1; 20 | } 21 | 22 | 23 | } 24 | return str.substring(startIndex,endIndex); 25 | 26 | 27 | } 28 | public static void main(String[] args) { 29 | String str="This is a test String"; 30 | System.out.println(minimumLengthWord(str)); 31 | } 32 | 33 | 34 | } 35 | -------------------------------------------------------------------------------- /Test 2/Print2DArray.java: -------------------------------------------------------------------------------- 1 | 2 | public class Print2DArray { 3 | 4 | 5 | public static void print2DArray(int[][] arr) { 6 | for(int i=0;i0) { 14 | length++; 15 | num/=10; 16 | } 17 | int sum=0; 18 | while(n>0) { 19 | sum+=(Math.pow(n %10, length)); 20 | n/=10; 21 | } 22 | if(originalNumber==sum) { 23 | System.out.println(true); 24 | }else { 25 | System.out.println(false); 26 | } 27 | 28 | 29 | } 30 | 31 | } 32 | -------------------------------------------------------------------------------- /Test1/NumberStarPattern1.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class NumberStarPattern1 { 4 | 5 | public static void main(String[] args) { 6 | 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | for(int i=1;i<=n;i++) { 10 | for(int j=1;j<=n;j++) { 11 | if(n-j+1 == i) { 12 | System.out.print("*"); 13 | }else { 14 | System.out.print(n-j+1); 15 | } 16 | } 17 | System.out.println(); 18 | } 19 | 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /Test1/ZeroesAndStarPattern.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class ZeroesAndStarPattern { 4 | 5 | public static void main(String[] args) { 6 | 7 | Scanner scan=new Scanner(System.in); 8 | int n=scan.nextInt(); 9 | int l=2*n+1; 10 | for(int i=1;i<=n;i++) { 11 | for(int j=1;j<=l;j++) { 12 | if(j==(n+1) || j==i || i== l-j+1) { 13 | System.out.print("*"); 14 | }else { 15 | System.out.print(0); 16 | } 17 | } 18 | System.out.println(); 19 | } 20 | 21 | 22 | } 23 | 24 | } 25 | -------------------------------------------------------------------------------- /Time and Space Complexity/ArrayEquilibrium.java: -------------------------------------------------------------------------------- 1 | public class ArrayEquilibrium{ 2 | 3 | public static int arrayEquilibrium(int[] arr){ 4 | int rightSum=0; 5 | for(int i=0;i< arr.length;i++){ 6 | rightSum+=arr[i]; 7 | } 8 | //full array total sum 9 | 10 | int leftSum=0; 11 | 12 | for(int i=0;i map=new HashMap(); 9 | for(int i=0;iarr[i]) { 10 | min=arr[i]; 11 | minIndex=i; 12 | } 13 | } 14 | return minIndex; 15 | 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /Time and Space Complexity/DuplicateInArray.java: -------------------------------------------------------------------------------- 1 | 2 | public class DuplicateInArray { 3 | 4 | public static int duplicate(int[] arr) { 5 | 6 | 7 | int n=arr.length-2; 8 | int sum=0; 9 | for(int i : arr) { 10 | sum+=i; 11 | } 12 | return sum-(n*(n+1)/2); 13 | 14 | } 15 | public static void main(String[] args) { 16 | int[] arr= {0 ,7 ,2 ,5 ,4 ,7 ,1 ,3, 6}; 17 | System.out.println(duplicate(arr)); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /Time and Space Complexity/PairSum.java: -------------------------------------------------------------------------------- 1 | import java.util.HashMap; 2 | 3 | public class PairSum { 4 | //O(n) 5 | public static void pairSum(int[] arr,int sum) { 6 | HashMap map=new HashMap(); 7 | 8 | for(int i=0;i map=new HashMap(); 14 | 15 | for(int j=i+1;j