├── src ├── SearchingAlgorithms │ ├── smallestDivisorGivenByThreshold.java │ ├── squareRoot.java │ ├── peakIndexInMountainArray.java │ └── lowerBound.java ├── Recursion │ ├── climbStairs.java │ ├── printNto1.java │ ├── NthStair.java │ ├── factorial.java │ ├── sumOfN.java │ ├── print1toN.java │ ├── fibonacciSeries.java │ ├── arrayTraversal.java │ ├── preInPost.java │ ├── power.java │ ├── tribonacciNumber.java │ ├── maxSubarrayProduct.java │ ├── powerWithLogarithmic.java │ ├── generateParenthesis.java │ ├── gcdRecursion.java │ ├── mazePath2.java │ ├── subsets.java │ ├── binaryStringWithoutConsecutiveOnes.java │ ├── stringTraversal.java │ ├── minimumPathSum.java │ ├── mazePath.java │ └── uniquePaths.java ├── Arrays │ ├── sumOfDigitsOfStringAfterConvert.java │ ├── rollNumber.java │ ├── findSingleNumber.java │ ├── sumOfElements.java │ ├── isPowerOfFour.java │ ├── maxElementInArray.java │ ├── threeDivisors.java │ ├── smallestEvenMultiple.java │ ├── runningSum.java │ ├── addDigits.java │ ├── removeElement.java │ ├── powerOfThree.java │ ├── sort0and1MethodTwo.java │ ├── commonFactors.java │ ├── smallestCommonElement.java │ ├── mergeTripletsToFormTargetTriplet.java │ ├── secondMaxInArray.java │ ├── specialArray.java │ ├── maxProfit.java │ ├── diagonalSum.java │ ├── removeDuplicateElements.java │ ├── checkIfDoubleExist.java │ ├── findKthPositive.java │ ├── harshadNumber.java │ ├── subArraySum.java │ ├── uglyNumber.java │ ├── happyNumber.java │ ├── nextGreatestLetter.java │ ├── basicsOfArrayList.java │ ├── minRemovalToBalanceArray.java │ ├── firstBadVersion.java │ ├── maximumSubarray.java │ ├── arrayPartition.java │ ├── findGCD.java │ ├── calculateMoney.java │ ├── digitGame.java │ ├── numberOfBits.java │ ├── sortOsand1sMethodone.java │ ├── divideTwoIntegers.java │ ├── goodPairsI.java │ ├── maxConsecutiveOnes.java │ ├── findAllDuplicates.java │ ├── maxMedianSum.java │ ├── oneBitAndTwoBitCharacters.java │ ├── reverseArray.java │ ├── maximum69Number.java │ ├── rankTransform.java │ ├── singleNonDuplicate.java │ ├── checkDivisibility.java │ ├── containsDuplicate.java │ ├── countPrimes.java │ ├── maximumProductSubarray.java │ ├── maxDiffBetweenIncreasingElements.java │ ├── monotonicArray.java │ ├── specialArray1.java │ ├── meanOfArrayAfterRemovingMinAndMaxElements.java │ ├── countMatches.java │ ├── findNumberWithEvenDigits.java │ ├── countDigitsDivideNumber.java │ ├── sort0and1and2_Method2.java │ ├── sumOfUniqueElements.java │ ├── thirdMax.java │ ├── countGoodTriplets.java │ ├── multiplyingFoundValuesByTwo.java │ ├── twoFarthestHouseDist.java │ ├── plusOne.java │ ├── sumOfAbsoluteDiff.java │ ├── findFirstPalindromicString.java │ ├── singleNumber2.java │ ├── findIndicesOfStableMountain.java │ ├── countOperations.java │ ├── createTargetArray.java │ ├── rotateArray.java │ ├── duplicateZeroes.java │ ├── minimumElementAfterReplacementWithDigitSum.java │ ├── containsDuplicate2.java │ ├── countEven.java │ ├── containerWithMostWater.java │ ├── findDisappearedElements.java │ ├── missingElementInAP.java │ ├── minSumOfFourDigitsAfterSplitting.java │ ├── neitherMinOrMax.java │ ├── findNIntegersSumUptoZero.java │ ├── kthDistinctString.java │ ├── largestNumberAtLeastTwiceOfOthers.java │ ├── sort0and1and2_Method1.java │ ├── sumOfOddLengthSubArrays.java │ ├── twoSum.java │ ├── sumOfNumberAndReverse.java │ ├── sortArrayByParity.java │ ├── nextGreaterElement.java │ ├── reverseDegreeOfAString.java │ ├── sort0and1and2_DutchFlagAlgo.java │ ├── coutingBits.java │ ├── maxCandiesAllocatedToChildren.java │ ├── maxDiffBetweenAdjElements.java │ ├── mostFrequentEven.java │ ├── repeatedNtimes.java │ ├── maxValueOfString.java │ ├── countSeniorCitizens.java │ ├── removeOneElementToMakeArrayStrictlyIncreasing.java │ └── diStringMatch.java ├── Trees │ ├── TreeNode.java │ └── NodeOfTree.java ├── BinarySearchTree │ └── TreeNode.java ├── Strings │ ├── countDigits.java │ ├── compareTo.java │ ├── equalsMethod.java │ ├── indexOfFirstOccurence.java │ ├── inputStringBuilder.java │ ├── setCharAtMethod.java │ ├── returnMaxString.java │ ├── stringBuilderFunctions.java │ ├── addTwoStrings.java │ ├── addStrings.java │ ├── printSubstrings.java │ ├── updateEvenPositionOfString.java │ ├── lengthOfLastWord.java │ ├── toLowerCase.java │ ├── reverseSecondHalf.java │ ├── concatWithReverse.java │ ├── repeatedCharacter.java │ ├── countPrefixes.java │ ├── stringSorting.java │ ├── stringBuilderSorting.java │ ├── countValidWords.java │ ├── defangingAnIPAddress.java │ ├── findTheOriginalStringTypedI.java │ ├── palindrome.java │ ├── interning.java │ ├── checkBalancedString.java │ ├── stringBuilderInJava.java │ ├── getLucky.java │ ├── numberOfStringsThatAppearAsSubstringInWord.java │ ├── percentageOfLetterInString.java │ ├── faultyKeyboard.java │ ├── isSubsequence.java │ ├── splitAStringInBalanced.java │ ├── subtractTheProductAndSum.java │ ├── countAsterisks.java │ ├── reverseStringBuilder.java │ ├── anagram.java │ ├── scoreOfAString.java │ ├── excelSheetColumnTitle.java │ ├── checkPangram.java │ ├── rotateString.java │ ├── reverseWordsInStringIII.java │ ├── stringBuilder.java │ ├── concatenateNonZeroDigitsAndMultiplyBySum.java │ ├── minSwapsToMakeStringBalanced.java │ ├── sortTheSentence.java │ ├── stringCompression.java │ ├── removeOccurrencesOfSubstring.java │ ├── findTheKthCharacterInStringGameI.java │ ├── mimOperationToExceedThresholdValue.java │ ├── toggleCharacters.java │ ├── findWordsContainingCharacter.java │ ├── excelSheetColNumber.java │ ├── lexographicallyMaximum.java │ ├── reverseNumber.java │ ├── maximumWordsInSentence.java │ ├── longestCommonPrefix.java │ ├── shiftingLetters.java │ ├── reversePrefixOfAWord.java │ ├── frequencyArray.java │ ├── removeStarsFromString.java │ ├── removeTrailingZeroes.java │ ├── shuffleString.java │ ├── checkIfBinaryStringHasAtMostOneSegmentOfOnes.java │ ├── fizzBuzz.java │ ├── countVowels.java │ └── addSpacesToAString.java ├── BitManipulation │ ├── turnOffRightMostSetBit.java │ ├── swapTwoNumbers.java │ ├── hammingWeight.java │ ├── kthBitSetOrNot.java │ ├── minimumBitFlipsToConvert.java │ ├── powerOf2.java │ ├── findTheOriginalArrayOfPrefixXOR.java │ ├── decodeXORArray.java │ └── setKthBit.java ├── PrefixSum │ ├── minStartValue.java │ ├── runningSum.java │ ├── rangeSumQuery.java │ └── sumOfDistances.java ├── Loops │ ├── fibonacciSeries.java │ ├── countDigits.java │ ├── sumOfDigits.java │ ├── geometricMean.java │ ├── compositeNumber.java │ └── primeNumber.java ├── OoPs │ ├── methodOveridingReturnType.java │ ├── encapsulation.java │ └── constructor.java ├── LoopsAssignments │ ├── SumOfNaturalNos.java │ ├── MutiplicationOfNumber.java │ ├── FibonacciSeries.java │ ├── StringPalindrome.java │ └── GCDofTwoNumbers.java ├── Heaps │ ├── minTimeToFillCups.java │ ├── kthLargestElement.java │ ├── kthSmallestElement.java │ └── minimumCostToConnectRopes.java ├── PatternPrinting │ ├── Square │ │ ├── starSquare.java │ │ ├── numberSquare.java │ │ ├── alphabetSquare.java │ │ └── starRectangle.java │ ├── Triangle │ │ ├── starTriangle.java │ │ ├── numberTriangle.java │ │ ├── invertedStarTriangle.java │ │ ├── alphabetTriangle.java │ │ ├── invertedNumberTriangle.java │ │ ├── invertedAlphabetTriangle.java │ │ └── alphabetNumberTriangle.java │ ├── Special_Patterns │ │ ├── oddNumberTriangle.java │ │ ├── floydsTriangle.java │ │ ├── starCross.java │ │ ├── binaryTriangle.java │ │ └── starPlus.java │ └── Composite_Patterns │ │ ├── rhombus.java │ │ ├── starPyramid.java │ │ ├── starTriangleFlipped.java │ │ ├── numberTriangleFlipped.java │ │ ├── halfDiamond.java │ │ ├── numberPyramidPalindrome.java │ │ └── numberSpiral.java ├── Stack │ ├── basicStack.java │ ├── reverseStack.java │ ├── copyStack.java │ ├── validateStackSequence.java │ ├── nextGreaterElement.java │ ├── postfixToPrefix.java │ ├── postfixToInfix.java │ ├── prefixToInfix.java │ └── prefixToPostfix.java ├── DynamicProgramming │ ├── fibonacci.java │ ├── tribonacciNumber.java │ └── friendsPairingProblem.java ├── Hashmaps │ ├── treemap.java │ ├── minimumOperationsForMakingArrayZero.java │ ├── thirdMaximumNumber.java │ ├── findTheDifference.java │ ├── maximumUniqueSubArraySum.java │ ├── basicSet.java │ ├── iterateMap.java │ └── badPairs.java ├── SortingAlgorithms │ ├── checkIfArrayIsSortedOrNot.java │ ├── majorityElement.java │ ├── pushZeroesToEnd.java │ ├── selectionSortInReverse.java │ ├── transformArray.java │ └── bubbleSortInReverse.java ├── Methods │ ├── Square.java │ └── PrintOddBtnNos.java ├── LinkedList │ └── convertLLValuesToDecimal.java ├── Queue │ ├── basicQueue.java │ └── removeElementAtEvenIndex.java ├── TwoDimensionalArrays │ └── storeRollNoAndMarks.java ├── SlidingWindow │ ├── minimumDifferenceBetweenHighestAndLowest.java │ ├── maxLengthWithTwoOccurrence.java │ ├── maxSumOfSubarrays.java │ └── maxConsecutiveOnes.java └── Amazon │ └── angreziMedium.java ├── .idea ├── .gitignore ├── vcs.xml ├── misc.xml └── modules.xml ├── images └── img.png ├── .gitignore └── Decode Java plus DSA.iml /src/SearchingAlgorithms/smallestDivisorGivenByThreshold.java: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | -------------------------------------------------------------------------------- /images/img.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SarthakVitmal/DSA-In-Java/HEAD/images/img.png -------------------------------------------------------------------------------- /src/Recursion/climbStairs.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class climbStairs { 4 | } 5 | -------------------------------------------------------------------------------- /src/Arrays/sumOfDigitsOfStringAfterConvert.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class sumOfDigitsOfStringAfterConvert { 4 | public static void main(String[] args) { 5 | 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /src/Trees/TreeNode.java: -------------------------------------------------------------------------------- 1 | package Trees; 2 | 3 | public class TreeNode { 4 | TreeNode left; 5 | TreeNode right; 6 | int val; 7 | public TreeNode(int val){ 8 | this.val = val; 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /src/BinarySearchTree/TreeNode.java: -------------------------------------------------------------------------------- 1 | package BinarySearchTree; 2 | 3 | class TreeNode{ 4 | int val; 5 | TreeNode left; 6 | TreeNode right; 7 | TreeNode(int val){ 8 | this.val = val; 9 | } 10 | } -------------------------------------------------------------------------------- /src/Strings/countDigits.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class countDigits { 4 | public static void main(String[] args) { 5 | int num = 1234; 6 | String s = num + ""; 7 | System.out.println(s.length()); 8 | } 9 | } -------------------------------------------------------------------------------- /src/Strings/compareTo.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class compareTo { 4 | public static void main(String[] args) { 5 | String str1 = "abc"; 6 | String str2 = "ABC"; 7 | System.out.println(str1.compareTo(str2)); 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /src/Recursion/printNto1.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class printNto1 { 4 | public static void printN(int n){ 5 | if(n == 0) return; 6 | System.out.print(n + " "); 7 | printN(n-1); 8 | } 9 | public static void main(String[] args) { 10 | int n = 10; 11 | printN(n); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/Arrays/rollNumber.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class rollNumber { 4 | public static void main(String[] args) { 5 | int[] arr = {90,45,34,87,67,13,30}; 6 | 7 | for(int i=0;in)return; 6 | System.out.print(inc + " "); 7 | printN(inc+1,n); 8 | 9 | } 10 | public static void main(String[] args) { 11 | int n = 10; 12 | int incr = 1; 13 | printN(incr,n); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/Strings/indexOfFirstOccurence.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class indexOfFirstOccurence { 4 | public static void main(String[] args) { 5 | String haystack = "leetcode"; 6 | String needle = "leet"; 7 | 8 | int i = haystack.indexOf(needle); 9 | 10 | if(i!=-1) System.out.println(i); 11 | else System.out.println(-1); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/Recursion/fibonacciSeries.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class fibonacciSeries { 4 | public static int fibonacci(int n){ 5 | if(n==0 || n==1)return n; 6 | return fibonacci(n-1) + fibonacci(n-2); 7 | } 8 | public static void main(String[] args) { 9 | int n = 8; 10 | int res = fibonacci(n); 11 | System.out.println(res); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/Strings/inputStringBuilder.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | 5 | public class inputStringBuilder { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter a string : "); 9 | StringBuilder sb = new StringBuilder(sc.nextLine()); 10 | System.out.println(sb); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/Arrays/isPowerOfFour.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class isPowerOfFour { 4 | public static boolean isPower(int n){ 5 | for (int i = 0; i < 100; i++) { 6 | if(Math.pow(4,i) == n)return true; 7 | } 8 | return false; 9 | } 10 | public static void main(String[] args) { 11 | int n = 16; 12 | System.out.println(isPower(n)); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/Strings/setCharAtMethod.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | 5 | public class setCharAtMethod { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | StringBuilder sb = new StringBuilder(sc.nextLine()); 9 | System.out.println(sb); 10 | sb.setCharAt(0,'A'); 11 | System.out.println(sb); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/Recursion/arrayTraversal.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class arrayTraversal { 4 | public static void print(int i,int[] arr){ 5 | int n = arr.length; 6 | if(i==n)return; 7 | System.out.print(arr[i] + " "); 8 | print(i+1,arr); 9 | } 10 | public static void main(String[] args) { 11 | int[] arr = {1,2,3,4,5,6,7,10}; 12 | print(0,arr); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/Recursion/preInPost.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class preInPost { 4 | public static void pip(int n){ 5 | if(n==0)return; 6 | System.out.print(n + " "); //pre 7 | pip(n-1); 8 | System.out.print(n + " "); //in 9 | pip(n-1); 10 | System.out.print(n + " "); //post 11 | } 12 | public static void main(String[] args) { 13 | pip(4); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/Arrays/maxElementInArray.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class maxElementInArray { 4 | public static void main(String[] args) { 5 | int[] arr = {12,14,119,89,78}; 6 | 7 | int max = Integer.MIN_VALUE; 8 | for(int i=0;i= 10){ 8 | sum = 0; 9 | while (n > 0){ 10 | int rem = n % 10; 11 | sum += rem; 12 | n = n / 10; 13 | } 14 | n = sum; 15 | } 16 | System.out.println(n); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/BitManipulation/swapTwoNumbers.java: -------------------------------------------------------------------------------- 1 | package BitManipulation; 2 | 3 | public class swapTwoNumbers { 4 | public static void main(String[] args) { 5 | int a = 5; 6 | int b = 6; 7 | System.out.println("a="+a+" "+"b="+b); 8 | swap(a,b); 9 | } 10 | private static void swap(int a, int b){ 11 | a = a ^ b; 12 | b = a ^ b; 13 | a = a ^ b; 14 | System.out.println("a="+a+" "+"b="+b); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/PrefixSum/minStartValue.java: -------------------------------------------------------------------------------- 1 | package PrefixSum; 2 | 3 | public class minStartValue { 4 | public static void main(String[] args) { 5 | int[] arr = {-3,2,-3,4,2}; 6 | int startValue = 1; int prefixSum = 0; int minPrefixSum = 0; 7 | for(int num : arr){ 8 | prefixSum += num; 9 | minPrefixSum = Math.min(minPrefixSum,prefixSum); 10 | } 11 | System.out.println(startValue-minPrefixSum); 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/Arrays/removeElement.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class removeElement { 4 | public static void main(String[] args) { 5 | int[] arr = {0,1,2,2,3,0,4,2}; 6 | int j = 0; 7 | int k = 2; 8 | 9 | for (int i = 0; i < arr.length; i++) { 10 | if(arr[i] != k){ 11 | arr[j] = arr[i]; 12 | System.out.print(arr[j] +" "); 13 | j++; 14 | } 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ### IntelliJ IDEA ### 2 | out/ 3 | !**/src/main/**/out/ 4 | !**/src/test/**/out/ 5 | 6 | ### Eclipse ### 7 | .apt_generated 8 | .classpath 9 | .factorypath 10 | .project 11 | .settings 12 | .springBeans 13 | .sts4-cache 14 | bin/ 15 | !**/src/main/**/bin/ 16 | !**/src/test/**/bin/ 17 | 18 | ### NetBeans ### 19 | /nbproject/private/ 20 | /nbbuild/ 21 | /dist/ 22 | /nbdist/ 23 | /.nb-gradle/ 24 | 25 | ### VS Code ### 26 | .vscode/ 27 | 28 | ### Mac OS ### 29 | .DS_Store -------------------------------------------------------------------------------- /Decode Java plus DSA.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /src/BitManipulation/hammingWeight.java: -------------------------------------------------------------------------------- 1 | package BitManipulation; 2 | 3 | public class hammingWeight { 4 | public static int hammingWt(int n) { 5 | int count = 0; 6 | for(int i=0;i<32;i++){ 7 | int mask = 1 << i; 8 | if((n&mask) != 0)count++; 9 | } 10 | return count; 11 | } 12 | public static void main(String[] args) { 13 | int a = 0b111111; 14 | System.out.println(hammingWt(a)); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/BitManipulation/kthBitSetOrNot.java: -------------------------------------------------------------------------------- 1 | package BitManipulation; 2 | 3 | public class kthBitSetOrNot { 4 | public static void main(String[] args) { 5 | int a = 0b1111; 6 | int k = 3; 7 | boolean ans = isBitSet(a,k); 8 | System.out.println(ans); 9 | } 10 | 11 | private static boolean isBitSet(int a, int k) { 12 | int masked = 1 << k; 13 | if((a & masked) != 0)return false; 14 | return true; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/BitManipulation/minimumBitFlipsToConvert.java: -------------------------------------------------------------------------------- 1 | package BitManipulation; 2 | 3 | public class minimumBitFlipsToConvert { 4 | public static void main(String[] args) { 5 | int start = 10; 6 | int end = 7; 7 | int ans = minBitFlips(start,end); 8 | System.out.println(ans); 9 | } 10 | 11 | private static int minBitFlips(int start, int end) { 12 | int xor = start ^ end; 13 | return Integer.bitCount(xor); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/Strings/addTwoStrings.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.math.BigDecimal; 4 | 5 | public class addTwoStrings { 6 | public static void main(String[] args) { 7 | String num1 = "101"; 8 | String num2 = "10"; 9 | 10 | int num3 = Integer.parseInt(num1); 11 | int num4 = Integer.parseInt(num2); 12 | 13 | int num5 = num3 + num4; 14 | String s2 = String.valueOf(num5); 15 | System.out.println(s2); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/BitManipulation/powerOf2.java: -------------------------------------------------------------------------------- 1 | package BitManipulation; 2 | 3 | import java.util.Scanner; 4 | 5 | public class powerOf2 { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter the power of 2 : "); 9 | int x = sc.nextInt(); 10 | int ans = power(x); 11 | System.out.println(ans); 12 | } 13 | private static int power(int x){ 14 | return 1<= arr.length-1)return 0; 6 | int pro = arr[i] * arr[i+1]; 7 | return Math.max(pro,maxProduct(arr,i+2)); 8 | } 9 | public static void main(String[] args) { 10 | int[] arr = {2,3,-2,4}; 11 | int ans = maxProduct(arr,0); 12 | System.out.println(ans); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/Loops/fibonacciSeries.java: -------------------------------------------------------------------------------- 1 | package Loops; 2 | 3 | public class fibonacciSeries { 4 | public static void main(String[] args) { 5 | int n1 = 0; 6 | int n2 = 1; 7 | int n3; 8 | int count = 10; 9 | System.out.print(n1 + " " + n2 + " "); 10 | for (int i = 2; i <= count; i++) { 11 | n3 = n1 + n2; 12 | System.out.print(n3 + " "); 13 | n1 = n2; 14 | n2 = n3; 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/OoPs/methodOveridingReturnType.java: -------------------------------------------------------------------------------- 1 | package OoPs; 2 | class Parent1 { 3 | public Object methodOne(){ 4 | return null; 5 | } 6 | } 7 | class Child1 extends Parent1 { 8 | public String methodOne(){ 9 | System.out.println("Say Hello"); 10 | return null; 11 | } 12 | } 13 | public class methodOveridingReturnType { 14 | public static void main(String[] args) { 15 | Parent1 p5 = new Child1(); 16 | p5.methodOne(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Recursion/powerWithLogarithmic.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class powerWithLogarithmic { 4 | public static int power(int a,int b){ 5 | if(b==0)return 1; 6 | int ans = power(a,b/2); 7 | if(b%2==0)return ans * ans; 8 | else return ans * ans * a; 9 | } 10 | public static void main(String[] args) { 11 | int a = 2; 12 | int b = 4; 13 | int res = power(a,b); 14 | System.out.println(res); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/Strings/addStrings.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class addStrings { 4 | public static void main(String[] args) { 5 | String str1 = "10"; 6 | String str2 = "20"; 7 | 8 | long num1 = (long)(Integer.parseInt(str1)); 9 | long num2 = (long)(Integer.parseInt(str2)); 10 | 11 | long res = (long)(num1 + num2); 12 | 13 | String strresult = Long.toString(res); 14 | 15 | System.out.println(strresult); 16 | 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Strings/printSubstrings.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class printSubstrings { 4 | public static void main(String[] args) { 5 | String str = "abcde"; 6 | 7 | System.out.println("Substrings : "); 8 | for (int i = 0; i <= str.length(); i++) { 9 | for (int j = i; j <= str.length(); j++) { 10 | System.out.print(str.substring(i,j) + " "); 11 | } 12 | System.out.println(); 13 | } 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/Strings/updateEvenPositionOfString.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class updateEvenPositionOfString { 4 | public static void main(String[] args) { 5 | String s = "PhysicsWallah"; 6 | String res = ""; 7 | 8 | for(int i=0;i0 && s.charAt(i) == ' '){ 10 | i--; 11 | } 12 | while(i>0 && s.charAt(i) != ' '){ 13 | length++; 14 | i--; 15 | } 16 | System.out.println(length); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Strings/toLowerCase.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class toLowerCase { 4 | public static void main(String[] args) { 5 | String s = "HELLO"; 6 | char[] ch = s.toCharArray(); 7 | for (int i = 0; i < s.length(); i++) { 8 | ch[i] = (char) (ch[i] + ('a' - 'A')); 9 | } 10 | String res = ""; 11 | for (int i = 0; i < ch.length; i++) { 12 | res += ch[i]; 13 | } 14 | System.out.println(res); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/Loops/countDigits.java: -------------------------------------------------------------------------------- 1 | package Loops; 2 | 3 | import java.util.Scanner; 4 | 5 | public class countDigits { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter a number : "); 9 | int n = sc.nextInt(); 10 | int count = 0; 11 | while(n!=0){ 12 | n = n / 10; 13 | count++; 14 | } 15 | System.out.println("Number of digits : "+count); 16 | 17 | 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/OoPs/encapsulation.java: -------------------------------------------------------------------------------- 1 | package OoPs; 2 | 3 | class Book{ 4 | private int pageNo; 5 | 6 | public int getPageNo(){ //getter method 7 | return pageNo; 8 | } 9 | public void setPageNo(int pageNo){ //setter method 10 | this.pageNo = pageNo; 11 | } 12 | } 13 | public class encapsulation { 14 | public static void main(String[] args) { 15 | Book b = new Book(); 16 | b.setPageNo(100); 17 | System.out.println(b.getPageNo()); 18 | 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/LoopsAssignments/MutiplicationOfNumber.java: -------------------------------------------------------------------------------- 1 | package LoopsAssignments; 2 | 3 | import java.util.Scanner; 4 | 5 | public class MutiplicationOfNumber { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter a number : "); 9 | int num = sc.nextInt(); 10 | System.out.println("Multiplication Table of number : "+num); 11 | for(int i=num;i<=num*10;i=i+num) 12 | System.out.println(i); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/Arrays/sort0and1MethodTwo.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class sort0and1MethodTwo { 4 | public static void main(String[] args) { 5 | int[] arr = {1,1,0,0,0,1,1,0,1}; 6 | int noOfZeros = 0; 7 | 8 | for(int i=0;i arr[j])j++; 14 | else i++; 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/Strings/reverseSecondHalf.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | 5 | public class reverseSecondHalf { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter a even length string : "); 9 | String str = sc.nextLine(); 10 | 11 | int mid = str.length() / 2; 12 | 13 | for (int i = str.length()-1; i >= mid; i--) { 14 | System.out.print(str.charAt(i)); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/Heaps/minTimeToFillCups.java: -------------------------------------------------------------------------------- 1 | package Heaps; 2 | 3 | public class minTimeToFillCups { 4 | public static void main(String[] args) { 5 | int[] amount = {1,4,2}; 6 | int time = fillCups(amount); 7 | System.out.println(time); 8 | } 9 | 10 | private static int fillCups(int[] amount) { 11 | int max = Math.max(amount[0],Math.max(amount[1],amount[2])); 12 | int total = amount[0] + amount[1] + amount[2]; 13 | return Math.max(max,(int)Math.ceil(total/2.0)); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/OoPs/constructor.java: -------------------------------------------------------------------------------- 1 | package OoPs; 2 | 3 | class Employee_{ 4 | //Instance Variables 5 | String name; 6 | int age; 7 | Employee_(){ 8 | System.out.println("Employee Constructor Called"); 9 | } 10 | void display(){ 11 | System.out.println("Name : "+name); 12 | System.out.println("Age : "+age); 13 | } 14 | } 15 | public class constructor { 16 | public static void main(String[] args) { 17 | Employee_ e = new Employee_(); 18 | e.display(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/PatternPrinting/Square/starSquare.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting; 2 | 3 | import java.util.Scanner; 4 | 5 | public class starSquare { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter side of square : "); 9 | int s = sc.nextInt(); 10 | for(int i=0;i= x) count++; 8 | if (x == count) return x; 9 | } 10 | return -1; 11 | } 12 | public static void main(String[] args) { 13 | int[] arr = {3,9,7,8,3,8,6,6}; 14 | int n = specialArr(arr); 15 | System.out.println(n); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/Strings/concatWithReverse.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | 5 | public class concatWithReverse { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter a string : "); 9 | String str = sc.nextLine(); 10 | String str2 = ""; 11 | 12 | for(int i=str.length()-1;i>=0;i--){ 13 | str2 += str.charAt(i); 14 | } 15 | 16 | str = str + str2; 17 | System.out.println(str); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Loops/sumOfDigits.java: -------------------------------------------------------------------------------- 1 | package Loops; 2 | 3 | import java.util.Scanner; 4 | 5 | public class sumOfDigits { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter a number : "); 9 | int n = sc.nextInt(); 10 | int rem; 11 | int sum = 0; 12 | 13 | while(n!=0){ 14 | rem = n % 10; 15 | sum += rem; 16 | n = n / 10; 17 | } 18 | System.out.println("Sum of digits : "+sum); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/PatternPrinting/Triangle/starTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Triangle; 2 | 3 | import java.util.Scanner; 4 | 5 | public class starTriangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int n = sc.nextInt(); 10 | 11 | for(int i=1;i<=n;i++){ 12 | for(int j=1;j<=i;j++){ 13 | System.out.print("* "); 14 | } 15 | System.out.println(); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Stack/basicStack.java: -------------------------------------------------------------------------------- 1 | package Stack; 2 | 3 | import java.util.Stack; 4 | 5 | public class basicStack { 6 | public static void main(String[] args) { 7 | Stack st = new Stack<>(); 8 | st.push(1); 9 | st.push(2); 10 | st.push(3); 11 | System.out.println(st); 12 | System.out.println(st.peek()); 13 | st.pop(); 14 | System.out.println(st); 15 | while (st.size() > 1){ 16 | st.pop(); 17 | } 18 | System.out.println(st.peek()); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Strings/repeatedCharacter.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class repeatedCharacter { 4 | public static char repeatedChar(String s){ 5 | char[] ch = s.toCharArray(); 6 | int[] arr = new int[256]; 7 | for(char c : ch) { 8 | arr[c]++; 9 | if (arr[c] > 1) return c; 10 | } 11 | return 's'; 12 | } 13 | public static void main(String[] args) { 14 | String s = "abccbaacz"; 15 | char res = repeatedChar(s); 16 | System.out.println(res); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Arrays/maxProfit.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class maxProfit { 4 | public static void main(String[] args) { 5 | int[] arr = {7,6,4,3,1}; 6 | int maxprofit = 0; 7 | int minPrice = Integer.MAX_VALUE; 8 | for (int i = 0; i < arr.length; i++) { 9 | if(arr[i] < minPrice){ 10 | minPrice = arr[i]; 11 | }else{ 12 | maxprofit = Math.max(maxprofit, arr[i] - minPrice); 13 | } 14 | } 15 | System.out.println(maxprofit); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/PatternPrinting/Square/alphabetSquare.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting; 2 | 3 | import java.util.Scanner; 4 | 5 | public class alphabetSquare { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter side of square : "); 9 | int s = sc.nextInt(); 10 | for(int i=1;i<=s;i++){ 11 | for(int j=1;j<=s;j++){ 12 | System.out.print(((char)(j+64)+" ")); 13 | } 14 | System.out.println(); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/PatternPrinting/Triangle/numberTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Triangle; 2 | 3 | import java.util.Scanner; 4 | 5 | public class numberTriangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int n = sc.nextInt(); 10 | 11 | for(int i=1;i<=n;i++){ 12 | for(int j=1;j<=i;j++){ 13 | System.out.print(j+" "); 14 | } 15 | System.out.println(); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/PrefixSum/runningSum.java: -------------------------------------------------------------------------------- 1 | package PrefixSum; 2 | 3 | public class runningSum { 4 | public static int[] runningSumOfArray(int[] arr){ 5 | if(arr.length == 1)return arr; 6 | for (int i = 1; i < arr.length; i++)arr[i] = arr[i] + arr[i-1]; 7 | return arr; 8 | } 9 | public static void main(String[] args) { 10 | int[] arr = {1,1,1,1,1}; 11 | int[] res = runningSumOfArray(arr); 12 | for (int i = 0; i < res.length; i++) { 13 | System.out.print(res[i] + " "); 14 | } 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/Arrays/diagonalSum.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class diagonalSum { 4 | public static void main(String[] args) { 5 | int[][] mat = {{1,2,3},{4,5,6},{7,8,9}}; 6 | int r = mat.length; 7 | int c = mat[0].length; 8 | int sum = 0; 9 | 10 | for (int i = 0; i < r; i++) { 11 | for (int j = 0; j < c; j++) { 12 | if(i==j || i+j == r-1){ 13 | sum += mat[i][j]; 14 | } 15 | } 16 | } 17 | System.out.println(sum); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/PatternPrinting/Triangle/invertedStarTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Triangle; 2 | 3 | import java.util.Scanner; 4 | 5 | public class invertedStarTriangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int n = sc.nextInt(); 10 | 11 | for(int i=1;i<=n;i++){ 12 | for(int j=n;j>=i;j--){ 13 | System.out.print("* "); 14 | } 15 | System.out.println(); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Arrays/removeDuplicateElements.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class removeDuplicateElements { 4 | public static void main(String[] args) { 5 | int[] arr = {1,2,2,3,3,4,4,4}; 6 | int k = 0; 7 | 8 | for (int i = 0; i < arr.length-1; i++) { 9 | if (arr[i] != arr[i + 1]) { 10 | arr[k] = arr[i]; 11 | System.out.print(arr[k] + " "); 12 | k++; 13 | } 14 | } 15 | System.out.println(arr[arr.length-1]); 16 | System.out.println(k+1); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/PatternPrinting/Triangle/alphabetTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Triangle; 2 | 3 | import java.util.Scanner; 4 | 5 | public class alphabetTriangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int n = sc.nextInt(); 10 | 11 | for(int i=1;i<=n;i++){ 12 | for(int j=1;j<=i;j++){ 13 | System.out.print((char)(j+64)+" "); 14 | } 15 | System.out.println(); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Strings/countPrefixes.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class countPrefixes { 4 | public static void main(String[] args) { 5 | String[] words = {"a","b","c","ab","bc","abc"}; 6 | String s = "abc"; 7 | int ans = countPre(words,s); 8 | System.out.println(ans); 9 | } 10 | 11 | private static int countPre(String[] words, String s) { 12 | int count = 0; 13 | for (int i = 0; i < words.length; i++) { 14 | if(s.startsWith(words[i]))count++; 15 | } 16 | return count; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Strings/stringSorting.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | import java.util.Arrays; 5 | 6 | public class stringSorting { 7 | public static void main(String[] args) { 8 | Scanner sc = new Scanner(System.in); 9 | System.out.println("Enter a string : "); 10 | String str = sc.nextLine(); 11 | 12 | char []ch = str.toCharArray(); 13 | Arrays.sort(ch); 14 | 15 | str = ch.toString(); 16 | 17 | for(char ele : ch){ 18 | System.out.print(ele + " "); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Arrays/checkIfDoubleExist.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class checkIfDoubleExist { 4 | public static boolean checkIfExist(int[] arr){ 5 | for (int i = 0; i < arr.length; i++) { 6 | for (int j = 0; j < arr.length; j++) { 7 | if(i != j && arr[i] == 2 * arr[j])return true; 8 | } 9 | } 10 | return false; 11 | } 12 | public static void main(String[] args) { 13 | int[] arr = {7,15,3,4,30}; 14 | boolean res = checkIfExist(arr); 15 | System.out.println(res); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/Arrays/findKthPositive.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class findKthPositive { 4 | public static void main(String[] args) { 5 | int[] arr = {1,2}; 6 | int k = 1; 7 | int missingCount = 0; 8 | int arrIdx = 0; 9 | int i = 1; 10 | 11 | while(missingCount < k){ 12 | if(arrIdx < arr.length && i == arr[arrIdx]){ 13 | arrIdx++; 14 | }else missingCount++; 15 | if(missingCount < k) 16 | i++; 17 | } 18 | System.out.println(i); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/PatternPrinting/Special_Patterns/oddNumberTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Special_Patterns; 2 | 3 | import java.util.Scanner; 4 | public class oddNumberTriangle { 5 | public static void main(String[] args) { 6 | Scanner sc = new Scanner(System.in); 7 | System.out.println("Enter no of rows : "); 8 | int n = sc.nextInt(); 9 | 10 | for(int i=1;i<=n;i++){ 11 | for(int j=1;j<=i;j++){ 12 | System.out.print((2*j-1)+" "); 13 | } 14 | System.out.println(); 15 | } 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/PatternPrinting/Triangle/invertedNumberTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Triangle; 2 | 3 | import java.util.Scanner; 4 | 5 | public class invertedNumberTriangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int n = sc.nextInt(); 10 | 11 | for(int i=1;i<=n;i++){ 12 | for(int j=1;j<=n+1-i;j++){ 13 | System.out.print(j+" "); 14 | } 15 | System.out.println(); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/DynamicProgramming/fibonacci.java: -------------------------------------------------------------------------------- 1 | package DynamicProgramming; 2 | 3 | //Recursion + Memoization 4 | 5 | public class fibonacci { 6 | public static int findFibo(int n,int[] dp){ 7 | if(n <= 1)return n; 8 | if(dp[n] != 0)return dp[n]; 9 | int ans = findFibo(n-1,dp) + findFibo(n-2,dp); 10 | dp[n] = ans; 11 | return ans; 12 | } 13 | public static void main(String[] args) { 14 | int n = 5; 15 | int[] dp = new int[n+1]; 16 | int res = findFibo(n,dp); 17 | System.out.println(res); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Arrays/harshadNumber.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class harshadNumber { 4 | public static void main(String[] args) { 5 | int x = 18; 6 | int ans = checkHarshadNumber(x); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int checkHarshadNumber(int x) { 11 | String s = String.valueOf(x); 12 | int sum = 0; 13 | for (int i = 0; i < s.length(); i++) { 14 | sum += Integer.parseInt(String.valueOf(s.charAt(i))); 15 | } 16 | if(x % sum == 0)return sum; 17 | return -1; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Arrays/subArraySum.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class subArraySum { 4 | public static void main(String[] args) { 5 | int[] arr = {2,3,1}; 6 | int ans = subArrSum(arr); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int subArrSum(int[] arr) { 11 | int sum = 0; 12 | for (int i = 0; i < arr.length; i++) { 13 | int start = Math.max(0,i-arr[i]); 14 | for (int j = start; j <= i; j++) { 15 | sum += arr[j]; 16 | } 17 | } 18 | return sum; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Hashmaps/treemap.java: -------------------------------------------------------------------------------- 1 | package Hashmaps; 2 | 3 | import java.util.TreeMap; 4 | 5 | public class treemap { 6 | public static void main(String[] args) { 7 | /* 8 | Treemap are used to sort in ascending order on the basic of key 9 | Ordered Map 10 | */ 11 | TreeMap map = new TreeMap<>(); 12 | map.put("Sarthak",1); 13 | map.put("Ayushi",2); 14 | map.put("raghav",3); 15 | 16 | for(String key : map.keySet()){ 17 | System.out.println(key+" "+map.get(key)); 18 | } 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/PatternPrinting/Triangle/invertedAlphabetTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Triangle; 2 | 3 | import java.util.Scanner; 4 | 5 | public class invertedAlphabetTriangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int n = sc.nextInt(); 10 | 11 | for(int i=1;i<=n;i++){ 12 | for(int j=1;j<=n+1-i;j++){ 13 | System.out.print((char)(i+64)+" "); 14 | } 15 | System.out.println(); 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/SortingAlgorithms/checkIfArrayIsSortedOrNot.java: -------------------------------------------------------------------------------- 1 | package SortingAlgorithms; 2 | 3 | public class checkIfArrayIsSortedOrNot { 4 | public static void main(String[] args) { 5 | int[] arr = {1,3,8}; 6 | boolean flag = false; 7 | 8 | for (int i = 0; i < arr.length - 1; i++) { 9 | if(arr[i] >= arr[i+1]) { 10 | flag = false; 11 | break; 12 | }else flag = true; 13 | } 14 | if(flag) System.out.println("Array is sorted"); 15 | else System.out.println("Array is unsorted"); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/Arrays/uglyNumber.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class uglyNumber { 6 | public static void main(String[] args) { 7 | int n = 1; 8 | boolean ans = isUgly(n); 9 | System.out.println(ans); 10 | } 11 | 12 | private static boolean isUgly(int n) { 13 | if (n <= 0) return false; 14 | int[] factors = {2, 3, 5}; 15 | for (int factor : factors) { 16 | while (n % factor == 0) { 17 | n /= factor; 18 | } 19 | } 20 | return n == 1; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Strings/stringBuilderSorting.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | import java.util.Arrays; 5 | 6 | public class stringBuilderSorting { 7 | public static void main(String[] args) { 8 | Scanner sc = new Scanner(System.in); 9 | System.out.println("Enter a string : "); 10 | StringBuilder sb = new StringBuilder(sc.nextLine()); 11 | 12 | char []ch = sb.toString().toCharArray(); 13 | 14 | Arrays.sort(ch); 15 | 16 | for(char ele : ch){ 17 | System.out.print(ele + " "); 18 | } 19 | 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Arrays/happyNumber.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class happyNumber { 4 | public static void main(String[] args) { 5 | boolean[] seen = new boolean[1000]; // Array to keep track of seen numbers 6 | int n = 2; 7 | while (n != 1 && !seen[n]){ 8 | seen[n] = true; 9 | int sum = 0; 10 | while(n > 0){ 11 | int rem = n % 10; 12 | sum += (int) Math.pow(rem,2); 13 | n = n / 10; 14 | } 15 | n = sum; 16 | } 17 | System.out.println(n); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Hashmaps/minimumOperationsForMakingArrayZero.java: -------------------------------------------------------------------------------- 1 | package Hashmaps; 2 | 3 | import java.util.HashSet; 4 | 5 | public class minimumOperationsForMakingArrayZero { 6 | public static void main(String[] args) { 7 | int[] arr = {1,5,0,3,5}; 8 | int ans = minimumOperations(arr); 9 | System.out.println(ans); 10 | } 11 | 12 | private static int minimumOperations(int[] arr) { 13 | HashSet set = new HashSet<>(); 14 | for(int ele : arr){ 15 | if(ele != 0)set.add(ele); 16 | } 17 | return set.size(); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Methods/Square.java: -------------------------------------------------------------------------------- 1 | package Methods; 2 | 3 | import java.util.Scanner; 4 | 5 | class CalculateSquare{ 6 | void calculate(int n){ 7 | for(int i=1;i<=n;i++){ 8 | int res = i * i; 9 | System.out.print(res+" "); 10 | } 11 | } 12 | } 13 | 14 | public class Square { 15 | public static void main(String[] args) { 16 | Scanner sc = new Scanner(System.in); 17 | System.out.println("Enter a number : "); 18 | int n = sc.nextInt(); 19 | CalculateSquare cs = new CalculateSquare(); 20 | cs.calculate(n); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/SearchingAlgorithms/squareRoot.java: -------------------------------------------------------------------------------- 1 | package SearchingAlgorithms; 2 | 3 | public class squareRoot { 4 | public static int sqrt(int x){ 5 | int low = 0; 6 | int high = x; 7 | int mid = 0; 8 | 9 | while(low<=high){ 10 | mid = (low+high)/2; 11 | if(mid*mid == x)return mid; 12 | else if(mid*mid > x)high = mid - 1; 13 | else if(mid*mid < x)low = mid + 1; 14 | }return high; 15 | } 16 | public static void main(String[] args) { 17 | int x = 6; 18 | System.out.println(sqrt(x)); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Strings/countValidWords.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class countValidWords { 4 | public static void main(String[] args) { 5 | String sentence = "!"; 6 | int ans = ValidWords(sentence); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int ValidWords(String sentence) { 11 | String[] str = sentence.split(" "); 12 | int count = 0; 13 | for (String s : str) { 14 | if (s.matches("^[a-z]+(-[a-z]+)?[!.,]?$")) { 15 | count++; 16 | } 17 | } 18 | return count; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Strings/defangingAnIPAddress.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class defangingAnIPAddress { 4 | public static void main(String[] args) { 5 | String s = "255.100.50.0"; 6 | String ans = defangIPaddr(s); 7 | System.out.println(ans); 8 | } 9 | 10 | private static String defangIPaddr(String s) { 11 | StringBuilder sb = new StringBuilder(); 12 | for (int i = 0; i < s.length(); i++) { 13 | if(s.charAt(i) != '.')sb.append(s.charAt(i)); 14 | else sb.append("[.]"); 15 | } 16 | return sb.toString(); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Arrays/nextGreatestLetter.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class nextGreatestLetter { 4 | public static void main(String[] args) { 5 | char[] letters = {'x','x','y','y'}; 6 | char target = 'z'; 7 | char ans = '0'; 8 | 9 | for (int i = 0; i < letters.length; i++) { 10 | if((int)letters[i] > (int)target){ 11 | ans = letters[i]; 12 | break; 13 | }else if((int)letters[i] < (int)target){ 14 | ans = letters[0]; 15 | } 16 | } 17 | System.out.println(ans); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Recursion/generateParenthesis.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class generateParenthesis { 4 | 5 | public static void printParenthesis(int open,int close,int n,String ans){ 6 | int len = ans.length(); 7 | if(len == 2*n){ 8 | System.out.println(ans); 9 | return; 10 | } 11 | if(open < n)printParenthesis(open+1,close,n,ans+"("); 12 | if(open > close) printParenthesis(open,close+1,n,ans+")"); 13 | } 14 | public static void main(String[] args) { 15 | int n = 3; 16 | printParenthesis(0,0,n,""); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Strings/findTheOriginalStringTypedI.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class findTheOriginalStringTypedI { 4 | public static void main(String[] args) { 5 | String s = "abbcccc"; 6 | int count = possibleStringCount(s); 7 | System.out.println(count); 8 | } 9 | 10 | private static int possibleStringCount(String s) { 11 | if(s.length() == 1)return 1; 12 | int count = 1; 13 | for (int i = 0; i < s.length(); i++) { 14 | if(i+1 < s.length() && s.charAt(i) == s.charAt(i+1))count++; 15 | } 16 | return count; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Strings/palindrome.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | 5 | public class palindrome { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter a string : "); 9 | String str = sc.nextLine(); 10 | String str2 = ""; 11 | 12 | for(int i=str.length()-1;i>=0;i--){ 13 | str2 += str.charAt(i); 14 | } 15 | 16 | if(str.equals(str2)) System.out.println("Strings are palindrome"); 17 | else System.out.println("Strings are not palindrome"); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/PatternPrinting/Special_Patterns/floydsTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Special_Patterns; 2 | 3 | import java.util.Scanner; 4 | 5 | public class floydsTriangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int n = sc.nextInt(); 10 | int a = 1; 11 | for(int i=1;i<=n;i++){ 12 | for(int j=1;j<=i;j++){ 13 | System.out.print(a+" "); 14 | a++; 15 | } 16 | System.out.println(); 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/DynamicProgramming/tribonacciNumber.java: -------------------------------------------------------------------------------- 1 | package DynamicProgramming; 2 | 3 | public class tribonacciNumber { 4 | public static int tribonacci(int n,int[] dp) { 5 | if(n == 1)return 1; 6 | if(n <= 0)return 0; 7 | if(dp[n] != 0)return dp[n]; 8 | int ans = tribonacci(n-1,dp) + tribonacci(n-2,dp) + tribonacci(n-3,dp); 9 | dp[n] = ans; 10 | return ans; 11 | } 12 | public static void main(String[] args) { 13 | int n = 4; 14 | int[] dp = new int[n+1]; 15 | int ans = tribonacci(n,dp); 16 | System.out.println(ans); 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Strings/interning.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | public class interning { 3 | public static void main(String[] args) { 4 | String s = "Sarthak"; 5 | String q = "Sarthak"; 6 | //Here a separate string is not created for 'q' variable it is pointing to same as 's' variable. 7 | //It is used when multiple string are created with same data and hence reducing memory space. 8 | String t = new String("Sarthak"); 9 | //By declaring the string using above type a new string will be created with different 'Sarthak' value inside. 10 | System.out.println(t); 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /src/DynamicProgramming/friendsPairingProblem.java: -------------------------------------------------------------------------------- 1 | package DynamicProgramming; 2 | 3 | import java.util.Arrays; 4 | 5 | public class friendsPairingProblem { 6 | static int[] dp; 7 | public static void main(String[] args) { 8 | int n = 4; 9 | dp = new int[n+1]; 10 | Arrays.fill(dp,-1); 11 | int ans = pair(n,dp); 12 | System.out.println(ans); 13 | } 14 | 15 | private static int pair(int n, int[] dp) { 16 | if(n == 1 || n == 2)return n; 17 | if(dp[n] != -1)return dp[n]; 18 | return dp[n] = pair(n-1, dp) + (n-1) * pair(n-2, dp); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/PatternPrinting/Square/starRectangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting; 2 | 3 | import java.util.Scanner; 4 | 5 | public class starRectangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int r = sc.nextInt(); 10 | System.out.println("Enter no of columns : "); 11 | int c = sc.nextInt(); 12 | for(int i=0;i s1 = new Stack<>(); 8 | Stack s2 = new Stack<>(); 9 | s1.push(1); 10 | s1.push(2); 11 | s1.push(3); 12 | s1.push(4); 13 | s1.push(5); 14 | System.out.println("Original Stack :"); 15 | System.out.println(s1); 16 | while(!s1.isEmpty()) s2.push(s1.pop()); 17 | System.out.println("Reversed Stack :"); 18 | System.out.println(s2); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Arrays/basicsOfArrayList.java: -------------------------------------------------------------------------------- 1 | //In arraylist default value is not set to zero. 2 | package Arrays; 3 | 4 | import java.util.ArrayList; 5 | 6 | public class basicsOfArrayList { 7 | public static void main(String[] args) { 8 | ArrayList arr = new ArrayList<>(10); 9 | arr.add(5); //add 10 | arr.add(7); 11 | arr.add(9); 12 | 13 | System.out.println(arr); //print 14 | 15 | for(int i=0;i max)max = arr[i]; 12 | if(arr[i] < min)min = arr[i]; 13 | } 14 | for (int i = 1; i <= max; i++) { 15 | if(max % i == 0 && min % i == 0){ 16 | gcd = i; 17 | } 18 | } 19 | System.out.println(gcd); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Recursion/gcdRecursion.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | import java.util.Scanner; 4 | 5 | public class gcdRecursion { 6 | public static int gcd(int num1,int num2){ 7 | int rem = num2 % num1; 8 | if(rem == 0)return num1; 9 | return gcd(rem,num1); 10 | } 11 | public static void main(String[] args) { 12 | Scanner sc = new Scanner(System.in); 13 | System.out.print("Enter first No : "); 14 | int num1 = sc.nextInt(); 15 | System.out.print("Enter second No : "); 16 | int num2 = sc.nextInt(); 17 | System.out.println("GCD : "+gcd(num1,num2)); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/SortingAlgorithms/majorityElement.java: -------------------------------------------------------------------------------- 1 | package SortingAlgorithms; 2 | import java.util.Arrays; 3 | 4 | public class majorityElement { 5 | public static void main(String[] args) { 6 | int[] arr = {3,2,3,4,4,4}; 7 | for (int i = 1; i < arr.length; i++) { 8 | int j = i; 9 | while(j>=1 && arr[j] < arr[j-1]){ 10 | int temp = arr[j]; 11 | arr[j] = arr[j-1]; 12 | arr[j-1] = temp; 13 | j--; 14 | } 15 | } 16 | int n = arr.length/2; 17 | System.out.println("Majority Element : "+arr[n]); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Strings/stringBuilderInJava.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class stringBuilderInJava { 4 | public static void main(String[] args) { 5 | StringBuilder s = new StringBuilder(); 6 | System.out.println(s.length()); 7 | System.out.println(s.capacity()); //Initial Capacity of a string declared using String Builder is always 16 8 | 9 | 10 | StringBuilder t = new StringBuilder("Sarthak"); 11 | System.out.println(t.capacity()); 12 | System.out.println(t.length()); 13 | 14 | StringBuilder u = new StringBuilder(10); 15 | System.out.println(u.capacity()); 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /src/PatternPrinting/Triangle/alphabetNumberTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Triangle; 2 | 3 | import java.util.Scanner; 4 | 5 | public class alphabetNumberTriangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int n = sc.nextInt(); 10 | 11 | for(int i=0;i<=n;i++){ 12 | for(int j=1;j<=i;j++){ 13 | if(i%2==0) System.out.print((char)(j+64)+" "); 14 | else System.out.print(j+" "); 15 | } 16 | System.out.println(); 17 | } 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Strings/getLucky.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class getLucky { 4 | public static void main(String[] args) { 5 | String s = "leetcode"; 6 | int k = 2; 7 | int ans = getLuckyNumber(s,k); 8 | System.out.println(ans); 9 | } 10 | 11 | private static int getLuckyNumber(String s, int k) { 12 | int count = 1; StringBuilder sum = null; 13 | for (int i = 0; i < s.length(); i++) { 14 | System.out.println(s.charAt(i) - 'a' + 1); 15 | sum.append(s.charAt(i) - 'a' + 1); 16 | } 17 | System.out.println(sum); 18 | return 0; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Strings/numberOfStringsThatAppearAsSubstringInWord.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class numberOfStringsThatAppearAsSubstringInWord { 4 | public static void main(String[] args) { 5 | String[] patterns = {"a","abc","bc","d"}; 6 | String word = "abc"; 7 | int ans = numOfStrings(patterns,word); 8 | System.out.println(ans); 9 | } 10 | 11 | private static int numOfStrings(String[] patterns, String word) { 12 | int count = 0; 13 | for (int i = 0; i < patterns.length; i++) { 14 | if(word.contains(patterns[i]))count++; 15 | } 16 | return count; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Strings/percentageOfLetterInString.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class percentageOfLetterInString { 4 | public static void main(String[] args) { 5 | String s = "foobar"; 6 | char ch = 'o'; 7 | int ans = percentageLetter(s,ch); 8 | System.out.println(ans); 9 | } 10 | 11 | private static int percentageLetter(String s, char ch) { 12 | int count = 0; 13 | for (int i = 0; i < s.length(); i++) { 14 | if(s.charAt(i) == ch)count++; 15 | } 16 | double res = (double)count/s.length(); 17 | res = res * 100; 18 | return (int)res; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Arrays/calculateMoney.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class calculateMoney { 4 | public static void main(String[] args) { 5 | int n = 20; 6 | int ans = totalMoney(n); 7 | System.out.println(); 8 | System.out.println(ans); 9 | } 10 | 11 | private static int totalMoney(int n) { 12 | int i=1; 13 | int sum = 0; 14 | while (n > 0){ 15 | int days = Math.min(n,7); 16 | for (int j = 0; j < days; j++) { 17 | sum += (i+j); 18 | } 19 | i++; 20 | n = n - 7; 21 | } 22 | return sum; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Arrays/digitGame.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class digitGame { 4 | public static void main(String[] args) { 5 | int[] arr = {1,2,3,4,10}; 6 | boolean ans = canAliceWin(arr); 7 | System.out.println(ans); 8 | } 9 | 10 | private static boolean canAliceWin(int[] arr) { 11 | int singleDigits = 0; 12 | int doubleDigits = 0; 13 | 14 | for (int i = 0; i < arr.length; i++) { 15 | if(arr[i] > 9)doubleDigits += arr[i]; 16 | else singleDigits += arr[i]; 17 | } 18 | if(singleDigits == doubleDigits)return false; 19 | return true; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Arrays/numberOfBits.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | /* 4 | Given a positive integer n, write a function that returns the number 5 | of set bits in its binary representation (also known as the Hamming weight). 6 | */ 7 | public class numberOfBits { 8 | public static void main(String[] args) { 9 | int n = 11; 10 | int ans = hammingWeight(n); 11 | System.out.println(ans); 12 | } 13 | 14 | private static int hammingWeight(int n) { 15 | int countOnes = 0; 16 | while (n != 0){ 17 | if(n % 2 == 1)countOnes++; 18 | n/=2; 19 | } 20 | return countOnes; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Loops/geometricMean.java: -------------------------------------------------------------------------------- 1 | package Loops; 2 | 3 | import java.util.Scanner; 4 | 5 | public class geometricMean { 6 | //1 2 4 8 16 32 7 | public static void main(String[] args) { 8 | Scanner sc = new Scanner(System.in); 9 | System.out.println("Enter the first term : "); 10 | int a = sc.nextInt(); 11 | System.out.println("Enter the difference : "); 12 | int d = sc.nextInt(); 13 | System.out.println("Enter the number of terms"); 14 | int n = sc.nextInt(); 15 | 16 | for(int i=1;i<=n;i++) { 17 | System.out.println(a); 18 | a*=d; 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Strings/faultyKeyboard.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class faultyKeyboard { 4 | public static String finalString(String s){ 5 | int n = s.length(); 6 | StringBuilder sb = new StringBuilder(); 7 | for (int i = 0; i < n; i++) { 8 | if(s.charAt(i) != 'i')sb.append(s.charAt(i)); 9 | if(s.charAt(i) == 'i'){ 10 | sb.reverse(); 11 | } 12 | } 13 | return sb.toString(); 14 | } 15 | public static void main(String[] args) { 16 | String s = "string"; 17 | String ans = finalString(s); 18 | System.out.println(ans); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Arrays/sortOsand1sMethodone.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Scanner; 4 | 5 | public class sortOsand1sMethodone { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | int[] arr = {1,0,0,1,1,0,1,0,0,1}; 9 | 10 | for(int i=0;iarr[j]) { 13 | int temp = arr[i]; 14 | arr[i] = arr[j]; 15 | arr[j] = temp; 16 | } 17 | } 18 | System.out.print(arr[i] + " "); 19 | } 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Loops/compositeNumber.java: -------------------------------------------------------------------------------- 1 | package Loops; 2 | 3 | import java.util.Scanner; 4 | 5 | public class compositeNumber { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter the number : "); 9 | int n = sc.nextInt(); 10 | 11 | for(int i = 2; i < n; i++) { 12 | if(n%i==0) { 13 | System.out.println("Composite Number"); 14 | break; 15 | } 16 | 17 | else { 18 | System.out.println("Not a composite number"); 19 | break; 20 | } 21 | } 22 | 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/LoopsAssignments/FibonacciSeries.java: -------------------------------------------------------------------------------- 1 | package LoopsAssignments; 2 | 3 | import java.util.Scanner; 4 | 5 | public class FibonacciSeries { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter a value : "); 9 | int n = sc.nextInt(); 10 | int num1 = 0; 11 | int num2 = 1; 12 | int num3; 13 | System.out.print(num1+" "+num2); 14 | 15 | for(int i=0;i= 0; i--) { 13 | revStr = revStr + str.charAt(i); 14 | } 15 | 16 | if(str.equals(revStr)) System.out.println("String is a palindrome"); 17 | else System.out.println("String is not a palindrome"); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Strings/isSubsequence.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class isSubsequence { 4 | public static void main(String[] args) { 5 | String s = "b"; 6 | String t = "abc"; 7 | boolean ans = isSubSeq(s,t); 8 | System.out.println(ans); 9 | } 10 | 11 | private static boolean isSubSeq(String s, String t) { 12 | if(s.isEmpty())return true; 13 | int i = 0; 14 | int j = 0; 15 | while (i < t.length()){ 16 | if(j < s.length() && t.charAt(i) == s.charAt(j))j++; 17 | i++; 18 | } 19 | if(j == s.length())return true; 20 | return false; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Strings/splitAStringInBalanced.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class splitAStringInBalanced { 4 | public static void main(String[] args) { 5 | String s = "RLRRLLRLRL"; 6 | int ans = balancedStringSplit(s); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int balancedStringSplit(String s) { 11 | int isBalanced = 0; 12 | int countRL = 0; 13 | for (int i = 0; i < s.length(); i++) { 14 | if(s.charAt(i) == 'R')countRL++; 15 | if(s.charAt(i) == 'L')countRL--; 16 | if(countRL == 0)isBalanced++; 17 | } 18 | return isBalanced; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Strings/subtractTheProductAndSum.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class subtractTheProductAndSum { 4 | public static void main(String[] args) { 5 | int n = 234; 6 | int ans = subtractProductAndSum(n); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int subtractProductAndSum(int n) { 11 | String s = String.valueOf(n); 12 | int pro = 1; int sum = 0; 13 | for (int i = 0; i < s.length(); i++) { 14 | int curr = Integer.parseInt(String.valueOf(s.charAt(i))); 15 | pro *= curr; 16 | sum += curr; 17 | } 18 | return pro - sum; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Arrays/maxConsecutiveOnes.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class maxConsecutiveOnes { 4 | public static void main(String[] args) { 5 | int[] arr = {1,1,1,1,0,1,0,1,1,1,1,1,1,0,1,1,1}; 6 | int j = 0; 7 | int count = 0; 8 | int maxOnes = 0; 9 | 10 | while(j al = new ArrayList<>(); 11 | 12 | for (int nums : arr) freq[nums]++; 13 | 14 | for (int i = 0; i < freq.length; i++) { 15 | if (freq[i] > 1) al.add(i); 16 | } 17 | 18 | for (int i = 0; i < al.size(); i++) { 19 | System.out.print(al.get(i) + " "); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Arrays/maxMedianSum.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Arrays; 4 | 5 | public class maxMedianSum { 6 | public static void main(String[] args) { 7 | int[] arr = {1,1,10,10,10,10}; // 1 1 2 2 3 3 8 | long ans = maximumMedianSum(arr); 9 | System.out.println(ans); 10 | } 11 | private static long maximumMedianSum(int[] arr) { 12 | Arrays.sort(arr); 13 | int i = 0, j = arr.length - 1; 14 | int median = 0; 15 | while (i < j){ 16 | int ans = arr[j-1]; 17 | median += ans; 18 | i++; 19 | j-=2; 20 | } 21 | return median; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Strings/countAsterisks.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class countAsterisks { 4 | public static void main(String[] args) { 5 | String s = "iamprogrammer"; 6 | int ans = count(s); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int count(String s) { 11 | int pipe = 0; 12 | int countAsterisk = 0; 13 | for (int i = 0; i < s.length(); i++) { 14 | if(pipe == 0 && s.charAt(i) == '|')pipe++; 15 | else if(pipe == 1 && s.charAt(i) == '|')pipe--; 16 | if(pipe == 0 && s.charAt(i) == '*')countAsterisk++; 17 | } 18 | return countAsterisk; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Strings/reverseStringBuilder.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | 5 | public class reverseStringBuilder { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.print("Enter a string : "); 9 | StringBuilder sb = new StringBuilder(sc.nextLine()); 10 | 11 | int i=0; 12 | int j=sb.length()-1; 13 | 14 | while(i set = new TreeSet<>(); 14 | for (int i = 0; i < arr.length; i++) { 15 | set.add(arr[i]); 16 | if(set.size() > 3)set.pollFirst(); 17 | } 18 | if(set.size() < 3){ 19 | return set.last(); 20 | } 21 | return set.first(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/PatternPrinting/Composite_Patterns/rhombus.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Composite_Patterns; 2 | 3 | import java.util.Scanner; 4 | 5 | public class rhombus { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | 9 | System.out.println("Enter the no of rows : "); 10 | int n = sc.nextInt(); 11 | 12 | for(int i=1;i<=n;i++){ 13 | for(int j=n-i;j>=1;j--){ 14 | System.out.print(" " + " "); 15 | } 16 | for(int j=1;j<=n;j++){ 17 | System.out.print("*" + " " ); 18 | } 19 | System.out.println(); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Recursion/mazePath2.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | import java.util.Scanner; 4 | 5 | public class mazePath2 { 6 | public static int maze(int r,int c){ 7 | if(r == 1 || c == 1)return 1; 8 | int rightWays = maze(r,c-1); 9 | int downWays = maze(r-1,c); 10 | return rightWays + downWays; 11 | } 12 | public static void main(String[] args) { 13 | Scanner sc = new Scanner(System.in); 14 | System.out.println("Enter n : "); 15 | int n = sc.nextInt(); 16 | System.out.println("Enter m : "); 17 | int m = sc.nextInt(); 18 | int res = maze(n,m); 19 | System.out.println(res); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Recursion/subsets.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class subsets { 6 | static ArrayList arr = new ArrayList<>(); 7 | public static void printSubsets(int i,String s,String ans){ 8 | if(i==s.length()){ 9 | arr.add(ans); 10 | return; 11 | } 12 | char ch = s.charAt(i); 13 | printSubsets(i+1,s,ans); //not take 14 | printSubsets(i+1,s,ans+ch); //take 15 | } 16 | public static void main(String[] args) { 17 | String s = "abcd"; 18 | arr = new ArrayList<>(); 19 | printSubsets(0,s,""); 20 | System.out.println(arr); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/SearchingAlgorithms/peakIndexInMountainArray.java: -------------------------------------------------------------------------------- 1 | package SearchingAlgorithms; 2 | 3 | public class peakIndexInMountainArray { 4 | public static void main(String[] args) { 5 | int[] arr = {10,20,30,40,50,60,70,20,10}; 6 | int low = 1; 7 | int high = arr.length - 2; 8 | 9 | while(low<=high){ 10 | int mid = (low + high)/2; 11 | if(arr[mid] > arr[mid-1] && arr[mid] > arr[mid+1]){ 12 | System.out.println("Peak Index : "+mid); 13 | break; 14 | }else if(arr[mid] < arr[mid+1]) low = mid + 1; 15 | else if(arr[mid] > arr[mid+1]) high = mid - 1; 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/Strings/excelSheetColumnTitle.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class excelSheetColumnTitle { 4 | public static void main(String[] args) { 5 | int columnNumber = 28; 6 | String ans = convertToTitle(columnNumber); 7 | System.out.println(ans); 8 | } 9 | 10 | private static String convertToTitle(int columnNumber) { 11 | StringBuilder sb = new StringBuilder(); 12 | while (columnNumber > 0){ 13 | columnNumber -= 1; 14 | char rem = (char) ('A' + (columnNumber % 26)); 15 | sb.append(rem); 16 | columnNumber /= 26; 17 | } 18 | return sb.reverse().toString(); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Arrays/maximum69Number.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collections; 5 | 6 | public class maximum69Number { 7 | public static void main(String[] args) { 8 | int n = 9969; 9 | int ans = max69Number(n); 10 | System.out.println(ans); 11 | } 12 | 13 | private static int max69Number(int n) { 14 | char[] num = Integer.toString(n).toCharArray(); 15 | 16 | for (int i = 0; i < num.length; i++) { 17 | if(num[i] == '6'){ 18 | num[i] = '9'; 19 | break; 20 | } 21 | } 22 | return Integer.parseInt(new String(num)); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Arrays/rankTransform.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class rankTransform { 4 | public static void main(String[] args) { 5 | int[] arr = {37,13,28,9,100,56,80,5,12}; 6 | int[] ans = new int[arr.length]; 7 | 8 | for (int i = 0; i < arr.length; i++) { 9 | int count = 0; 10 | int curr = arr[i]; 11 | for (int j = 0; j < arr.length; j++) { 12 | if(curr > arr[j])count++; 13 | else ans[i] = 1; 14 | } 15 | ans[i] = count+1; 16 | } 17 | 18 | for (int i = 0; i < ans.length; i++) { 19 | System.out.print(ans[i] + " "); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Arrays/singleNonDuplicate.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class singleNonDuplicate { 4 | public static int singleNonDup(int[] arr){ 5 | int i = 0; 6 | if(arr.length <= 1)return arr[0]; 7 | while(i ll = new LinkedList<>(); 8 | ll.add(1); 9 | ll.add(0); 10 | ll.add(1); 11 | int ans = getDecimalValue(ll); 12 | System.out.println(ans); 13 | } 14 | 15 | private static int getDecimalValue(LinkedList ll) { 16 | StringBuilder sb = new StringBuilder(); 17 | for(int num : ll){ 18 | sb.append(num); 19 | } 20 | return Integer.parseInt(sb.toString(),2); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Methods/PrintOddBtnNos.java: -------------------------------------------------------------------------------- 1 | package Methods; 2 | 3 | import java.util.Scanner; 4 | 5 | class PrintOddNos{ 6 | void printOdd(int a , int b){ 7 | for(int i=a;i set = new HashSet<>(); 17 | for(char ch : sentence.toCharArray()){ 18 | set.add(ch); 19 | } 20 | return set.size() == 26; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Strings/rotateString.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class rotateString { 4 | public static void main(String[] args) { 5 | String s = "abcde"; 6 | String goal = "cdeab"; 7 | boolean ans = rotateStr(s,goal); 8 | System.out.println(ans); 9 | } 10 | 11 | private static boolean rotateStr(String s, String goal) { 12 | StringBuilder sb = new StringBuilder(s); 13 | for (int i = 0; i < s.length(); i++) { 14 | char ch = sb.charAt(0); 15 | sb.deleteCharAt(0); 16 | sb.append(ch); 17 | if(sb.toString().equals(goal))return true; 18 | } 19 | return false; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Arrays/checkDivisibility.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class checkDivisibility { 4 | public static void main(String[] args) { 5 | int n = 99; 6 | boolean ans = checkDivisible(n); 7 | System.out.println(ans); 8 | } 9 | 10 | private static boolean checkDivisible(int n) { 11 | String s = String.valueOf(n); 12 | StringBuilder sb = new StringBuilder(s); 13 | int sum = 0, pro = 1; 14 | for (int i = 0; i < sb.length(); i++) { 15 | int num = Integer.parseInt(String.valueOf(s.charAt(i))); 16 | sum += num; 17 | pro *= num; 18 | } 19 | return n % (sum + pro) == 0; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Arrays/containsDuplicate.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Arrays; 4 | 5 | public class containsDuplicate { 6 | public static void main(String[] args) { 7 | int []arr = {3,4,5,6,6}; 8 | int flag = 0; 9 | 10 | Arrays.sort(arr); 11 | int i = 0; 12 | while(i 1)break; 17 | } 18 | } 19 | if(count == 1)countPrime++; 20 | } 21 | System.out.println(countPrime); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Arrays/maximumProductSubarray.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class maximumProductSubarray { 4 | public static int maxProduct(int[] arr){ 5 | int maxProduct = Integer.MIN_VALUE; 6 | if(arr.length == 1)return arr[0]; 7 | for (int i = 0; i < arr.length-1; i++) { 8 | for (int j = i+1; j < arr.length; j++) { 9 | int product = arr[i] * arr[j]; 10 | if(product > maxProduct)maxProduct = product; 11 | } 12 | } 13 | return maxProduct; 14 | } 15 | 16 | public static void main(String[] args) { 17 | int[] arr = {0,2}; 18 | System.out.println(maxProduct(arr)); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/PatternPrinting/Composite_Patterns/starPyramid.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Composite_Patterns; 2 | 3 | import java.util.Scanner; 4 | 5 | public class starPyramid { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | 9 | System.out.println("Enter the no of rows : "); 10 | int n = sc.nextInt(); 11 | 12 | for(int i=1;i<=n;i++){ 13 | for(int j=n-i;j>=1;j--){ 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 | -------------------------------------------------------------------------------- /src/Arrays/maxDiffBetweenIncreasingElements.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class maxDiffBetweenIncreasingElements { 4 | public static void main(String[] args) { 5 | int[] arr = {1,5,2,10}; 6 | int ans = maxDifference(arr); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int maxDifference(int[] arr) { 11 | int maxDiff = -1; 12 | for (int i = 0; i < arr.length-1; i++) { 13 | for (int j = i+1; j < arr.length; j++) { 14 | if(arr[i] < arr[j]){ 15 | maxDiff = Math.max(maxDiff, arr[j]-arr[i]); 16 | } 17 | } 18 | } 19 | return maxDiff; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Arrays/monotonicArray.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class monotonicArray { 4 | public static boolean monotonicArr(int[] arr){ 5 | boolean isIncreasing = true; 6 | boolean isDecreasing = true; 7 | 8 | for(int i=1;i arr[i-1])isDecreasing = false; 10 | if(arr[i] < arr[i-1])isIncreasing = false; 11 | } 12 | return isIncreasing || isDecreasing; 13 | } 14 | public static void main(String[] args) { 15 | int[] arr = {1,1,0}; 16 | boolean result = monotonicArr(arr); 17 | if(result) System.out.println(true); 18 | else System.out.println(false); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Arrays/specialArray1.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class specialArray1 { 4 | public static void main(String[] args) { 5 | int[] arr = {4,3,1,6}; 6 | boolean isSpecial = isSpecialArray(arr); 7 | System.out.println(isSpecial); 8 | } 9 | 10 | private static boolean isSpecialArray(int[] arr) { 11 | int n = arr.length; 12 | boolean isSpecial = false; 13 | if(n == 1)return true; 14 | for (int i = 0; i < n-1; i++) { 15 | if((arr[i] % 2 == 0 && arr[i+1] % 2 == 1) || (arr[i] % 2 == 1 && arr[i+1] % 2 == 0))isSpecial = true; 16 | else return false; 17 | } 18 | return isSpecial; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Loops/primeNumber.java: -------------------------------------------------------------------------------- 1 | package Loops; 2 | 3 | import java.util.Scanner; 4 | 5 | public class primeNumber { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter the number : "); 9 | int n = sc.nextInt(); 10 | 11 | int x = 0; //0 means prime 12 | for(int i=2;i=1;j--){ 14 | System.out.print(" "+" "); 15 | } 16 | for(int j=1;j<=i;j++){ 17 | System.out.print("*"+" "); 18 | } 19 | System.out.println(); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Strings/reverseWordsInStringIII.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class reverseWordsInStringIII { 4 | public static void main(String[] args) { 5 | String s = "Let's take LeetCode contest"; 6 | String ans = reverseWords(s); 7 | System.out.println(ans); 8 | } 9 | 10 | private static String reverseWords(String s) { 11 | StringBuilder sb = new StringBuilder(); 12 | String[] words = s.split(" "); 13 | 14 | for (int i = 0; i < words.length; i++) { 15 | sb.append(new StringBuilder(words[i]).reverse()); 16 | 17 | if(i < words.length-1)sb.append(" "); 18 | } 19 | return sb.toString(); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Strings/stringBuilder.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class stringBuilder { 4 | public static void main(String[] args) { 5 | String s = "Sarthak"; 6 | convertToStringBuilder(s); 7 | } 8 | 9 | private static void convertToStringBuilder(String s) { 10 | //converting string to stringbuilder 11 | StringBuilder sb = new StringBuilder(); 12 | for (int i = 0; i < s.length(); i++) { 13 | sb.append(s.charAt(i)); 14 | } 15 | 16 | System.out.println(sb.substring(0,5)); 17 | //convert stringbuilder to string 18 | String s1 = sb.reverse().toString(); 19 | System.out.println(s1); 20 | 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/PatternPrinting/Composite_Patterns/numberTriangleFlipped.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Composite_Patterns; 2 | 3 | import java.util.Scanner; 4 | 5 | public class numberTriangleFlipped { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | 9 | System.out.println("Enter the no of rows : "); 10 | int n = sc.nextInt(); 11 | 12 | for(int i=1;i<=n;i++){ 13 | for(int j=n-i;j>=1;j--){ 14 | System.out.print(" "+" "); 15 | } 16 | for(int j=1;j<=i;j++){ 17 | System.out.print(j+" "); 18 | } 19 | System.out.println(); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Recursion/binaryStringWithoutConsecutiveOnes.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class binaryStringWithoutConsecutiveOnes { 4 | public static void printStrings(int n,String ans){ 5 | int len = ans.length(); 6 | if(len == n){ 7 | System.out.print(ans + " "); 8 | return; 9 | } 10 | if(len == 0 || ans.endsWith("0")){ 11 | printStrings(n,ans+"1"); 12 | printStrings(n,ans+"0"); 13 | } 14 | else if(ans.endsWith("1")){ 15 | printStrings(n,ans+"0"); 16 | } 17 | } 18 | public static void main(String[] args) { 19 | int n = 2; 20 | printStrings(n,""); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/BitManipulation/findTheOriginalArrayOfPrefixXOR.java: -------------------------------------------------------------------------------- 1 | package BitManipulation; 2 | 3 | public class findTheOriginalArrayOfPrefixXOR { 4 | public static void main(String[] args) { 5 | int[] pre = {5,2,0,3,1}; 6 | int[] ans = findArray(pre); 7 | for (int i = 0; i < ans.length; i++) { 8 | System.out.print(ans[i] + " "); 9 | } 10 | } 11 | 12 | private static int[] findArray(int[] pre) { 13 | if(pre.length <= 1)return pre; 14 | int[] ans = new int[pre.length]; 15 | ans[0] = pre[0]; 16 | for (int i = 1; i < pre.length; i++) { 17 | ans[i] = pre[i] ^ pre[i-1]; 18 | } 19 | return ans; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Arrays/meanOfArrayAfterRemovingMinAndMaxElements.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Arrays; 4 | 5 | public class meanOfArrayAfterRemovingMinAndMaxElements { 6 | public static void main(String[] args) { 7 | int[] arr = {6,2,7,5,1,2,0,3,10,2,5,0,5,5,0,8,7,6,8,0}; 8 | Arrays.sort(arr); 9 | double remove_count = arr.length * 0.05; 10 | double sum = 0; 11 | double count = 0; 12 | System.out.println(remove_count); 13 | for (int i = (int)remove_count; i < arr.length-remove_count; i++) { 14 | sum+= arr[i]; 15 | count++; 16 | } 17 | double mean = sum/count; 18 | System.out.println(mean); 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Arrays/countMatches.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class countMatches { 4 | public static void main(String[] args) { 5 | int n = 7; 6 | System.out.println(numberOfMatches(n)); 7 | } 8 | 9 | private static int numberOfMatches(int n) { 10 | int totalMatches = 0; 11 | while (n != 1){ 12 | if(n % 2 == 0){ 13 | int match = n / 2; 14 | totalMatches += match; 15 | n = n / 2; 16 | }if(n % 2 == 1){ 17 | int match = (n-1) / 2; 18 | totalMatches += match; 19 | n = ((n-1) / 2)+1; 20 | } 21 | } 22 | return totalMatches; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Arrays/findNumberWithEvenDigits.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class findNumberWithEvenDigits { 4 | public static int findNumbers(int[] arr){ 5 | int countEven = 0; 6 | int countDigits; 7 | for (int i = 0; i < arr.length; i++) { 8 | countDigits = 0; 9 | while(arr[i] > 0){ 10 | arr[i] /= 10; 11 | countDigits++; 12 | } 13 | if(countDigits % 2 == 0)countEven++; 14 | } 15 | return countEven; 16 | } 17 | public static void main(String[] args) { 18 | int[] arr = {56,901,482,1771,1234}; 19 | int res = findNumbers(arr); 20 | System.out.println(res); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Heaps/kthLargestElement.java: -------------------------------------------------------------------------------- 1 | package Heaps; 2 | 3 | import java.util.PriorityQueue; 4 | 5 | public class kthLargestElement { 6 | public static int kSmallest(int[] arr,int k){ 7 | PriorityQueue pq = new PriorityQueue<>(); 8 | for (int i = 0; i < arr.length; i++) { 9 | pq.add(arr[i]); 10 | if(k < pq.size()){ 11 | pq.remove(); 12 | } 13 | } 14 | System.out.println(pq); 15 | return pq.peek(); 16 | } 17 | public static void main(String[] args) { 18 | int []arr = {4,7,3,9,8,1,2,6,5}; 19 | int k = 3; 20 | int res = kSmallest(arr,k); 21 | System.out.println(res); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Recursion/stringTraversal.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class stringTraversal { 4 | public static void skip(int i,String s,String ans){ 5 | if(i == s.length()){ 6 | System.out.println(ans); 7 | return; 8 | } 9 | if(s.charAt(i) != 'a')ans += s.charAt(i); 10 | skip(i+1,s,ans); 11 | } 12 | public static void print(int i,String s){ 13 | if(i == s.length())return; 14 | System.out.print(s.charAt(i)); 15 | print(i+1,s); 16 | } 17 | public static void main(String[] args) { 18 | String s = "Sarthak Vitmal"; 19 | print(0,s); 20 | System.out.println(); 21 | skip(0,s,""); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Arrays/countDigitsDivideNumber.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class countDigitsDivideNumber { 4 | public static void main(String[] args) { 5 | int n = 121; 6 | int ans = countDigits(n); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int countDigits(int n) { 11 | int count = 0; 12 | String s = String.valueOf(n); 13 | char[] ch = new char[s.length()]; 14 | for (int i = 0; i < s.length(); i++) { 15 | ch[i] = s.charAt(i); 16 | } 17 | for (int i = 0; i < ch.length; i++) { 18 | int digit = ch[i] - '0'; 19 | if(n % digit == 0)count++; 20 | } 21 | return count; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/LoopsAssignments/GCDofTwoNumbers.java: -------------------------------------------------------------------------------- 1 | package LoopsAssignments; 2 | 3 | import java.util.Scanner; 4 | 5 | public class GCDofTwoNumbers { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter the first number : "); 9 | int n1 = sc.nextInt(); 10 | System.out.println("Enter the second number : "); 11 | int n2 = sc.nextInt(); 12 | int factors = 1; 13 | 14 | for (int i = 2; i < n1 && i < n2; i++) { 15 | if (n1 % i == 0 && n2 % i == 0) { 16 | factors = i; 17 | } 18 | } 19 | System.out.print("GCD of " +n1+ " and " +n2+ " is " +factors); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/PatternPrinting/Special_Patterns/starCross.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Special_Patterns; 2 | 3 | import java.util.Scanner; 4 | 5 | public class starCross { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter no of rows : "); 9 | int n = sc.nextInt(); 10 | 11 | for(int i=1;i<=n;i++){ 12 | for(int j=1;j<=n;j++){ 13 | if(i==j || (i+j)==n+1) { 14 | System.out.print("*"); 15 | } 16 | else{ 17 | System.out.print(" "); 18 | } 19 | } 20 | System.out.println(); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Strings/concatenateNonZeroDigitsAndMultiplyBySum.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class concatenateNonZeroDigitsAndMultiplyBySum { 4 | public static void main(String[] args) { 5 | int n = 10203004; 6 | long ans = sumAndMultiply(n); 7 | System.out.println(ans); 8 | } 9 | 10 | private static long sumAndMultiply(int n) { 11 | StringBuilder sb = new StringBuilder(); 12 | String s = String.valueOf(n); 13 | int sum = 0; 14 | for (int i = 0; i < s.length(); i++) { 15 | if (s.charAt(i) != '0') sb.append(s.charAt(i)); 16 | sum += s.charAt(i) - '0'; 17 | } 18 | return Long.parseLong(sb.toString()) * sum; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Strings/minSwapsToMakeStringBalanced.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class minSwapsToMakeStringBalanced { 4 | public static void main(String[] args) { 5 | String s = "]]][[["; 6 | int ans = minSwaps(s); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int minSwaps(String s) { 11 | int imbalance = 0; 12 | int maxImbalance = 0; 13 | for (char c : s.toCharArray()) { 14 | if (c == '[') { 15 | imbalance--; 16 | } else { 17 | imbalance++; 18 | } 19 | maxImbalance = Math.max(maxImbalance, imbalance); 20 | } 21 | return (maxImbalance + 1) / 2; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Strings/sortTheSentence.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class sortTheSentence { 4 | public static void main(String[] args) { 5 | String s = "is2 sentence4 This1 a3"; 6 | String ans = sortSentence(s); 7 | System.out.println(ans); 8 | } 9 | 10 | private static String sortSentence(String s) { 11 | String[] words = s.split(" "); 12 | String[] result = new String[words.length]; 13 | 14 | for(String word : words){ 15 | int len = word.length(); 16 | int pos = Character.getNumericValue(word.charAt(len-1)); 17 | result[pos - 1] = word.substring(0,len-1); 18 | } 19 | return String.join(" ",result); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Arrays/sort0and1and2_Method2.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class sort0and1and2_Method2 { 4 | public static void main(String[] args) { 5 | int[] arr = {1,2,0,2,1,0,0}; 6 | int noOfZero = 0; 7 | int noOfOne = 0; 8 | int noOfTwo = 0; 9 | 10 | 11 | for(int i=0;i 1) ans += length; 16 | i = j; 17 | } 18 | } 19 | ans += arr[i]; 20 | int length = j - i; 21 | if (length > 1) ans += length; 22 | System.out.println(ans); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Arrays/sumOfUniqueElements.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Arrays; 4 | 5 | public class sumOfUniqueElements { 6 | public static void main(String[] args) { 7 | int[] arr = {1,2,3,2}; 8 | int[] freqArray = new int[arr.length]; 9 | int sum = 0; 10 | Arrays.sort(arr); 11 | if(arr[0] != arr[1]) freqArray[0] = 1; 12 | for (int i = 1; i < arr.length-1; i++) if(arr[i-1] != arr[i] && arr[i] != arr[i+1])freqArray[i] = 1; 13 | if(arr[arr.length-1] != arr[arr.length-2])freqArray[arr.length-1] = 1; 14 | for (int i = 0; i < arr.length; i++) { 15 | if(freqArray[i] == 1) sum+= arr[i]; 16 | } 17 | System.out.println(sum); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Arrays/thirdMax.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class thirdMax { 4 | public static void main(String[] args) { 5 | int[] arr = {1,2,2,5,3,5}; 6 | int max = Integer.MIN_VALUE; 7 | for(int i=0;i arr[maxIdx]){ 11 | maxIdx = j; 12 | } 13 | } 14 | int temp = arr[maxIdx]; 15 | arr[maxIdx] = arr[i]; 16 | arr[i] = temp; 17 | } 18 | for (int i = arr.length-1; i>=0 ; i--) { 19 | System.out.print(arr[i] + " "); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Arrays/countGoodTriplets.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class countGoodTriplets { 4 | public static void main(String[] args) { 5 | int[] arr = {1,1,2,2,3}; 6 | int a = 7;int b = 2;int c = 3; 7 | int goodTriplets = 0; 8 | for (int i = 0; i < arr.length-2; i++) { 9 | for (int j = i+1; j < arr.length-1; j++) { 10 | for (int k = j+1; k < arr.length; k++) { 11 | if(Math.abs(arr[i] - arr[j]) <= a && Math.abs(arr[j] - arr[k]) <= b && Math.abs(arr[i] - arr[k]) <= c){ 12 | goodTriplets++; 13 | } 14 | } 15 | } 16 | } 17 | System.out.println(goodTriplets); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Arrays/multiplyingFoundValuesByTwo.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class multiplyingFoundValuesByTwo { 4 | public static boolean isContains(int []arr,int original){ 5 | for(int num : arr){ 6 | if(num == original)return true; 7 | } 8 | return false; 9 | } 10 | public static int findFinalValue(int[] arr,int original){ 11 | while (isContains(arr,original)){ 12 | original = original * 2; 13 | } 14 | return original; 15 | } 16 | public static void main(String[] args) { 17 | int[] nums = {5,3,6,1,12}; 18 | int original = 3; 19 | int res = findFinalValue(nums,original); 20 | System.out.println(res); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/PatternPrinting/Special_Patterns/binaryTriangle.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Special_Patterns; 2 | 3 | import java.util.Scanner; 4 | 5 | public class binaryTriangle { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | 9 | System.out.println("Enter the no of rows : "); 10 | int n = sc.nextInt(); 11 | 12 | for(int i=1;i<=n;i++){ 13 | for(int j=1;j<=i;j++){ 14 | if((i+j)%2==0) { 15 | System.out.print("1 "); 16 | } 17 | else{ 18 | System.out.print("0 "); 19 | } 20 | } 21 | System.out.println(); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Strings/removeOccurrencesOfSubstring.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class removeOccurrencesOfSubstring { 4 | public static void main(String[] args) { 5 | String s = "daabcbaabcbc"; 6 | String part = "abc"; 7 | String ans = removeOccurrences(s,part); 8 | System.out.println(ans); 9 | } 10 | 11 | private static String removeOccurrences(String s, String part) { 12 | int idx; 13 | while ((idx = findOccurrence(s,part)) != -1){ 14 | s = s.substring(0, idx) + s.substring(idx + part.length()); 15 | } 16 | return s; 17 | } 18 | 19 | private static int findOccurrence(String s, String part) { 20 | return s.indexOf(part); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Arrays/twoFarthestHouseDist.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | //leetcode - 2078. Two Furthest Houses With Different Colors 4 | public class twoFarthestHouseDist { 5 | public static void main(String[] args) { 6 | int[] arr = {1,8,3,8,3}; 7 | int dist = maxDistance(arr); 8 | System.out.println(dist); 9 | } 10 | 11 | private static int maxDistance(int[] arr) { 12 | int maxDist = Integer.MIN_VALUE; 13 | for (int i = 0; i < arr.length; i++) { 14 | for (int j = i+1; j < arr.length; j++) { 15 | if(arr[i] != arr[j]){ 16 | maxDist = Math.max(maxDist,j-i); 17 | } 18 | } 19 | } 20 | return maxDist; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/PatternPrinting/Special_Patterns/starPlus.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Special_Patterns; 2 | 3 | import java.util.Scanner; 4 | 5 | public class starPlus { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | 9 | System.out.println("Enter no of rows : "); 10 | int n = sc.nextInt(); 11 | 12 | for(int i=1;i<=n;i++){ 13 | for(int j=1;j<=n;j++){ 14 | if(i==(n/2)+1 || j==(n/2)+1) { 15 | System.out.print("*"+" "); 16 | } 17 | else { 18 | System.out.print(" "+" "); 19 | } 20 | } 21 | System.out.println(); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Queue/basicQueue.java: -------------------------------------------------------------------------------- 1 | package Queue; 2 | 3 | import java.util.LinkedList; 4 | import java.util.Queue; 5 | 6 | public class basicQueue { 7 | public static void main(String[] args) { 8 | Queue q = new LinkedList<>(); 9 | Queue q1= new LinkedList<>(); 10 | System.out.println(q.isEmpty()); 11 | q.add(1); 12 | q.add(2); 13 | q.add(3); 14 | q.add(4); 15 | q.add(5); 16 | System.out.println(q); 17 | q.remove(); 18 | System.out.println(q); 19 | q.poll(); 20 | System.out.println(q); 21 | System.out.println(q.peek()); 22 | System.out.println(q.isEmpty()); 23 | System.out.println(q.size()); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/SearchingAlgorithms/lowerBound.java: -------------------------------------------------------------------------------- 1 | package SearchingAlgorithms; 2 | 3 | public class lowerBound { 4 | public static int min(int a,int b){ 5 | return Math.min(a, b); 6 | } 7 | public static void main(String[] args) { 8 | int[] arr = {10,20,30,40,50,60}; 9 | int target = 85; 10 | int lowerBound = arr.length - 1; 11 | int low = 0; 12 | int high = arr.length - 1; 13 | 14 | while(low<=high){ 15 | int mid = (low + high)/ 2; 16 | if(arr[mid] >= target){ 17 | lowerBound = min(lowerBound,mid); 18 | high = mid - 1; 19 | }else low = mid + 1; 20 | } 21 | System.out.println(lowerBound); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Stack/copyStack.java: -------------------------------------------------------------------------------- 1 | package Stack; 2 | 3 | import java.util.Stack; 4 | 5 | public class copyStack { 6 | public static void main(String[] args) { 7 | Stack s1 = new Stack<>(); 8 | Stack s2 = new Stack<>(); 9 | Stack s3 = new Stack<>(); 10 | s1.push(1); 11 | s1.push(2); 12 | s1.push(3); 13 | s1.push(4); 14 | s1.push(5); 15 | System.out.println("Original Stack :"); 16 | System.out.println(s1); 17 | while(!s1.isEmpty()) s2.push(s1.pop()); 18 | System.out.println(s2); 19 | while(!s2.isEmpty()) s3.push(s2.pop()); 20 | System.out.println("Copy Stack : "); 21 | System.out.println(s3); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Arrays/plusOne.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Arrays; 4 | 5 | public class plusOne { 6 | public static void main(String[] args) { 7 | int[] arr = {9,8,7,6,5,4,3,2,1,0}; 8 | int[] ans = plusOne(arr); 9 | System.out.println(Arrays.toString(ans)); 10 | } 11 | 12 | public static int[] plusOne(int[] digits) { 13 | int n = digits.length; 14 | 15 | for (int i = n - 1; i >= 0; i--) { 16 | if (digits[i] < 9) { 17 | digits[i]++; 18 | return digits; 19 | } 20 | digits[i] = 0; 21 | } 22 | 23 | int[] newNumber = new int[n + 1]; 24 | newNumber[0] = 1; 25 | return newNumber; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/Arrays/sumOfAbsoluteDiff.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class sumOfAbsoluteDiff { 4 | public static int[] getSumAbsoluteDiff(int[] arr){ 5 | int[] ans = new int[arr.length]; 6 | for (int i = 0; i < arr.length; i++) { 7 | int diff = 0; 8 | for (int j = 0; j < arr.length; j++) { 9 | diff += Math.abs(arr[i] - arr[j]); 10 | } 11 | ans[i] = diff; 12 | } 13 | return ans; 14 | } 15 | public static void main(String[] args) { 16 | int[] arr = {1,4,6,8,10}; 17 | int[] ans = getSumAbsoluteDiff(arr); 18 | for (int i = 0; i < ans.length; i++) { 19 | System.out.print(ans[i] + " "); 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/BitManipulation/decodeXORArray.java: -------------------------------------------------------------------------------- 1 | package BitManipulation; 2 | 3 | public class decodeXORArray { 4 | public static void main(String[] args) { 5 | int[] encoded = {6,2,7,3}; 6 | int first = 4; 7 | int[] ans = decodeArray(encoded,first); 8 | for (int i = 0; i < ans.length; i++) { 9 | System.out.print(ans[i] + " "); 10 | } 11 | } 12 | 13 | private static int[] decodeArray(int[] encoded, int first) { 14 | int n = encoded.length; 15 | int[] decoded = new int[n+1]; 16 | decoded[0] = first; 17 | for (int i = 1; i < decoded.length; i++) { 18 | decoded[i] = encoded[i-1] ^ decoded[i-1]; 19 | } 20 | return decoded; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Hashmaps/findTheDifference.java: -------------------------------------------------------------------------------- 1 | package Hashmaps; 2 | 3 | import java.util.Arrays; 4 | import java.util.HashSet; 5 | 6 | public class findTheDifference { 7 | public static void main(String[] args) { 8 | String s = "abcd"; 9 | String t = "abcde"; 10 | char ans = findDifference(s,t); 11 | System.out.println(ans); 12 | } 13 | 14 | private static char findDifference(String s, String t) { 15 | char[] ch1 = s.toCharArray(); 16 | char[] ch2 = t.toCharArray(); 17 | Arrays.sort(ch1); 18 | Arrays.sort(ch2); 19 | for (int i = 0; i < ch1.length; i++) { 20 | if(ch1[i] != ch2[i])return ch2[i]; 21 | } 22 | return ch2[ch2.length-1]; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Arrays/findFirstPalindromicString.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | class findFirstPalindromicString{ 4 | 5 | public static String checkFirstPalindrome(String[] srr){ 6 | for(int x=0;x=0){ 10 | s += srr[x].charAt(i); 11 | i--; 12 | } 13 | if(s.equals(srr[x])){ 14 | return s; 15 | } 16 | } 17 | return "Not Found"; 18 | } 19 | public static void main(String[] args) { 20 | String[] srr = {"apple","racecar","level"}; 21 | 22 | System.out.println("First Palindromic String : "+checkFirstPalindrome(srr)); 23 | } 24 | } -------------------------------------------------------------------------------- /src/Arrays/singleNumber2.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Arrays; 4 | 5 | public class singleNumber2 { 6 | public static int singleNumber(int[] arr){ 7 | int n = arr.length; 8 | if(n <= 3)return arr[0]; 9 | Arrays.sort(arr); 10 | int i = 0; 11 | while (i < n-1){ 12 | int j = i + 1; 13 | if(arr[i] == arr[j]){ 14 | i += 3; 15 | } 16 | else return arr[i]; 17 | } 18 | if(arr[n-1] != arr[n-2])return arr[n-1]; 19 | return -1; 20 | } 21 | public static void main(String[] args) { 22 | int[] arr = {2,2,2,56,1,1,1}; 23 | int n = singleNumber(arr); 24 | System.out.println(n); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Hashmaps/maximumUniqueSubArraySum.java: -------------------------------------------------------------------------------- 1 | package Hashmaps; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashSet; 5 | 6 | public class maximumUniqueSubArraySum { 7 | public static void main(String[] args) { 8 | int[] arr = {1,2,-1,-2,1,0,-1}; 9 | int ans = maxSum(arr); 10 | System.out.println(ans); 11 | } 12 | 13 | private static int maxSum(int[] arr) { 14 | HashSet set = new HashSet<>(); 15 | for(int ele : arr){ 16 | if(ele >= 0)set.add(ele); 17 | } 18 | ArrayList al = new ArrayList<>(set); 19 | int sum = 0; 20 | for (Integer integer : al) { 21 | sum += integer; 22 | } 23 | return sum; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Strings/findTheKthCharacterInStringGameI.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class findTheKthCharacterInStringGameI { 4 | public static void main(String[] args) { 5 | int k = 5; 6 | char ch = kthCharacter(k); 7 | System.out.println(ch); 8 | } 9 | 10 | private static char kthCharacter(int k) { 11 | StringBuilder sb = new StringBuilder("a"); 12 | while (k > sb.length()){ 13 | int len = sb.length(); 14 | for (int i = 0; i < len; i++) { 15 | char next = sb.charAt(i) == 'z' ? 'a' : (char)(sb.charAt(i)+1); 16 | sb.append(next); 17 | } 18 | } 19 | System.out.println(sb); 20 | return sb.charAt(k-1); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Strings/mimOperationToExceedThresholdValue.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.PriorityQueue; 4 | 5 | public class mimOperationToExceedThresholdValue { 6 | public static void main(String[] args) { 7 | int[] nums = {1,1,2,4,9}; 8 | int k = 1; 9 | int ans = minOperations(nums, k); 10 | System.out.println(ans); 11 | } 12 | 13 | private static int minOperations(int[] nums, int k) { 14 | PriorityQueue pq = new PriorityQueue<>(); 15 | for (int num : nums) { 16 | pq.add(num); 17 | } 18 | int count = 0; 19 | while (pq.peek() < k){ 20 | pq.poll(); 21 | count++; 22 | } 23 | return count; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Strings/toggleCharacters.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | 5 | public class toggleCharacters { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | System.out.println("Enter a string : "); 9 | StringBuilder sb = new StringBuilder(sc.nextLine()); 10 | 11 | for(int i=0;i= 'A' && sb.charAt(i) <= 'Z'){ 13 | char ch = sb.charAt(i); 14 | sb.setCharAt(i,(char)(ch+32)); 15 | } else { 16 | char ch = sb.charAt(i); 17 | sb.setCharAt(i,(char)(ch-32)); 18 | } 19 | } 20 | System.out.println(sb); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Arrays/findIndicesOfStableMountain.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class findIndicesOfStableMountain { 6 | public static void main(String[] args) { 7 | int[] arr = {10,1,10,1,10}; 8 | int threshold = 3; 9 | ArrayList al = stableMountains(arr,threshold); 10 | for (int i = 0; i < al.size(); i++) { 11 | System.out.print(al.get(i) + " "); 12 | } 13 | } 14 | 15 | private static ArrayList stableMountains(int[] arr, int threshold) { 16 | ArrayList ans = new ArrayList<>(); 17 | for (int i = 1; i < arr.length; i++) { 18 | if(arr[i-1] > threshold)ans.add(i); 19 | } 20 | return ans; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Arrays/countOperations.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class countOperations { 4 | public static int countOperation(int num1,int num2){ 5 | int ops = 0; 6 | if(num1 == 0 || num2 == 0)return 0; 7 | while (num1 > 0 || num2 > 0){ 8 | if(num1 == 0 || num2 == 0)break; 9 | if(num1 >= num2){ 10 | num1 = num1 - num2; 11 | ops++; 12 | }else { 13 | num2 = num2 - num1; 14 | ops++; 15 | } 16 | } 17 | return ops; 18 | } 19 | public static void main(String[] args) { 20 | int num1 = 2; 21 | int num2 = 3; 22 | int ans = countOperation(num1,num2); 23 | System.out.println(ans); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Arrays/createTargetArray.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class createTargetArray { 6 | public static void main(String[] args) { 7 | int[] arr = {0,1,2,3,4}; 8 | int[] index = {0,1,2,2,1}; 9 | int[] ans = targetArray(arr,index); 10 | for (int i = 0; i < ans.length; i++) { 11 | System.out.print(ans[i] + " "); 12 | } 13 | } 14 | 15 | private static int[] targetArray(int[] arr, int[] index) { 16 | ArrayList al = new ArrayList<>(); 17 | for (int i = 0; i < arr.length; i++) { 18 | int idx = index[i]; 19 | al.add(idx,arr[i]); 20 | } 21 | return al.stream().mapToInt(Integer::intValue).toArray(); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Hashmaps/basicSet.java: -------------------------------------------------------------------------------- 1 | package Hashmaps; 2 | 3 | import java.util.HashSet; 4 | 5 | public class basicSet { 6 | public static void main(String[] args) { 7 | HashSet set = new HashSet<>(); 8 | //insert TC = O(1) 9 | set.add(10); 10 | set.add(20); 11 | set.add(30); 12 | 13 | //search - true or false TC = O(1) 14 | System.out.println(set.contains(60)); 15 | System.out.println(set); 16 | 17 | System.out.println(set.size()); 18 | //remove 19 | set.remove(10); 20 | System.out.println(set); 21 | 22 | Object[] arr = set.toArray(); 23 | for (int i = 0; i < arr.length; i++) { 24 | System.out.print(arr[i] + " "); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/Recursion/minimumPathSum.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | public class minimumPathSum { 4 | public static int minPathSum(int row,int col,int m,int n,int[][] arr,int sum){ 5 | if(row>=m || col>=n)return Integer.MAX_VALUE; 6 | sum += arr[row][col]; 7 | if(row == m-1 && col == n-1)return sum; 8 | int rightMove = minPathSum(row,col+1,m,n,arr,sum); 9 | int downMove = minPathSum(row+1,col,m,n,arr,sum); 10 | return Math.min(rightMove,downMove); 11 | } 12 | public static void main(String[] args) { 13 | int[][] arr = {{1,3,1},{1,5,1},{4,2,1}}; 14 | int m = arr.length; 15 | int n = arr[0].length; 16 | int ans = minPathSum(0,0,m,n,arr,0); 17 | System.out.println(ans); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Stack/validateStackSequence.java: -------------------------------------------------------------------------------- 1 | package Stack; 2 | 3 | import java.util.Stack; 4 | 5 | public class validateStackSequence { 6 | public static boolean validateSS(int[] pushed,int[] popped){ 7 | Stack st = new Stack<>(); 8 | int j = 0; 9 | for (int ch : pushed) { 10 | st.push(ch); 11 | while (!st.isEmpty() && st.peek() == popped[j]) { 12 | st.pop(); 13 | j++; 14 | } 15 | } 16 | return st.isEmpty(); 17 | } 18 | public static void main(String[] args) { 19 | int[] pushed = {1,2,3,4,5}; 20 | int[] popped = {4,5,3,2,1}; 21 | boolean result = validateSS(pushed,popped); 22 | System.out.println(result); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Strings/findWordsContainingCharacter.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class findWordsContainingCharacter { 6 | public static void main(String[] args) { 7 | String[] words = {"leet","code"}; 8 | char x = 'e'; 9 | ArrayList al = findWordsContaining(words,x); 10 | for (int i = 0; i < al.size(); i++) { 11 | System.out.print(al.get(i) + " "); 12 | } 13 | } 14 | 15 | private static ArrayList findWordsContaining(String[] words, char x) { 16 | ArrayList al = new ArrayList<>(); 17 | for (int i = 0; i < words.length; i++) { 18 | if (words[i].indexOf(x) != -1) al.add(i); 19 | } 20 | return al; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Arrays/rotateArray.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Scanner; 4 | 5 | public class rotateArray { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | int []arr = {10,20,30,40,50,60,70}; 9 | int n = arr.length; 10 | int []rotatedarray = new int[n]; 11 | 12 | System.out.println("Enter the number of steps : "); 13 | int k = sc.nextInt(); 14 | 15 | for(int i=0;i=1; j--) { 20 | System.out.print("*" + " "); 21 | } 22 | System.out.println(); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Arrays/duplicateZeroes.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class duplicateZeroes { 4 | public static void main(String[] args) { 5 | int[] arr = {1,0,2,3,0,4,5,0}; 6 | int[] ans = new int[arr.length]; 7 | int k = 0; 8 | 9 | for (int i = 0; i < arr.length && k <= ans.length-1; i++) { 10 | if(arr[i] == 0){ 11 | if(k < ans.length - 1) { 12 | ans[k] = 0; 13 | ans[k + 1] = 0; 14 | }else ans[k] = 0; 15 | k+=2; 16 | } 17 | else ans[k++] = arr[i]; 18 | } 19 | 20 | for (int i = 0; i < ans.length; i++) { 21 | arr[i] = ans[i]; 22 | System.out.print(arr[i] + " "); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Arrays/minimumElementAfterReplacementWithDigitSum.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class minimumElementAfterReplacementWithDigitSum { 4 | public static void main(String[] args) { 5 | int[] arr = {10,12,13,14}; 6 | int ans = minElement(arr); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int minElement(int[] arr) { 11 | int min = Integer.MAX_VALUE; 12 | for (int i = 0; i < arr.length; i++) { 13 | String s = String.valueOf(arr[i]); 14 | int sum = 0; 15 | for (int j = 0; j < s.length(); j++) { 16 | sum += Integer.parseInt(String.valueOf(s.charAt(j))); 17 | } 18 | min = Math.min(sum,min); 19 | } 20 | return min; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/Heaps/kthSmallestElement.java: -------------------------------------------------------------------------------- 1 | package Heaps; 2 | 3 | import java.util.Collections; 4 | import java.util.PriorityQueue; 5 | 6 | public class kthSmallestElement { 7 | public static int kthSmallest(int[] arr,int k){ 8 | PriorityQueue pq = new PriorityQueue<>(Collections.reverseOrder()); 9 | for (int i = 0; i < arr.length; i++) { 10 | pq.add(arr[i]); 11 | if(pq.size() > k){ 12 | pq.remove(); 13 | } 14 | } 15 | System.out.println(pq); 16 | return pq.peek(); 17 | } 18 | public static void main(String[] args) { 19 | int[] arr = {10,2,3,8,-4,-2,6}; 20 | int k = 4; 21 | int res = kthSmallest(arr,k); 22 | System.out.println(res); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/TwoDimensionalArrays/storeRollNoAndMarks.java: -------------------------------------------------------------------------------- 1 | package TwoDimensionalArrays; 2 | 3 | import java.util.Scanner; 4 | 5 | public class storeRollNoAndMarks { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | int [][]arr = new int[4][2]; 9 | int marks,rollno; 10 | 11 | System.out.println("Enter the Roll No and Marks of students"); 12 | for(int i=0;i<4;i++){ 13 | for(int j=0;j<2;j++){ 14 | arr[i][j] = sc.nextInt(); 15 | } 16 | } 17 | 18 | for(int i=0;i<4;i++){ 19 | for(int j=0;j<2;j++){ 20 | System.out.print(arr[i][j] + " "); 21 | } 22 | System.out.println(); 23 | } 24 | 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Hashmaps/iterateMap.java: -------------------------------------------------------------------------------- 1 | package Hashmaps; 2 | 3 | import java.util.HashMap; 4 | 5 | public class iterateMap { 6 | public static void main(String[] args) { 7 | HashMap map = new HashMap<>(); 8 | map.put("Sarthak",1); 9 | map.put("Yashraj",2); 10 | map.put("Saket",3); 11 | map.put("Omkar",4); 12 | map.put("Raghav",5); 13 | map.put("Harsh",6); 14 | 15 | for(String key : map.keySet()){ 16 | int val = map.get(key); 17 | System.out.print(key+ " " +val); 18 | System.out.println(); 19 | } 20 | System.out.println("-------------------"); 21 | for(Object pair : map.entrySet()){ 22 | System.out.println(pair); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Queue/removeElementAtEvenIndex.java: -------------------------------------------------------------------------------- 1 | package Queue; 2 | 3 | import java.util.LinkedList; 4 | import java.util.Queue; 5 | 6 | public class removeElementAtEvenIndex { 7 | public static void removeEven(Queue q){ 8 | Queue newQueue = new LinkedList<>(); 9 | int i=0; 10 | while (!q.isEmpty()){ 11 | q.remove(); 12 | if(!q.isEmpty()){ 13 | newQueue.add((Integer) q.remove()); 14 | } 15 | } 16 | System.out.println(newQueue); 17 | } 18 | public static void main(String[] args) { 19 | Queue q = new LinkedList<>(); 20 | q.add(1); 21 | q.add(2); 22 | q.add(3); 23 | q.add(4); 24 | q.add(5); 25 | removeEven(q); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/SlidingWindow/minimumDifferenceBetweenHighestAndLowest.java: -------------------------------------------------------------------------------- 1 | package SlidingWindow; 2 | 3 | import java.util.Arrays; 4 | 5 | public class minimumDifferenceBetweenHighestAndLowest { 6 | public static int minimumDifference(int[] arr, int k) { 7 | if(k == 1)return 0; 8 | Arrays.sort(arr); 9 | int n = arr.length; 10 | int xmin = Integer.MAX_VALUE; 11 | for (int i = 1; i <= n-k; i++) { 12 | int min = arr[i]; 13 | int max = arr[i+k-1]; 14 | xmin = Math.min(xmin,max-min); 15 | } 16 | return xmin; 17 | } 18 | public static void main(String[] args) { 19 | int[] arr = {9,4,1,7}; // 1,4,7,9 20 | int k = 2; 21 | System.out.print(minimumDifference(arr,k)); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Arrays/containsDuplicate2.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class containsDuplicate2 { 4 | public static boolean containsNearbyDuplicate(int[] arr,int k){ 5 | int i=0; 6 | while (i 0){ 8 | int rem = num % 10; 9 | sum += rem; 10 | num = num / 10; 11 | } 12 | return sum; 13 | } 14 | public static int countEvenNo(int num){ 15 | int count = 0; 16 | for (int i = 1; i <= num; i++) { 17 | if(sumOfDigits(i) % 2 == 0){ 18 | count++; 19 | } 20 | } 21 | return count; 22 | } 23 | public static void main(String[] args) { 24 | int num = 4; 25 | int res = countEvenNo(num); 26 | System.out.println(res); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/SortingAlgorithms/transformArray.java: -------------------------------------------------------------------------------- 1 | package SortingAlgorithms; 2 | 3 | public class transformArray { 4 | public static void main(String[] args) { 5 | int[]arr = {54,11,28,91,47,63}; 6 | int x = 0; 7 | for(int j=0;j 0){ 12 | min = arr[i]; 13 | minIdx = i; 14 | } 15 | } 16 | arr[minIdx] = x; 17 | x--; 18 | } 19 | for (int i = 0; i < arr.length; i++) { 20 | System.out.print(-1 * 21 | arr[i] + " "); 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Strings/excelSheetColNumber.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class excelSheetColNumber { 4 | public static void main(String[] args) { 5 | String columnTitle = "FXSHRXW"; 6 | int ans = titleToNumber(columnTitle); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int titleToNumber(String columnTitle) { 11 | if(columnTitle.length() == 1){ 12 | int ch = columnTitle.charAt(0); 13 | return ch - 'A' + 1; 14 | } 15 | int col = 0; 16 | int pow = columnTitle.length()-1; 17 | for (int i = 0; i < columnTitle.length(); i++) { 18 | col += (int) ((columnTitle.charAt(i) - 'A' + 1) * Math.pow(26,pow)); 19 | pow--; 20 | } 21 | return col; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Strings/lexographicallyMaximum.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class lexographicallyMaximum { 4 | public static void main(String[] args) { 5 | String str = "apple mango banana"; 6 | char[] ch = str.toCharArray(); 7 | int i = 0, j = 0; 8 | String maxWord = " "; 9 | 10 | 11 | while(j <= ch.length){ 12 | if(j == ch.length || ch[j] == ' '){ 13 | String currentWord = str.substring(i,j); 14 | char firstLetter = currentWord.charAt(0); 15 | if(firstLetter > maxWord.charAt(0)){ 16 | maxWord = currentWord; 17 | } 18 | i = j + 1; 19 | } 20 | j++; 21 | } 22 | System.out.println(maxWord); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Strings/reverseNumber.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class reverseNumber { 4 | public static int reverse(int n){ 5 | int temp = n; 6 | StringBuilder res = new StringBuilder(); 7 | if (n < 0) temp = -1 * n; 8 | String s = Integer.toString(temp); 9 | for (int i = s.length() - 1; i >= 0; i--) { 10 | if (s.charAt(i) != 0) res.append(s.charAt(i)); 11 | } 12 | int ans = Integer.parseInt(res.toString()); 13 | if (n < 0) { 14 | ans = -1 * ans; 15 | } 16 | return ans; 17 | } 18 | public static void main(String[] args) { 19 | int n = -430; 20 | int res = reverse(n); 21 | System.out.println(res); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Arrays/containerWithMostWater.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class containerWithMostWater { 4 | public static void main(String[] args) { 5 | int[] arr = {1,8,6,2,5,4,8,3,7}; 6 | int area = maxArea(arr); 7 | System.out.println(area); 8 | } 9 | 10 | private static int maxArea(int[] arr) { 11 | int maxArea = Integer.MIN_VALUE; 12 | int left = 0, right = arr.length-1; 13 | while (left != right){ 14 | int dist = right - left; 15 | int minHeight = Math.min(arr[left],arr[right]); 16 | int area = dist * minHeight; 17 | maxArea = Math.max(area,maxArea); 18 | if(arr[left] > arr[right])right--; 19 | else left++; 20 | } 21 | return maxArea; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/SortingAlgorithms/bubbleSortInReverse.java: -------------------------------------------------------------------------------- 1 | package SortingAlgorithms; 2 | 3 | public class bubbleSortInReverse { 4 | public static void main(String[] args) { 5 | int[] arr = {1,2,3,4,5,8,7,10,9,6}; 6 | boolean isSorted = true; 7 | for (int x = 0; x < arr.length - 1; x++) { 8 | for (int i = 0; i < arr.length-1-x; i++) { 9 | if(arr[i] < arr[i+1]){ 10 | int temp = arr[i]; 11 | arr[i] = arr[i+1]; 12 | arr[i+1] = temp; 13 | isSorted = false; 14 | } 15 | } 16 | if(isSorted) break; 17 | } 18 | 19 | for (int i = 0; i < arr.length; i++) { 20 | System.out.print(arr[i] + " "); 21 | } 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Strings/maximumWordsInSentence.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class maximumWordsInSentence { 4 | public static void main(String[] args) { 5 | String[] sentences = {"alice and bob love leetcode", "i think so too", "this is great thanks very much"}; 6 | int maxLen = maxWordsFound(sentences); 7 | System.out.println(maxLen); 8 | } 9 | 10 | private static int maxWordsFound(String[] sentences) { 11 | int maxLen = Integer.MIN_VALUE; 12 | for (int i = 0; i < sentences.length; i++) { 13 | int spaces = 0; 14 | for(char ch1 : sentences[i].toCharArray()){ 15 | if(ch1 == ' ')spaces++; 16 | } 17 | maxLen = Math.max(maxLen,spaces+1); 18 | } 19 | return maxLen; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Arrays/findDisappearedElements.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Arrays; 5 | 6 | public class findDisappearedElements { 7 | public static void main(String[] args) { 8 | int[] nums = {4,3,2,7,8,2,3,1}; 9 | ArrayList arr = new ArrayList<>(); 10 | 11 | boolean[] present = new boolean[nums.length + 1]; 12 | for (int num : nums) { 13 | if (num <= nums.length) { 14 | present[num] = true; 15 | } 16 | } 17 | for (int i = 1; i < present.length; i++) { 18 | if (!present[i]) { 19 | arr.add(i); 20 | } 21 | } 22 | for (int missing : arr) { 23 | System.out.print(missing + " "); 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Arrays/missingElementInAP.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.HashMap; 4 | import java.util.HashSet; 5 | 6 | public class missingElementInAP { 7 | public static void main(String[] args) { 8 | int[] arr = {1, 6, 11, 16, 21, 31}; 9 | int ans = missingElement(arr); 10 | System.out.println(ans); 11 | } 12 | 13 | private static int missingElement(int[] arr) { 14 | int d = (arr[arr.length-1] - arr[0]) / arr.length; 15 | int expectedSum = 0; 16 | for (int i = arr[0]; i <= arr[arr.length-1]; i+=d) { 17 | expectedSum += i; 18 | } 19 | int actualSum = 0; 20 | for (int i = 0; i < arr.length; i++) { 21 | actualSum += arr[i]; 22 | } 23 | return expectedSum-actualSum; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/SlidingWindow/maxLengthWithTwoOccurrence.java: -------------------------------------------------------------------------------- 1 | package SlidingWindow; 2 | 3 | import java.util.HashMap; 4 | 5 | public class maxLengthWithTwoOccurrence { 6 | public static int maximumLengthSubstring(String s){ 7 | HashMap map = new HashMap<>(); 8 | for (int i = 0; i < s.length(); i++) { 9 | char ele = s.charAt(i); 10 | if(map.containsKey(ele)){ 11 | int freq = map.get(ele); 12 | map.put(ele,freq+1); 13 | }else map.put(ele,1); 14 | } 15 | System.out.println(map); 16 | return 0; 17 | } 18 | public static void main(String[] args) { 19 | String s = "bcbbbcba"; 20 | int len = maximumLengthSubstring(s); 21 | System.out.println(len); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/BitManipulation/setKthBit.java: -------------------------------------------------------------------------------- 1 | package BitManipulation; 2 | 3 | public class setKthBit { 4 | public static void main(String[] args) { 5 | int a = 0b10111001011; 6 | int k = 5; 7 | int ans = setBit(a,k); 8 | System.out.println(ans); 9 | int ansu = unsetBit(a,k); 10 | System.out.println(ansu); 11 | int anst = toggle(a,k); 12 | System.out.println(anst); 13 | } 14 | private static int setBit(int a, int k){ 15 | int masked = 1 << k; 16 | return a | masked; 17 | } 18 | private static int unsetBit(int a,int k){ 19 | int masked = ~(1 << k); 20 | return a & masked; 21 | } 22 | private static int toggle(int a,int k){ 23 | int masked = 1 << k; 24 | return a ^ masked; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Strings/longestCommonPrefix.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class longestCommonPrefix { 4 | public static void main(String[] args) { 5 | String[] strs = {"flower", "flow", "flight"}; 6 | String ans = longestCommon(strs); 7 | System.out.println(ans); 8 | } 9 | 10 | private static String longestCommon(String[] strs) { 11 | StringBuilder sb = new StringBuilder(); 12 | for (int i = 0; i < strs[0].length(); i++) { 13 | char currentChar = strs[0].charAt(i); 14 | for (int j = 1; j < strs.length; j++) { 15 | if(i >= strs[j].length() || strs[j].charAt(i) != currentChar)return sb.toString(); 16 | } 17 | sb.append(strs[0].charAt(i)); 18 | } 19 | return sb.toString(); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Strings/shiftingLetters.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class shiftingLetters { 4 | public static String shiftLetters(String s,int[] arr){ 5 | int n = arr.length; 6 | StringBuilder sb = new StringBuilder(); 7 | for (int i = n - 2; i >= 0; i--) { 8 | arr[i] = (arr[i] + arr[i + 1]) % 26; 9 | } 10 | for (int i = 0; i < n; i++) { 11 | char ch = s.charAt(i); 12 | int afterShift = (ch - 'a' + arr[i]) % 26 + 'a'; 13 | sb.append((char) afterShift); 14 | } 15 | return sb.toString(); 16 | } 17 | public static void main(String[] args) { 18 | String s = "abc"; 19 | int[] arr = {3,5,9}; 20 | String ans = shiftLetters(s,arr); 21 | System.out.println(ans); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Arrays/minSumOfFourDigitsAfterSplitting.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Arrays; 4 | 5 | public class minSumOfFourDigitsAfterSplitting { 6 | public static void main(String[] args) { 7 | int num = 2932; 8 | int ans = minimumSum(num); 9 | System.out.println(ans); 10 | } 11 | 12 | private static int minimumSum(int num) { 13 | String s = String.valueOf(num); 14 | String[] ans = new String[4]; 15 | for (int i = 0; i < s.length(); i++) { 16 | ans[i] = String.valueOf(s.charAt(i)); 17 | System.out.print(ans[i] + " "); 18 | } 19 | Arrays.sort(ans); 20 | String s1 = ans[0] + ans[2]; 21 | String s2 = ans[1] + ans[3]; 22 | return Integer.parseInt(s1) + Integer.parseInt(s2); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Arrays/neitherMinOrMax.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class neitherMinOrMax { 4 | public static int neitherMinNorMax(int[] arr){ 5 | if(arr.length <= 2)return -1; 6 | int max = Integer.MIN_VALUE; 7 | int min = Integer.MAX_VALUE; 8 | 9 | for (int i = 0; i < arr.length; i++) { 10 | if(max < arr[i])max = arr[i]; 11 | if(min > arr[i]) min = arr[i]; 12 | } 13 | 14 | for (int i = 0; i < arr.length; i++) { 15 | if(arr[i] != max && arr[i] != min){ 16 | return arr[i]; 17 | } 18 | } 19 | return -1; 20 | } 21 | public static void main(String[] args) { 22 | int[] arr = {2,1}; 23 | int res = neitherMinNorMax(arr); 24 | System.out.println(res); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/PrefixSum/sumOfDistances.java: -------------------------------------------------------------------------------- 1 | package PrefixSum; 2 | 3 | public class sumOfDistances { 4 | public static long[] distance(int[] dist){ 5 | long[] arr = new long[dist.length]; 6 | int n = dist.length; 7 | for (int i = 0; i < n; i++) { 8 | int sum = 0; 9 | for (int j = 0; j < n; j++) { 10 | if(i!=j && dist[i] == dist[j]){ 11 | sum += Math.abs(i-j); 12 | } 13 | } 14 | arr[i] = sum; 15 | } 16 | return arr; 17 | } 18 | public static void main(String[] args) { 19 | int[] arr = {1,3,1,1,2}; 20 | long[] dist = distance(arr); 21 | for (int i = 0; i < dist.length; i++) { 22 | System.out.print(dist[i] + " "); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Recursion/mazePath.java: -------------------------------------------------------------------------------- 1 | package Recursion; 2 | 3 | import java.util.Scanner; 4 | 5 | public class mazePath { 6 | public static int maze(int initialRow,int initialCol,int lastRow,int lastCol){ 7 | if(initialRow == lastRow || initialCol == lastCol)return 1; 8 | int rightWays = maze(initialRow,initialCol+1,lastRow,lastCol); 9 | int downWays = maze(initialRow+1,initialCol,lastRow,lastCol); 10 | return rightWays + downWays; 11 | } 12 | public static void main(String[] args) { 13 | Scanner sc = new Scanner(System.in); 14 | System.out.println("Enter n : "); 15 | int n = sc.nextInt(); 16 | System.out.println("Enter m : "); 17 | int m = sc.nextInt(); 18 | int res = maze(1,1,n,m); 19 | System.out.println(res); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/Strings/reversePrefixOfAWord.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class reversePrefixOfAWord { 4 | public static void main(String[] args) { 5 | String word = "xyxzxe"; 6 | char ch = 'z'; 7 | String ans = reversePrefix(word,ch); 8 | System.out.println(ans); 9 | } 10 | 11 | private static String reversePrefix(String word, char ch) { 12 | boolean firstOcc = false; 13 | StringBuilder sb = new StringBuilder(); 14 | 15 | for (int i = 0; i < word.length(); i++) { 16 | if(!firstOcc && word.charAt(i) == ch){ 17 | sb.append(word.charAt(i)); 18 | sb.reverse(); 19 | firstOcc = true; 20 | }else sb.append(word.charAt(i)); 21 | } 22 | return sb.toString(); 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Arrays/findNIntegersSumUptoZero.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class findNIntegersSumUptoZero { 6 | public static void main(String[] args) { 7 | int n = 4; 8 | int[] ans = sumZero(n); 9 | for (int i = 0; i < ans.length; i++) { 10 | System.out.print(ans[i] + " "); 11 | } 12 | } 13 | 14 | private static int[] sumZero(int n) { 15 | ArrayList al = new ArrayList<>(); 16 | for (int i = 1; i <= n / 2; i++) { 17 | al.add(i); 18 | al.add(i * -1); 19 | } 20 | if(n % 2 == 1)al.add(0); 21 | int[] ans = new int[al.size()]; 22 | for (int i = 0; i < al.size(); i++) { 23 | ans[i] = al.get(i); 24 | } 25 | return ans; 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/Arrays/kthDistinctString.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class kthDistinctString { 6 | public static String kthDistinct(String[] arr,int k){ 7 | ArrayList al = new ArrayList<>(); 8 | for (int i = 0; i < arr.length; i++) { 9 | String ch = arr[i]; 10 | int count = 0; 11 | for (int j = 0; j < arr.length; j++) { 12 | if(ch.equals(arr[j]))count++; 13 | } 14 | if(count == 1)al.add(ch); 15 | } 16 | 17 | if(k <= al.size())return al.get(k-1); 18 | else return ""; 19 | } 20 | public static void main(String[] args) { 21 | String[] arr = {"a","b","a"}; 22 | String res = kthDistinct(arr,3); 23 | System.out.println(res); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Arrays/largestNumberAtLeastTwiceOfOthers.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class largestNumberAtLeastTwiceOfOthers { 4 | public static void main(String[] args) { 5 | int[] arr = {3,6,1,0}; 6 | int max = Integer.MIN_VALUE; 7 | int maxIdx = -1; 8 | 9 | 10 | for (int i = 0; i < arr.length; i++) { 11 | if(arr[i] > max) { 12 | max = arr[i]; 13 | maxIdx = i; 14 | } 15 | } 16 | boolean isLargest = true; 17 | for (int i = 0; i < arr.length; i++) { 18 | if(arr[i]!=max && max < 2 * arr[i]){ 19 | isLargest = false; 20 | break; 21 | } 22 | } 23 | if(isLargest) System.out.println(maxIdx); 24 | else System.out.println(-1); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Arrays/sort0and1and2_Method1.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class sort0and1and2_Method1 { 4 | 5 | public static void swap(int[] arr,int left,int right){ 6 | int temp = arr[left]; 7 | arr[left] = arr[right]; 8 | arr[right] = temp; 9 | } 10 | 11 | public static void main(String[] args) { 12 | int []arr = {0,2,1,2,1,0,2,1}; 13 | int left_ptr = 0; 14 | int right_ptr = arr.length - 1; 15 | 16 | for(int i=0;i arr[j]){ 19 | int temp = arr[i]; 20 | arr[i] = arr[j]; 21 | arr[j] = temp; 22 | } 23 | } 24 | System.out.print(arr[i]+" "); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/Arrays/sumOfOddLengthSubArrays.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class sumOfOddLengthSubArrays { 4 | public static void main(String[] args) { 5 | int[] arr = {1,4,2,5,3}; 6 | int ans = sumOddLengthSubarrays(arr); 7 | System.out.println(ans); 8 | } 9 | 10 | private static int sumOddLengthSubarrays(int[] arr) { 11 | int total = 0; 12 | for (int i = 0; i < arr.length; i++) { 13 | for (int j = i; j < arr.length; j++) { 14 | if((j - i + 1) % 2 == 1){ 15 | int sum = 0; 16 | for (int k = i; k <= j; k++) { 17 | sum += arr[k]; 18 | } 19 | total += sum; 20 | } 21 | } 22 | } 23 | return total; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Arrays/twoSum.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.Scanner; 4 | 5 | public class twoSum { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | int[] arr = {0,2,4,6,7,8,9}; 9 | System.out.println("Enter the target value : "); 10 | int target = sc.nextInt(); 11 | 12 | int flag = 0; 13 | for(int i=0;i pq = new PriorityQueue<>(); 8 | for (int i = 0; i < arr.length; i++) { 9 | pq.add((long) arr[i]); 10 | } 11 | long cost = 0; 12 | while(pq.size() > 1){ 13 | long min1 = pq.remove(); 14 | long min2 = pq.remove(); 15 | long sum = min1 + min2; 16 | pq.add(sum); 17 | cost += sum; 18 | } 19 | return cost; 20 | } 21 | public static void main(String[] args) { 22 | int[] arr = {4,7,2,6,9}; 23 | long res = minCost(arr); 24 | System.out.println(res); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/PatternPrinting/Composite_Patterns/numberPyramidPalindrome.java: -------------------------------------------------------------------------------- 1 | package PatternPrinting.Composite_Patterns; 2 | 3 | import java.util.Scanner; 4 | 5 | public class numberPyramidPalindrome { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | 9 | System.out.println("Enter the no of rows : "); 10 | int n = sc.nextInt(); 11 | 12 | for(int i=1;i<=n;i++){ 13 | for(int j=n-i;j>=1;j--){ 14 | System.out.print(" "+" "); 15 | } 16 | 17 | for(int j=1;j<=i;j++){ 18 | System.out.print(j+" "); 19 | } 20 | 21 | for(int j=i-1;j>=1;j--){ 22 | System.out.print(j + " "); 23 | } 24 | System.out.println(); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/Amazon/angreziMedium.java: -------------------------------------------------------------------------------- 1 | package Amazon; 2 | 3 | public class angreziMedium { 4 | static String[] belowTwenty = { 5 | "", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", 6 | "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", 7 | "Eighteen", "Nineteen" 8 | }; 9 | 10 | static String[] tens = { 11 | "", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety" 12 | }; 13 | public static void main(String[] args) { 14 | int num = 16; 15 | String ans = convertToWords(num); 16 | System.out.println(ans); 17 | } 18 | 19 | private static String convertToWords(int num) { 20 | if(num < 20)return belowTwenty[num]; 21 | return ""; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Arrays/sumOfNumberAndReverse.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | 4 | public class sumOfNumberAndReverse { 5 | public static int rev(int num){ 6 | String n = String.valueOf(num); 7 | StringBuilder rev = new StringBuilder(); 8 | for (int i = n.length()-1; i >= 0; i--) { 9 | rev.append(n.charAt(i)); 10 | } 11 | return Integer.parseInt(rev.toString()); 12 | } 13 | public static boolean sumOfNumAndRev(int num){ 14 | if(num == 0)return true; 15 | for (int i = 0; i < num; i++) { 16 | if(i + rev(i) == num)return true; 17 | } 18 | return false; 19 | } 20 | public static void main(String[] args) { 21 | int num = 0; 22 | boolean result = sumOfNumAndRev(num); 23 | System.out.println(result); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Strings/frequencyArray.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class frequencyArray { 4 | public static void main(String[] args) { 5 | String str = "abacaa"; 6 | int []arr = new int[26]; 7 | 8 | for(int i=0;i st = new Stack<>(); 14 | for (int i = 0; i < s.length(); i++) { 15 | if(s.charAt(i) != '*')st.push(s.charAt(i)); 16 | else if(s.charAt(i) == '*'){ 17 | st.pop(); 18 | } 19 | } 20 | StringBuilder sb = new StringBuilder(); 21 | while (!st.isEmpty()){ 22 | sb.append(st.pop()); 23 | } 24 | return sb.reverse().toString(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Strings/removeTrailingZeroes.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class removeTrailingZeroes { 4 | public static void main(String[] args) { 5 | String s = "123"; 6 | String ans = removeZeroes(s); 7 | System.out.println(ans); 8 | } 9 | 10 | private static String removeZeroes(String s) { 11 | StringBuilder sb = new StringBuilder(); 12 | int i = s.length()-1; 13 | while (i != 0){ 14 | while (s.charAt(i) == '0'){ 15 | i--; 16 | } 17 | if(s.charAt(i) != '0'){ 18 | while (i != 0){ 19 | sb.append(s.charAt(i)); 20 | i--; 21 | } 22 | } 23 | } 24 | sb.append(s.charAt(0)); 25 | return sb.reverse().toString(); 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/Strings/shuffleString.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | public class shuffleString { 4 | public static void main(String[] args) { 5 | String s = "codeleet"; 6 | int[] arr = {4,5,6,7,0,2,1,3}; 7 | String ans = restoreString(s,arr); 8 | System.out.println(ans); 9 | } 10 | 11 | private static String restoreString(String s, int[] arr) { 12 | StringBuilder t = new StringBuilder(s); 13 | for (int i = 0; i < t.length(); i++) { 14 | int idx = getIdx(arr,i); 15 | t.setCharAt(i,s.charAt(idx)); 16 | } 17 | return t.toString(); 18 | } 19 | 20 | private static int getIdx(int[] arr, int ele) { 21 | for (int i = 0; i < arr.length; i++) { 22 | if(arr[i] == ele)return i; 23 | } 24 | return 0; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/SlidingWindow/maxSumOfSubarrays.java: -------------------------------------------------------------------------------- 1 | package SlidingWindow; 2 | 3 | public class maxSumOfSubarrays { 4 | public static int maximumSubarraySum(int[] arr, int k){ 5 | int n = arr.length; 6 | int sum=0; int maxSum=0; 7 | int i=0; int j=k-1; 8 | for (int a = i; a <= j; a++) { 9 | sum += arr[a]; 10 | } 11 | if(n == k)return sum; 12 | i++; j++; 13 | while (j al = new ArrayList<>(); 18 | for (int i = 0; i < arr.length ; i++) { 19 | al.add(arr[i]); 20 | } 21 | for (int i = 0; i < al.size(); i++) { 22 | System.out.print(al.get(i) + " "); 23 | } 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Trees/NodeOfTree.java: -------------------------------------------------------------------------------- 1 | package Trees; 2 | class Node{ 3 | int val; 4 | Node left; 5 | Node right; 6 | Node(int val){ 7 | this.val = val; 8 | } 9 | } 10 | 11 | public class NodeOfTree { 12 | private static void display(Node root){ 13 | if(root == null)return; 14 | System.out.print(root.val + " "); 15 | display(root.left); 16 | display(root.right); 17 | } 18 | public static void main(String[] args) { 19 | Node root = new Node(1); 20 | Node a = new Node(4); 21 | Node b = new Node(3); 22 | Node c = new Node(2); 23 | Node d = new Node(6); 24 | Node e = new Node(5); 25 | root.left = a;root.right = b; 26 | a.left = c;a.right = d; 27 | b.left = null;b.right = e; 28 | display(root); 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/Arrays/nextGreaterElement.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class nextGreaterElement { 4 | public static void main(String[] args) { 5 | int[] arr1 = {4,1,2}; 6 | int[] arr2 = {1,3,4,2}; 7 | int[] ans = new int[arr1.length]; 8 | 9 | for (int i = 0; i < arr1.length; i++) { 10 | boolean found = false; 11 | for (int j = 0; j < arr2.length; j++) { 12 | if(arr1[i] == arr2[j]) { 13 | found = true; 14 | } 15 | if(found && arr1[i] < arr2[j]){ 16 | ans[i] = arr2[j]; 17 | break; 18 | }else ans[i] = -1; 19 | } 20 | } 21 | 22 | for (int i = 0; i < ans.length; i++) { 23 | System.out.print(ans[i] + " "); 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Arrays/reverseDegreeOfAString.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | import java.util.HashMap; 4 | public class reverseDegreeOfAString { 5 | public static void main(String[] args) { 6 | String s = "abc"; 7 | int ans = reverseDegree(s); 8 | System.out.println(ans); 9 | } 10 | 11 | private static int reverseDegree(String s) { 12 | HashMap map = new HashMap<>(); 13 | for (int i = 1; i <= 26; i++) { 14 | char ch = (char)('a' + i - 1); 15 | map.put(ch,27-i); 16 | } 17 | System.out.println(map); 18 | int sum = 0; 19 | for (int i = 1; i <= s.length(); i++) { 20 | int deg = map.get(s.charAt(i-1)); 21 | sum += deg * i; 22 | System.out.println(sum); 23 | } 24 | return sum; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Strings/countVowels.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.Scanner; 4 | 5 | public class countVowels { 6 | 7 | public static boolean isVowel(char ch){ 8 | if(ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' || ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U') 9 | return true; 10 | 11 | return false; 12 | } 13 | public static void main(String[] args) { 14 | Scanner sc = new Scanner(System.in); 15 | System.out.print("Enter a string : "); 16 | String str = sc.nextLine(); 17 | int count = 0; 18 | 19 | for(int i=0;ik){ 13 | if(nums[i] == 0){ 14 | flips--; 15 | } 16 | i++; 17 | } 18 | maxLen = Math.max(maxLen,j-i+1); 19 | } 20 | return maxLen; 21 | } 22 | public static void main(String[] args) { 23 | int[] arr = {0,0,1,1,0,1,1}; 24 | int k = 2; 25 | int ans = longestOnes(arr,k); 26 | System.out.println(ans); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/Arrays/coutingBits.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | /* 4 | Given an integer n, return an array ans of length n + 1 such that for each i (0 <= i <= n), ans[i] is 5 | the number of 1's in the binary representation of i. 6 | */ 7 | public class coutingBits { 8 | public static void main(String[] args) { 9 | int n = 5; 10 | int[] ans = countingBit(n); 11 | for (int i = 0; i < ans.length; i++) { 12 | System.out.print(ans[i] + " "); 13 | } 14 | } 15 | 16 | private static int[] countingBit(int n) { 17 | int[] ans = new int[n+1]; 18 | for(int i = 0; i<=n; i++){ 19 | int j = i, cnt = 0; 20 | while(j != 0){ 21 | if(j % 2 == 1) cnt++; 22 | j /= 2; 23 | } 24 | ans[i] = cnt; 25 | } 26 | return ans; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/Arrays/maxCandiesAllocatedToChildren.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class maxCandiesAllocatedToChildren { 4 | public static void main(String[] args) { 5 | int[] arr = {5,8,6}; 6 | int k = 3; 7 | int ans = maximumCandies(arr,k); 8 | System.out.println(ans); 9 | } 10 | 11 | private static int maximumCandies(int[] arr, int k) { 12 | int max = Integer.MIN_VALUE; 13 | for(int candies : arr)max = Math.max(max,candies); 14 | int low = 1; int high = max; 15 | while (low < high){ 16 | int mid = low + (high - low) / 2; 17 | int sum = 0; 18 | for(int candies : arr){ 19 | sum += candies / mid; 20 | } 21 | if(sum >= k)low = mid + 1; 22 | else high = mid; 23 | } 24 | return low; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Arrays/maxDiffBetweenAdjElements.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | //leetcode - 3423. Maximum Difference Between Adjacent Elements in a Circular Array 4 | public class maxDiffBetweenAdjElements { 5 | public static void main(String[] args) { 6 | int[] arr = {2,1,0}; 7 | int diff = maxAdjacentDistance(arr); 8 | System.out.println(diff); 9 | } 10 | 11 | private static int maxAdjacentDistance(int[] arr) { 12 | int maxDiff = Integer.MIN_VALUE; 13 | int i=0; int j=1; 14 | while (j=m || col>=n)return 0; 8 | if(row==m-1 && col==n-1)return 1; 9 | if(dp[row][col] != -1)return dp[row][col]; 10 | int rightWays = paths(row,col+1,m,n,dp); 11 | int downWays = paths(row+1,col,m,n,dp); 12 | return rightWays+downWays; 13 | } 14 | public static void main(String[] args) { 15 | int m = 3, n = 7; 16 | int[][] dp = new int[m][n]; 17 | for (int i = 0; i < m; i++) { 18 | for (int j = 0; j < n; j++) { 19 | dp[i][j] = -1; 20 | } 21 | } 22 | int ans = paths(0,0,m,n,dp); 23 | System.out.println(ans); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Stack/nextGreaterElement.java: -------------------------------------------------------------------------------- 1 | package Stack; 2 | 3 | import java.util.Stack; 4 | 5 | public class nextGreaterElement { 6 | public static void main(String[] args) { 7 | int[] arr = {1,3,2,1,8,6,3,4}; 8 | Stack st = new Stack<>(); 9 | int[] ans = new int[arr.length]; 10 | 11 | for (int i = arr.length-1; i >= 0; i--) { 12 | int ch = arr[i]; 13 | if(st.isEmpty()){ 14 | ans[i] = -1; 15 | } 16 | else if(st.peek() > ch) { 17 | ans[i] = st.peek(); 18 | } 19 | else if(st.peek() < ch){ 20 | while(!st.isEmpty() && st.peek() < ch) st.pop(); 21 | if(st.isEmpty())ans[i] = -1; 22 | else ans[i] = st.peek(); 23 | } 24 | st.push(ch); 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/Stack/postfixToPrefix.java: -------------------------------------------------------------------------------- 1 | package Stack; 2 | 3 | import java.util.Stack; 4 | 5 | public class postfixToPrefix { 6 | public static String postToPre(String s){ 7 | Stack st = new Stack<>(); 8 | for (int i = 0; i < s.length(); i++) { 9 | char ch = s.charAt(i); 10 | if(Character.isDigit(ch))st.push(String.valueOf(ch)); 11 | else if(ch == '+' || ch == '-' || ch == '*' || ch == '/'){ 12 | String val2 = st.pop(); 13 | String val1 = st.pop(); 14 | String res = ch+val1+val2; 15 | st.push(res); 16 | } 17 | } 18 | return st.peek(); 19 | } 20 | public static void main(String[] args) { 21 | String s = "953+4*6/-"; 22 | String res = postToPre(s); 23 | System.out.println(res); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Arrays/maxValueOfString.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class maxValueOfString { 4 | public static boolean isNumeric(String s){ 5 | for(char ch : s.toCharArray()){ 6 | if(!Character.isDigit(ch))return false; 7 | } 8 | return true; 9 | } 10 | public static int maxValue(String[] str){ 11 | int max = 0; 12 | int val; 13 | 14 | for(String s : str){ 15 | if(isNumeric(s)){ 16 | val = Integer.parseInt(s); 17 | }else{ 18 | val = s.length(); 19 | } 20 | max = Math.max(val,max); 21 | } 22 | return max; 23 | } 24 | public static void main(String[] args) { 25 | String[] s = {"alic3","bob","3","4","00000"}; 26 | int res = maxValue(s); 27 | System.out.println(res); 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/Hashmaps/badPairs.java: -------------------------------------------------------------------------------- 1 | package Hashmaps; 2 | 3 | import java.util.HashMap; 4 | 5 | public class badPairs { 6 | public static long countBadPairs(int[] arr) { 7 | HashMap map = new HashMap<>(); 8 | int badPairs = 0; 9 | int totalPairs = 0; 10 | for (int i = 0; i < arr.length; i++) { 11 | int num = arr[i] - i; 12 | totalPairs += i; 13 | 14 | if (map.containsKey(num)) { 15 | int freq = map.get(num); 16 | badPairs += freq; 17 | } 18 | 19 | map.put(num,map.getOrDefault(num,0)+1); 20 | } 21 | return totalPairs - badPairs; 22 | } 23 | public static void main(String[] args) { 24 | int[] arr = {4,1,3,3}; 25 | long ans = countBadPairs(arr); 26 | System.out.println(ans); 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/Stack/postfixToInfix.java: -------------------------------------------------------------------------------- 1 | package Stack; 2 | 3 | import java.util.Stack; 4 | 5 | public class postfixToInfix { 6 | public static String postToIn(String s){ 7 | Stack st = new Stack<>(); 8 | for (int i = 0; i < s.length(); i++) { 9 | char ch = s.charAt(i); 10 | if(Character.isDigit(ch))st.push(String.valueOf(ch)); 11 | else if(ch == '+' || ch == '-' || ch == '*' || ch == '/'){ 12 | String val2 = st.pop(); 13 | String val1 = st.pop(); 14 | String res = "("+val1+ch+val2+")"; 15 | st.push(res); 16 | } 17 | } 18 | return st.peek(); 19 | } 20 | public static void main(String[] args) { 21 | String s = "953+4*6/-"; 22 | String res = postToIn(s); 23 | System.out.println(res); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Stack/prefixToInfix.java: -------------------------------------------------------------------------------- 1 | package Stack; 2 | 3 | import java.util.Stack; 4 | 5 | public class prefixToInfix { 6 | public static String preToIn(String s){ 7 | Stack st = new Stack<>(); 8 | for (int i = s.length()-1; i >= 0; i--) { 9 | char ch = s.charAt(i); 10 | if(Character.isDigit(ch))st.push(String.valueOf(ch)); 11 | else if(ch == '+' || ch == '-' || ch == '*' || ch == '/'){ 12 | String val1 = st.pop(); 13 | String val2 = st.pop(); 14 | String res = "("+val1+ch+val2+")"; 15 | st.push(res); 16 | } 17 | } 18 | return st.peek(); 19 | } 20 | public static void main(String[] args) { 21 | String s = "-9/*+5346"; 22 | String res = preToIn(s); 23 | System.out.println(res); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Stack/prefixToPostfix.java: -------------------------------------------------------------------------------- 1 | package Stack; 2 | 3 | import java.util.Stack; 4 | 5 | public class prefixToPostfix { 6 | public static String preToPost(String s){ 7 | Stack st = new Stack<>(); 8 | for (int i = s.length()-1; i >= 0; i--) { 9 | char ch = s.charAt(i); 10 | if(Character.isDigit(ch))st.push(String.valueOf(ch)); 11 | else if(ch == '+' || ch == '-' || ch == '*' || ch == '/'){ 12 | String val1 = st.pop(); 13 | String val2 = st.pop(); 14 | String res = val1+val2+ch; 15 | st.push(res); 16 | } 17 | } 18 | return st.peek(); 19 | } 20 | public static void main(String[] args) { 21 | String s = "-9/*+5346"; 22 | String res = preToPost(s); 23 | System.out.println(res); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/Arrays/countSeniorCitizens.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class countSeniorCitizens { 4 | public static int countSenior(String[] details){ 5 | StringBuilder age = new StringBuilder(); 6 | int count = 0; 7 | for (int i = 0; i < details.length; i++) { 8 | for (int j = 0; j < details[i].length(); j++) { 9 | if(j == 11 || j == 12) age.append(details[i].charAt(j)); 10 | } 11 | String a = age.toString(); 12 | int s = Integer.parseInt(a); 13 | if(s > 60)count++; 14 | age = new StringBuilder(); 15 | } 16 | return count; 17 | } 18 | public static void main(String[] args) { 19 | String[] details = {"1313579440F5036","2921522980M3644"}; 20 | int res = countSenior(details); 21 | System.out.println(res); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Arrays/removeOneElementToMakeArrayStrictlyIncreasing.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class removeOneElementToMakeArrayStrictlyIncreasing { 4 | public static boolean canBeIncreasing(int[] arr){ 5 | int count = 0; 6 | for(int i = 1; i < arr.length; i++) { 7 | if (arr[i] <= arr[i - 1]) { 8 | count++; 9 | if (count > 1) return false; 10 | if (i > 1 && i < arr.length - 1 && arr[i] <= arr[i - 2] && arr[i + 1] <= arr[i - 1]) { 11 | return false; 12 | } 13 | } 14 | } 15 | return true; 16 | } 17 | public static void main(String[] args) { 18 | int[] arr = {2,3,1,2}; 19 | boolean res = canBeIncreasing(arr); 20 | if(res) System.out.println(true); 21 | else System.out.println(false); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/Strings/addSpacesToAString.java: -------------------------------------------------------------------------------- 1 | package Strings; 2 | 3 | import java.util.HashSet; 4 | 5 | public class addSpacesToAString { 6 | public static void main(String[] args) { 7 | String s = "icodeinpython"; 8 | int []spaces = {1,5,7,9}; 9 | String ans = addSpace(s,spaces); 10 | System.out.println(ans); 11 | } 12 | 13 | private static String addSpace(String s, int[] spaces) { 14 | StringBuilder sb = new StringBuilder(); 15 | HashSet set = new HashSet<>(); 16 | for (int i = 0; i < spaces.length; i++) { 17 | set.add(spaces[i]); 18 | } 19 | for (int i = 0; i < s.length(); i++) { 20 | if(set.contains(i)){ 21 | sb.append(" "+s.charAt(i)); 22 | }else sb.append(s.charAt(i)); 23 | } 24 | return sb.toString(); 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/Arrays/diStringMatch.java: -------------------------------------------------------------------------------- 1 | package Arrays; 2 | 3 | public class diStringMatch { 4 | public static int[] diStringMatch(String s){ 5 | int[] res = new int[s.length()+1]; 6 | int low = 0; 7 | int high = s.length(); 8 | 9 | for (int i = 0; i < s.length(); i++) { 10 | if(s.charAt(i) == 'I'){ 11 | res[i] = low; 12 | low++; 13 | } 14 | if(s.charAt(i) == 'D'){ 15 | res[i] = high; 16 | high--; 17 | } 18 | } 19 | res[res.length-1] = low; 20 | return res; 21 | } 22 | public static void main(String[] args) { 23 | String str = "DDI"; 24 | int[] res = diStringMatch(str); 25 | for (int i = 0; i < res.length; i++) { 26 | System.out.print(res[i] + " "); 27 | } 28 | } 29 | } 30 | --------------------------------------------------------------------------------