From c18318ad7716662d743e15aca0330d98bf0da3bc Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Tue, 11 Jun 2024 02:14:39 +0530 Subject: [PATCH 01/18] Array fundamentals problems day-1 TestLeaf DSA --- .../FindTargetValueIndexBySumOfInputs.java | 102 ++++++++++++++++++ .../fundamentalsArrays/ListOfProblemsNotes.md | 13 +++ src/main/resources/ProblemSolvingTemplet.md | 19 ++++ 3 files changed, 134 insertions(+) create mode 100644 src/main/java/com/testleaf/selfpaced/fundamentalsArrays/FindTargetValueIndexBySumOfInputs.java create mode 100644 src/main/java/com/testleaf/selfpaced/fundamentalsArrays/ListOfProblemsNotes.md create mode 100644 src/main/resources/ProblemSolvingTemplet.md diff --git a/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/FindTargetValueIndexBySumOfInputs.java b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/FindTargetValueIndexBySumOfInputs.java new file mode 100644 index 0000000..962d6ea --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/FindTargetValueIndexBySumOfInputs.java @@ -0,0 +1,102 @@ +package com.testleaf.selfpaced.fundamentalsArrays; +import java.util.Arrays; +import java.util.Scanner; + +/** + * + * Given the input array, find the indices of matching 2 sum of given two + * numbers. Ex - Array - {2,3,8,11,16,23} , num1=4, num2=7 , sum=11 exists in + * array return its index. + * + */ +public class FindTargetValueIndexBySumOfInputs { + + public static void main(String[] args) { + Scanner scInp = new Scanner(System.in); + System.out.print("\nEnter the size of Array : "); + int sizeOfArr = scInp.nextInt(); + double[] inputArr = new double[sizeOfArr]; + System.out.println("\nEnter the Array elements : "); + pushElementsIntoArray(inputArr); + System.out.println("\nInput Array : " + Arrays.toString(inputArr)); + System.out.print("\nEnter the 1st Num1 : "); + double num1 = scInp.nextDouble(); + System.out.print("\nEnter the 2nd Num2 : "); + double num2 = scInp.nextDouble(); + System.out.println("\nIndex of Summed Item : "+checkIsSumOfTwoNumbersExistsInArray(inputArr,num1,num2)); + + //call for 2nd problem + System.out.print("\nEnter Target Value : "); + double targetVal=scInp.nextDouble(); + System.out.println("\nOutput Index pairs : "); + findSumOfTwoIndicesAgainstTarget(inputArr,targetVal); + } + + + /* + * prob-2 - Given the input array, find the sum of any two indices of the + * matching given the target. + * + */ + private static void findSumOfTwoIndicesAgainstTarget(double[] appArr, double targetVal) { + boolean blFlag = false; + if (appArr == null) { + throw new RuntimeException("Operation can't be done for Null Array.."); + } + + if (appArr.length == 0) { + throw new RuntimeException("Empty!! array.."); + } + + for (int i = 0; i < appArr.length; i++) { + for (int j = i + 1; j < appArr.length; j++) { + double sumOfArrayItem=appArr[i]+appArr[j]; + if (sumOfArrayItem == targetVal) { + System.out.println("("+i+" , "+j+")"); + blFlag = true; + } + } + } + + if (!blFlag) { + throw new RuntimeException("No Match found!!.."); + } + } + + + /* + * prob-1 - Given the input array, find the indices of the matching 2 sum given + * the number. + * + */ + private static int checkIsSumOfTwoNumbersExistsInArray(double[] inputArr, double num1, double num2) { + int resIndex = -1; + if (inputArr == null) { + throw new RuntimeException("Operation can't be done for Null Array.."); + } + + if (inputArr.length == 0) { + throw new RuntimeException("Empty!! array.."); + } + + double sumVal = num1 + num2; + System.out.println("\nSum of Two numbers " + num1 + " , " + num2 + " : " + sumVal); + for (int i = 0; i < inputArr.length; i++) { + if (inputArr[i] == sumVal) { + resIndex = i; + break; + } + } + return resIndex; + } + + + public static void pushElementsIntoArray(double inputArr[]) { + Scanner scInp1Obj = new Scanner(System.in); + for (int i = 0; i < inputArr.length; i++) { + System.out.print("\nEnter the element No " + (i + 1) + " : "); + inputArr[i] = scInp1Obj.nextDouble(); + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/ListOfProblemsNotes.md b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/ListOfProblemsNotes.md new file mode 100644 index 0000000..552b329 --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/ListOfProblemsNotes.md @@ -0,0 +1,13 @@ +Day-1 : Fundamentals & Array +---------------------------- +1) Given the input array, find the indices of matching 2 sum of given two numbers. + Ex - Array - {2,3,8,11,16,23} , num1=4, num2=7 , sum=11 exists in array return its index. + +2) Given the input array, find the two indices of matching given the target. + Ex - Array - {2,7,11,15} , target=9 , output - {0,1} exists in array return with two indices. + +3) Given the sorted input array in non-decreasing/asc order, return the array of squares of each + number sorted in non-decreasing/asc order. + +4) Given input array and the target remove the matching target from the array. + Hint - use of Arrays.copyOf() method. \ No newline at end of file diff --git a/src/main/resources/ProblemSolvingTemplet.md b/src/main/resources/ProblemSolvingTemplet.md new file mode 100644 index 0000000..17c3aa3 --- /dev/null +++ b/src/main/resources/ProblemSolvingTemplet.md @@ -0,0 +1,19 @@ +## Problem Solving Template +1) understand the problem.
+2) Ask example of Input/Output and re-confirm it. Don't make assumption on expected Input/Output.
+3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case re-confirm with interviewer.
+4) Don't show excitement to solve the problem in front of interviewer. They may change the problem.
+5) Never leave big pauses/silence , if problem unable to crack without westing time request politely for next problem.
+6) If unable to Solve problem - impress/maximize your opportunity for next round let interviewer know "making a note of this problem/approach & will go back work on the same problem".
+7) Ask for Hints !! if at all required.
+8) Think for alternate solution.
+9) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? ask interviewer which to apply.
+10) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!.
+11) Initially to improve the logic build start with Psudo code.
+12) Keep Talking while implementing the code - explain the thinking approach.
+13) After solving the problem please execute step 3.
+14) Debug your failure to with breakPoints , watch variables fix and re-run your code.
+15) Try to ask good & relevant questions - opportunity to exhibit the skill.
+16) Do not ask stated / bad questions, create trust & transparency during interview.
+ +# Step 5 to Step 12 plays vital role to crack interviews.
From a109ec5c4bb72d256e3e3c2c08dd0ccf3532b3bd Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Tue, 11 Nov 2025 00:30:40 +0530 Subject: [PATCH 02/18] udemy /course/SDET Number based java programs : Section1 hands-on. --- .../section1/CheckPalindromNumber.java | 55 ++++++++++++++++++ .../section1/ComputeFactorialEx.java | 25 ++++++++ .../ConvertDecimalToBinaryNumber.java | 57 +++++++++++++++++++ .../sdetintcod/section1/DigitsCounterEx.java | 44 ++++++++++++++ .../section1/GenerateFinbonaciSeries.java | 27 +++++++++ .../sdetintcod/section1/SwapTwoNumbersEx.java | 24 ++++++++ 6 files changed, 232 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section1/CheckPalindromNumber.java create mode 100644 src/main/java/com/udemy/sdetintcod/section1/ComputeFactorialEx.java create mode 100644 src/main/java/com/udemy/sdetintcod/section1/ConvertDecimalToBinaryNumber.java create mode 100644 src/main/java/com/udemy/sdetintcod/section1/DigitsCounterEx.java create mode 100644 src/main/java/com/udemy/sdetintcod/section1/GenerateFinbonaciSeries.java create mode 100644 src/main/java/com/udemy/sdetintcod/section1/SwapTwoNumbersEx.java diff --git a/src/main/java/com/udemy/sdetintcod/section1/CheckPalindromNumber.java b/src/main/java/com/udemy/sdetintcod/section1/CheckPalindromNumber.java new file mode 100644 index 0000000..c3bed2a --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section1/CheckPalindromNumber.java @@ -0,0 +1,55 @@ +package com.udemy.sdetintcod.section1; +import java.util.Scanner; + +public class CheckPalindromNumber { + + public static void main(String[] args) { + Scanner scInput = new Scanner(System.in); + System.out.print("\nEnter the Number : "); + long inpNumX = scInput.nextLong(); + isNumberIsPalindrom(inpNumX); + System.out.println("\n*************************************"); + System.out.print("\nEnter the input text string : "); + String inpTextdt = scInput.next(); + stringPalindromChecker(inpTextdt); + scInput.close(); + } + + //madam + private static void stringPalindromChecker(String inpTextdt) { + boolean statusFlag = true; + inpTextdt=inpTextdt.replaceAll("\\s","").toLowerCase(); + int leftIndex = 0; + int rightIndex = inpTextdt.length() - 1; + while (leftIndex <= rightIndex) { + if (inpTextdt.charAt(leftIndex) != inpTextdt.charAt(rightIndex)) { + statusFlag = false; + break; + } + leftIndex++; + rightIndex--; + } + if (statusFlag) { + System.out.println("\n" + inpTextdt + " is a Palindrom string."); + } else { + System.out.println("\n" + inpTextdt + " is not a Palindrom string."); + } + } + + + private static void isNumberIsPalindrom(long inpNumX) { + long tempOrgNum = inpNumX, refNum = 0, remMod; + while (tempOrgNum != 0) { + remMod = (tempOrgNum % 10); + refNum = refNum * 10 + remMod; + tempOrgNum = (tempOrgNum / 10); + } + System.out.println("\nValue " + inpNumX + " of Reversed number : " + refNum); + if (refNum == inpNumX) { + System.out.println(inpNumX + " is a Palindrom Number"); + } else { + System.out.println(inpNumX + " is not a Palindrom Number"); + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section1/ComputeFactorialEx.java b/src/main/java/com/udemy/sdetintcod/section1/ComputeFactorialEx.java new file mode 100644 index 0000000..18f7f8e --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section1/ComputeFactorialEx.java @@ -0,0 +1,25 @@ +package com.udemy.sdetintcod.section1; +import java.util.Scanner; + +public class ComputeFactorialEx { + + public static void main(String[] args) { + Scanner scInput = new Scanner(System.in); + System.out.print("\nEnter the Number : "); + long inpNumX = scInput.nextLong(); + System.out.println("\nFactorial value : "+inpNumX+" ! = "+calculateFactorialOfNumber(inpNumX)); + scInput.close(); + } + + private static long calculateFactorialOfNumber(long inpNumX) { + long factVal = 1; + if (inpNumX == 0 || inpNumX == 1) { + return factVal; + } + for (int i = 1; i <= inpNumX; i++) { + factVal = factVal * i; + } + return factVal; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section1/ConvertDecimalToBinaryNumber.java b/src/main/java/com/udemy/sdetintcod/section1/ConvertDecimalToBinaryNumber.java new file mode 100644 index 0000000..84ea88b --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section1/ConvertDecimalToBinaryNumber.java @@ -0,0 +1,57 @@ +package com.udemy.sdetintcod.section1; +import java.util.Scanner; + +public class ConvertDecimalToBinaryNumber { + + public static void main(String[] args) { + Scanner scInput = new Scanner(System.in); + System.out.print("\nEnter the Number : "); + long inpNumX = scInput.nextLong(); + System.out.println("\nEquivalant in-build Binary value conversion : " + Long.toBinaryString(inpNumX)); + System.out.println("\nEquivalant in-build Hexdecimal value conversion : " + Long.toHexString(inpNumX)); + System.out.println("\nEquivalant in-build Octal value conversion : " + Long.toOctalString(inpNumX)); + System.out.println("\nEquivalant in-build Unsigned value conversion : " + Long.toUnsignedString(inpNumX)); + System.out.println("\n***********************************"); + convertToBinaryNumber(inpNumX); + System.out.println("\n***********************************"); + convertToOctalNumber(inpNumX); + scInput.close(); + } + + private static void convertToBinaryNumber(long inpNumX) { + long convertNum = 0, remMod, iCount = 1; + while (inpNumX != 0) { + // get the last digit. + remMod = inpNumX % 2; + + // Reformation of the converted new number + convertNum = convertNum + iCount * remMod; + iCount = iCount * 10; + + // This the terminal operation to execute loop till finite execution until + // inpNumX become zero + inpNumX = inpNumX / 2; + } + System.out.println("\nComputed Binary Value : " + convertNum); + } + + + private static void convertToOctalNumber(long inpNumX) { + long convertNum = 0, remMod, iCount = 1; + while (inpNumX != 0) { + // get the last digit. + remMod = inpNumX % 8; + + // Reformation of the converted new number + convertNum = convertNum + iCount * remMod; + iCount = iCount * 10; + + // This the terminal operation to execute loop till finite execution until + // inpNumX become zero + inpNumX = inpNumX / 8; + } + System.out.println("\nComputed Octal Value : " + convertNum); + } + + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section1/DigitsCounterEx.java b/src/main/java/com/udemy/sdetintcod/section1/DigitsCounterEx.java new file mode 100644 index 0000000..6689cd8 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section1/DigitsCounterEx.java @@ -0,0 +1,44 @@ +package com.udemy.sdetintcod.section1; +import java.util.Scanner; + +public class DigitsCounterEx { + + public static void main(String[] args) { + Scanner scInput = new Scanner(System.in); + System.out.print("\nEnter the Number : "); + long inpNumX = scInput.nextLong(); + System.out.println("\nThe number digits for the number "+inpNumX+" is : "+getNumberOfDigits(inpNumX)); + System.out.println("**********************************************"); + computeNumberOfOddsAndEvenDigitsOfInputNumber(inpNumX); + scInput.close(); + } + + private static void computeNumberOfOddsAndEvenDigitsOfInputNumber(long inpNumX) { + int oddCount = 0, evenCount = 0; + long tempNum=inpNumX; + while (tempNum != 0) { + long lastDigits = (tempNum % 10); + if (lastDigits % 2 == 0) { + System.out.println("\nEven Digits : "+lastDigits); + evenCount++; + } + else { + System.out.println("\nOdd Digits : "+lastDigits); + oddCount++; + } + tempNum = tempNum / 10; + } + System.out.println("\nNumber of Even digits for the number "+inpNumX+" is : "+evenCount); + System.out.println("\nNumber of Odd digits for the number "+inpNumX+" is : "+oddCount); + } + + private static int getNumberOfDigits(long inpNumX) { + int countOfDigit = 0; + while (inpNumX != 0) { + inpNumX = inpNumX / 10; + countOfDigit++; + } + return countOfDigit; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section1/GenerateFinbonaciSeries.java b/src/main/java/com/udemy/sdetintcod/section1/GenerateFinbonaciSeries.java new file mode 100644 index 0000000..f582238 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section1/GenerateFinbonaciSeries.java @@ -0,0 +1,27 @@ +package com.udemy.sdetintcod.section1; +import java.util.Scanner; + +public class GenerateFinbonaciSeries { + + public static void main(String[] args) { + Scanner scInput = new Scanner(System.in); + System.out.print("\nEnter the N-th digit of Fibonaci series : "); + long nThTerm = scInput.nextLong(); + getListOfFibonaciSeries(nThTerm); + scInput.close(); + } + + //0 1 1 2 3 5 8 + private static void getListOfFibonaciSeries(long nThTerm) { + long firstNum=0,secNum=1,nextNum; + System.out.println("\nPopulated Fibonaci Series : "); + for (long i = 1; i <= nThTerm; i++) { + System.out.print(" "+firstNum+", "); + nextNum=firstNum+secNum; + firstNum=secNum; + secNum=nextNum; + } + + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section1/SwapTwoNumbersEx.java b/src/main/java/com/udemy/sdetintcod/section1/SwapTwoNumbersEx.java new file mode 100644 index 0000000..c382923 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section1/SwapTwoNumbersEx.java @@ -0,0 +1,24 @@ +package com.udemy.sdetintcod.section1; +import java.util.Scanner; + +public class SwapTwoNumbersEx { + + public static void main(String[] args) { + Scanner scInput = new Scanner(System.in); + System.out.print("\nEnter the 1st Number : "); + double inpNumX = scInput.nextDouble(); + System.out.print("\nEnter the 2nd Number : "); + double inpNumY = scInput.nextDouble(); + doSwappingByAddSubstract(inpNumX,inpNumY); + scInput.close(); + } + + private static void doSwappingByAddSubstract(double inpNumX, double inpNumY) { + System.out.println("\nOriginal Value of X = "+inpNumX+" , Y = "+inpNumY+" "); + inpNumX=inpNumX+inpNumY; + inpNumY=inpNumX-inpNumY; + inpNumX=inpNumX-inpNumY; + System.out.println("\nSwapped Value of X = "+inpNumX+" , Y = "+inpNumY+" "); + } + +} \ No newline at end of file From 9dbdfa2d70d82a98a25132493a13ade4ef455e4a Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Fri, 21 Nov 2025 20:43:29 +0530 Subject: [PATCH 03/18] latest problem solving with Numbers,Conditional both section2,Sec3 --- .../sdetintcod/section2/FindMaxNumber.java | 28 +++++++++++++ .../sdetintcod/section2/LeapYearChecker.java | 27 +++++++++++++ .../section2/PrimeNumberChecker.java | 27 +++++++++++++ .../section2/SumAndProductOfDigits.java | 39 +++++++++++++++++++ .../section3/PrintTheCountOfVowels.java | 27 +++++++++++++ 5 files changed, 148 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section2/FindMaxNumber.java create mode 100644 src/main/java/com/udemy/sdetintcod/section2/LeapYearChecker.java create mode 100644 src/main/java/com/udemy/sdetintcod/section2/PrimeNumberChecker.java create mode 100644 src/main/java/com/udemy/sdetintcod/section2/SumAndProductOfDigits.java create mode 100644 src/main/java/com/udemy/sdetintcod/section3/PrintTheCountOfVowels.java diff --git a/src/main/java/com/udemy/sdetintcod/section2/FindMaxNumber.java b/src/main/java/com/udemy/sdetintcod/section2/FindMaxNumber.java new file mode 100644 index 0000000..a026855 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section2/FindMaxNumber.java @@ -0,0 +1,28 @@ +package com.udemy.sdetintcod.section2; +import java.util.Scanner; + +public class FindMaxNumber { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the 1st number : "); + double num1 = scnsInp.nextDouble(); + System.out.println("\nEnter the 2nd number : "); + double num2 = scnsInp.nextDouble(); + System.out.println("\nEnter the 3rd number : "); + double num3 = scnsInp.nextDouble(); + System.out.println("\nThe Maximum among three number ( "+num1+" ,"+num2+" ,"+num3+" ) is : "+getMaxNumber(num1,num2,num3)); + scnsInp.close(); + } + + private static double getMaxNumber(double num1, double num2, double num3) { + if (num1 > num2 && num1 > num3) { + return num1; + } else if (num2 > num1 && num2 > num3) { + return num2; + } else { + return num3; + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section2/LeapYearChecker.java b/src/main/java/com/udemy/sdetintcod/section2/LeapYearChecker.java new file mode 100644 index 0000000..1d4bb85 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section2/LeapYearChecker.java @@ -0,0 +1,27 @@ +package com.udemy.sdetintcod.section2; +import java.util.Scanner; + +public class LeapYearChecker { + + public static void main(String[] args) { + Scanner scnsInp=new Scanner(System.in); + System.out.println("\nEnter the year : "); + long num=scnsInp.nextLong(); + System.out.println("\nThe inputed year "+num+" status is : "+isLeapYear(num)); + scnsInp.close(); + } + + private static String isLeapYear(long num) { + String yearStatus = "Not a Leap Year."; + if (num % 4 == 0) { + if (num % 100 == 0) { + if (num % 400 == 0) { + yearStatus="Leap Year."; + } + } + yearStatus="Leap Year."; + } + return yearStatus; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section2/PrimeNumberChecker.java b/src/main/java/com/udemy/sdetintcod/section2/PrimeNumberChecker.java new file mode 100644 index 0000000..dfd8da7 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section2/PrimeNumberChecker.java @@ -0,0 +1,27 @@ +package com.udemy.sdetintcod.section2; +import java.util.Scanner; + +public class PrimeNumberChecker { + + public static void main(String[] args) { + Scanner scnsInp=new Scanner(System.in); + System.out.println("\nEnter the number : "); + long num=scnsInp.nextLong(); + System.out.println("\nThe inputed "+num+" is : "+validateIfNumberIsPrime(num)); + scnsInp.close(); + } + + private static String validateIfNumberIsPrime(long num) { + String resultOut = "Prime number"; + if (num <= 1) { + return resultOut = "Not a Prime number."; + } + for (long i = 2; i < Math.sqrt(num); i++) { + if (num % i == 0) { + return resultOut = "Not a Prime number."; + } + } + return resultOut; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section2/SumAndProductOfDigits.java b/src/main/java/com/udemy/sdetintcod/section2/SumAndProductOfDigits.java new file mode 100644 index 0000000..63fb5c4 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section2/SumAndProductOfDigits.java @@ -0,0 +1,39 @@ +package com.udemy.sdetintcod.section2; +import java.util.Scanner; + +public class SumAndProductOfDigits { + + public static void main(String[] args) { + Scanner scnsInp=new Scanner(System.in); + System.out.println("\nEnter the number : "); + long num=scnsInp.nextLong(); + System.out.println("\nThe inputed "+num+" is and the sum of Digits : "+getTheSumOfDigits(num)); + System.out.println("\nThe inputed "+num+" is and the Product of Digits : "+getTheProductOfDigits(num)); + scnsInp.close(); + } + + private static long getTheProductOfDigits(long num) { + long productOfDigits=1; + while (num!=0) { + //get the last digit of the number + long lastDigit=(num%10); + productOfDigits=productOfDigits*lastDigit; + //Cut/reduce the number & keep remaining + num=num/10; + } + return productOfDigits; + } + + private static long getTheSumOfDigits(long num) { + long sumOfDigits = 0; + while (num != 0) { + // get the last digit of the number + long lastDigit = (num % 10); + sumOfDigits = sumOfDigits + lastDigit; + // Cut/reduce the number & keep remaining + num = num / 10; + } + return sumOfDigits; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section3/PrintTheCountOfVowels.java b/src/main/java/com/udemy/sdetintcod/section3/PrintTheCountOfVowels.java new file mode 100644 index 0000000..1194ce1 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section3/PrintTheCountOfVowels.java @@ -0,0 +1,27 @@ +package com.udemy.sdetintcod.section3; +import java.util.Scanner; + +public class PrintTheCountOfVowels { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String textInput = scnsInp.nextLine(); + System.out.println("\nCount of Vowels into '"+textInput+"' is : "+getCountOfVowels(textInput)); + scnsInp.close(); + } + + private static int getCountOfVowels(String textInput) { + textInput = textInput.replaceAll("[\\d\\s]+", "").toLowerCase(); + System.out.println("\nNormalized String : "+textInput); + int countOfVowels = 0; + for (char ch : textInput.toCharArray()) { + if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u') { + System.out.println("Filtered Vowels : "+ch); + countOfVowels++; + } + } + return countOfVowels; + } + +} \ No newline at end of file From 2681163a6b4faa3b1f3aad14ed04a11ba4c508e1 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Fri, 6 Feb 2026 23:38:32 +0530 Subject: [PATCH 04/18] Added latest SDET-pracktices sec3 problem solutions. --- .../section3/DuplicateWordFinder.java | 47 +++++++++++++++ .../sdetintcod/section3/PanagramChecker.java | 32 ++++++++++ .../section3/ShowCharsFrequencyDescOrder.java | 58 +++++++++++++++++++ .../section3/TextStringCompression.java | 39 +++++++++++++ 4 files changed, 176 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section3/DuplicateWordFinder.java create mode 100644 src/main/java/com/udemy/sdetintcod/section3/PanagramChecker.java create mode 100644 src/main/java/com/udemy/sdetintcod/section3/ShowCharsFrequencyDescOrder.java create mode 100644 src/main/java/com/udemy/sdetintcod/section3/TextStringCompression.java diff --git a/src/main/java/com/udemy/sdetintcod/section3/DuplicateWordFinder.java b/src/main/java/com/udemy/sdetintcod/section3/DuplicateWordFinder.java new file mode 100644 index 0000000..8bd807e --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section3/DuplicateWordFinder.java @@ -0,0 +1,47 @@ +package com.udemy.sdetintcod.section3; +import java.util.HashMap; +import java.util.Map; +import java.util.Scanner; + +public class DuplicateWordFinder { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String textInput = scnsInp.nextLine(); + System.out.println("\n****** Duplicated Words *******"); + showRepeatedWords(textInput); + scnsInp.close(); + } + + private static void showRepeatedWords(String textInput) { + // Normalizing the input string + textInput = textInput.toLowerCase(); + + // get the words array + String[] strWordsArr = textInput.split("[\\W_]+"); + + // Declaration of Map to hold duplicate values + Map hMapObj = new HashMap<>(); + for (String strWordItems : strWordsArr) { + if (!strWordItems.isEmpty()) { + hMapObj.put(strWordItems, hMapObj.getOrDefault(strWordItems, 0) + 1); + } + } + + boolean duplicateFlag=false; + for (Map.Entry entry : hMapObj.entrySet()) { + if (entry.getValue() > 1) { + System.out.println("\n The word : '" + entry.getKey() + "' repeated : " + entry.getValue() + " times."); + duplicateFlag=true; + } + } + + if (!duplicateFlag) { + System.out.println("No!!..duplicate found.."); + } + + + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section3/PanagramChecker.java b/src/main/java/com/udemy/sdetintcod/section3/PanagramChecker.java new file mode 100644 index 0000000..0ed5071 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section3/PanagramChecker.java @@ -0,0 +1,32 @@ +package com.udemy.sdetintcod.section3; +import java.util.HashSet; +import java.util.Scanner; +import java.util.Set; + +public class PanagramChecker { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String textInput = scnsInp.nextLine(); + System.out.println("\nPanagram status string for '" + textInput + "' is : " + getPanagramStatus(textInput)); + scnsInp.close(); + } + + private static String getPanagramStatus(String textInput) { + //Normalizing the input string + textInput=textInput.replaceAll("^[a-z]","").toLowerCase(); + System.out.println("\nNormalized string : "+textInput); + + //Declaration of Set to maintain unique characters + Set chrSetsTd=new HashSet<>(); + for (char charItems:textInput.toCharArray()) { + if (charItems>='a' && charItems<='z') { + chrSetsTd.add(charItems); + } + } + //check condition for panagram checking + return (chrSetsTd.size()==26)?"Its Panagram.":"Not a Panagram."; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section3/ShowCharsFrequencyDescOrder.java b/src/main/java/com/udemy/sdetintcod/section3/ShowCharsFrequencyDescOrder.java new file mode 100644 index 0000000..8e4af16 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section3/ShowCharsFrequencyDescOrder.java @@ -0,0 +1,58 @@ +package com.udemy.sdetintcod.section3; +import java.util.ArrayList; +import java.util.List; +import java.util.Scanner; + +public class ShowCharsFrequencyDescOrder { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String textInput = scnsInp.next(); + System.out.println("\n***** Desc order sorted Charecter frequency ******"); + descSortedCharFrequency(textInput); + scnsInp.close(); + } + + private static void descSortedCharFrequency(String textInput) { + //Normalizing the input text + textInput=textInput.toLowerCase().replaceAll("^[a-z]",""); + int inputTextLen=textInput.length(); + + //Declaration of characters counts int[] frequency array with 256 ASCII Chars size + int[] charCountsFrequency=new int[256]; + int frequncyArrayLen=charCountsFrequency.length; + + //push information to frequency array by traversing to input text charecters + for (int i = 0; i < inputTextLen; i++) { + charCountsFrequency[textInput.charAt(i)]++; + } + + List lstOfChars=new ArrayList<>(); + //Traverse over the Frequency array & push element to Charecters list + for (int i = 0; i < frequncyArrayLen; i++) { + if (charCountsFrequency[i] > 0) { + lstOfChars.add((char) i); + } + } + + //Bubble sort for Desc order on array list + for (int i = 0; i charCountsFrequency[lstOfChars.get(i)]) { + char temp=lstOfChars.get(i); + lstOfChars.set(i,lstOfChars.get(j)); + lstOfChars.set(j,temp); + } + } + } + + //Traverse to display the Disc sorted chars with count. + for (Character charsItem : lstOfChars) { + System.out.println("\n"+charsItem+" with count of : "+charCountsFrequency[charsItem]); + } + + + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section3/TextStringCompression.java b/src/main/java/com/udemy/sdetintcod/section3/TextStringCompression.java new file mode 100644 index 0000000..ea3c5c5 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section3/TextStringCompression.java @@ -0,0 +1,39 @@ +package com.udemy.sdetintcod.section3; +import java.util.Scanner; + +public class TextStringCompression { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String textInput = scnsInp.nextLine(); + System.out.println("\nCompressed output string for '" + textInput + "' is : " + getCompressedText(textInput)); + scnsInp.close(); + } + + private static String getCompressedText(String textInput) { + if (textInput == null || textInput.isEmpty()) { + return textInput; + } + + int strSrcOrgLen = textInput.length(); + // Using StringBuilder for efficient mutable string operation + StringBuilder strBuild = new StringBuilder(); + int charOccCount = 0; + + for (int i = 0; i < strSrcOrgLen; i++) { + charOccCount++; + if (i + 1 == strSrcOrgLen || textInput.charAt(i) != textInput.charAt(i + 1)) { + strBuild.append(textInput.charAt(i)).append(charOccCount); + // reseting the occurrence count to 0. + charOccCount = 0; + } + } + // Length computation for compressed string + int strCompressLen = strBuild.toString().length(); + + // Checking length original input-text vs compressed string. + return (strCompressLen < strSrcOrgLen) ? strBuild.toString() : textInput; + } + +} \ No newline at end of file From d27310cd1a21f2ef2a32146beffc6e4363de6c00 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Mon, 23 Feb 2026 15:47:54 +0530 Subject: [PATCH 05/18] added latest java-strings concepts problem solvings. --- .../section4/AlphabeticalSortOfWeekArray.java | 33 ++++++++++++ .../section4/OccuranceAndMaxOccChars.java | 42 +++++++++++++++ .../RemoveNonConsicutiveDuplicates.java | 54 +++++++++++++++++++ .../RemoveOnlyConsicutiveDuplicates.java | 54 +++++++++++++++++++ .../section4/TextLenghtCalcWithoutFunc.java | 44 +++++++++++++++ .../TextReversalByKeepingSpecialChars.java | 50 +++++++++++++++++ src/main/resources/JavaStringProblems.md | 34 ++++++++++++ 7 files changed, 311 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section4/AlphabeticalSortOfWeekArray.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/OccuranceAndMaxOccChars.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/RemoveNonConsicutiveDuplicates.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/RemoveOnlyConsicutiveDuplicates.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/TextLenghtCalcWithoutFunc.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/TextReversalByKeepingSpecialChars.java create mode 100644 src/main/resources/JavaStringProblems.md diff --git a/src/main/java/com/udemy/sdetintcod/section4/AlphabeticalSortOfWeekArray.java b/src/main/java/com/udemy/sdetintcod/section4/AlphabeticalSortOfWeekArray.java new file mode 100644 index 0000000..6b48099 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/AlphabeticalSortOfWeekArray.java @@ -0,0 +1,33 @@ +package com.udemy.sdetintcod.section4; +import java.util.Arrays; +import java.util.Set; +import java.util.TreeSet; + +/** + * + * Part of TCS interview - 07-02-2026 + * + */ +public class AlphabeticalSortOfWeekArray { + + public static void main(String[] args) { + String[] strWeekArray={"sun","mon","tue","wed","thu","fri","sat"}; + System.out.println("\nInput string array : "+Arrays.toString(strWeekArray)); + System.out.println("\nResultant Sorted Array : "+Arrays.toString(alphaSortedArrayItems(strWeekArray))); + } + + /** + * Using TreeSet inbuilt sorted property + * + * @param strWeekArray + * @return + */ + private static String[] alphaSortedArrayItems(String[] strWeekArray) { + Set sortedSet = new TreeSet<>(); + for (String strItems : strWeekArray) { + sortedSet.add(strItems); + } + return sortedSet.toArray(new String[0]); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/OccuranceAndMaxOccChars.java b/src/main/java/com/udemy/sdetintcod/section4/OccuranceAndMaxOccChars.java new file mode 100644 index 0000000..8784163 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/OccuranceAndMaxOccChars.java @@ -0,0 +1,42 @@ +package com.udemy.sdetintcod.section4; +import java.util.HashMap; +import java.util.Map; +import java.util.Scanner; + +public class OccuranceAndMaxOccChars { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String textInput = scnsInp.nextLine(); + System.out.println("\n****** Repeted charecters occurance & max occurance of charecters *******"); + maxOccuranceOfRepeatedChars(textInput); + scnsInp.close(); + } + + private static void maxOccuranceOfRepeatedChars(String textInput) { + textInput=textInput.replaceAll("\\s",""); + + //Store key-value of Repeated characters frequency. + Map lnkHashMp=new HashMap<>(); + for (int i = 0; i < textInput.length(); i++) { + char currentChar = textInput.charAt(i); + if (lnkHashMp.containsKey(currentChar)) { + lnkHashMp.put(currentChar,lnkHashMp.get(currentChar)+1); + } else { + lnkHashMp.put(currentChar,1); + } + } + System.out.println("\nOccurance Of Charecters from Input Text : "+lnkHashMp); + int max=0; + char tempKey=' '; + for (Map.Entry entry : lnkHashMp.entrySet()) { + if(max 0 && current == textInput.charAt(i - 1)) { + isConsecutiveDuplicate = true; + } + + // Strictly append only if it is a consecutive duplicate + if (isConsecutiveDuplicate) { + result.append(current); + } + } + + System.out.println("Input: " + textInput); + System.out.println("Output: " + result.toString()); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/RemoveOnlyConsicutiveDuplicates.java b/src/main/java/com/udemy/sdetintcod/section4/RemoveOnlyConsicutiveDuplicates.java new file mode 100644 index 0000000..0c97c99 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/RemoveOnlyConsicutiveDuplicates.java @@ -0,0 +1,54 @@ +package com.udemy.sdetintcod.section4; +import java.util.Scanner; + +/** + * + * Part of TCS interview - 07-02-2026 + * + */ +public class RemoveOnlyConsicutiveDuplicates { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String textInput = scnsInp.nextLine(); + System.out.println("\n****** Remove only cosicutive repeated charecters *******"); + removeOnlyConsicutiveDuplicatesRepeatedChars(textInput); + scnsInp.close(); + } + + private static void removeOnlyConsicutiveDuplicatesRepeatedChars(String textInput) { + StringBuilder result = new StringBuilder(); + + for (int i = 0; i < textInput.length(); i++) { + char current = textInput.charAt(i); + + // Keep spaces strictly + if (current == ' ') { + result.append(current); + continue; + } + + // Check if current character is part of a consecutive duplicate pair + boolean isConsecutiveDuplicate = false; + + // Check the character to the right + if (i < textInput.length() - 1 && current == textInput.charAt(i + 1)) { + isConsecutiveDuplicate = true; + } + // Check the character to the left + if (i > 0 && current == textInput.charAt(i - 1)) { + isConsecutiveDuplicate = true; + } + + // Strictly append only if it is a consecutive duplicate + if (!isConsecutiveDuplicate) { + result.append(current); + } + } + + System.out.println("Input: " + textInput); + System.out.println("Output: " + result.toString()); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/TextLenghtCalcWithoutFunc.java b/src/main/java/com/udemy/sdetintcod/section4/TextLenghtCalcWithoutFunc.java new file mode 100644 index 0000000..d6f5b90 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/TextLenghtCalcWithoutFunc.java @@ -0,0 +1,44 @@ +package com.udemy.sdetintcod.section4; +import java.util.Scanner; + +public class TextLenghtCalcWithoutFunc { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String textInput = scnsInp.nextLine(); + System.out.println("\nComputed lenght of the input text : "+lenOfText(textInput)); + textVowelsAndConsonantsCounter(textInput); + scnsInp.close(); + } + + private static int lenOfText(String textInput) { + int lenCount = 0; + for (char chItems : textInput.toCharArray()) { + lenCount++; + } + return lenCount; + } + + /** + * Count Vowels and Consonants + * @param textInput + */ + private static void textVowelsAndConsonantsCounter(String textInput) { + textInput = textInput.toLowerCase().replaceAll("[^a-z]",""); + System.out.println("\nGeneralized string : " + textInput); + int vowelCount = 0; + int consoCount = 0; + for (char chItems : textInput.toCharArray()) { + if (chItems == 'a' || chItems == 'e' || chItems == 'i' || chItems == 'o' || chItems == 'u') { + vowelCount++; + } + else { + consoCount++; + } + } + System.out.println("\nNumber of Vowels : "+vowelCount); + System.out.println("\nNumber of Consonent : "+consoCount); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/TextReversalByKeepingSpecialChars.java b/src/main/java/com/udemy/sdetintcod/section4/TextReversalByKeepingSpecialChars.java new file mode 100644 index 0000000..4a8b185 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/TextReversalByKeepingSpecialChars.java @@ -0,0 +1,50 @@ +package com.udemy.sdetintcod.section4; +import java.util.Scanner; + +/** + * + * Part of TCS interview - 07-02-2026 + * + */ +public class TextReversalByKeepingSpecialChars { + + public static void main(String[] args) { + Scanner scnsInp = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String textInput = scnsInp.nextLine(); + System.out.println("\n****** Reversed Text *******"); + doTextReversalByKeepingSpecial(textInput); + scnsInp.close(); + } + + /** + * Using Two pointer approach. + * @param textInput + * + */ + private static void doTextReversalByKeepingSpecial(String textInput) { + String resOut = ""; + char[] charArray = textInput.toCharArray(); + int left = 0; + int right = textInput.length() - 1; + + while (left < right) { + if (!Character.isLetterOrDigit(charArray[left])) { + left++; + } + + if (!Character.isLetterOrDigit(charArray[right])) { + right--; + } + + char tempHold = charArray[left]; + charArray[left] = charArray[right]; + charArray[right] = tempHold; + left++; + right--; + } + resOut=resOut+String.valueOf(charArray); + System.out.println("\nResultant Transformed Reversed Text : "+resOut); + } + +} \ No newline at end of file diff --git a/src/main/resources/JavaStringProblems.md b/src/main/resources/JavaStringProblems.md new file mode 100644 index 0000000..5079fa7 --- /dev/null +++ b/src/main/resources/JavaStringProblems.md @@ -0,0 +1,34 @@ +## 🧠 Top 30 Java String Challenges: + + 1️⃣ Reverse a String + 2️⃣ Check if a String is Palindrome + 3️⃣ Count Occurrences of a Character + 3️⃣ Count Maximum Occurrences of a Character + 4️⃣ Find Duplicate Characters in a String + 5️⃣ Remove Duplicates from a String + 6️⃣ Check if Two Strings are Anagrams + 7️⃣ Find First Non-Repeated Character + 8️⃣ Check if a String Contains Only Digits + 9️⃣ Count Vowels and Consonants + 🔟 Check if a String is a Rotation of Another String + 11️⃣ Find the Longest Word in a Sentence + 12️⃣ Convert a String to Title Case + 13️⃣ Find All Permutations of a String + 14️⃣ Convert String to Integer (Without Integer.parseInt()) + 15️⃣ Find Frequency of Words in a Sentence + 16️⃣ Convert String to char[] Without .toCharArray() + 17️⃣ Remove Non-Alphabetic Characters + 18️⃣ Convert Lowercase to Uppercase (Without .toUpperCase()) + 19️⃣ Reverse Words in a Sentence + 20️⃣ Check if Two Strings Are One Edit Apart + 21️⃣ Implement strStr() (Find Substring Index) + 22️⃣ Compress a String (aaabb ➜ a3b2) + 23️⃣ Find Longest Common Prefix in an Array of Strings + 24️⃣ Implement isSubstring() Without contains() + 25️⃣ Print All Substrings of a String + 26️⃣ Convert a Number to Words (e.g., 123 ➜ “One Hundred Twenty-Three”) + 27️⃣ Validate an Email Address Format + 28️⃣ Convert CamelCase ➜ snake_case + 29️⃣ Find the Lexicographically Smallest String + 30️⃣ Remove Consecutive Duplicate Words from a Sentence + \ No newline at end of file From fa7859a90e39df5e84acffd8715e60e372a19a87 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Thu, 26 Feb 2026 23:59:53 +0530 Subject: [PATCH 06/18] Added all latest problem solutions for section4 --- .../section4/AlphabeticalSortOfWeekArray.java | 33 ++++++++++++++ .../section4/BubbleSortElements.java | 31 +++++++++++++ .../section4/CheckHashSetsEqualityStatus.java | 45 +++++++++++++++++++ .../section4/FindDuplicateElements.java | 29 ++++++++++++ .../section4/GetFirstNonRepeatedElements.java | 34 ++++++++++++++ .../section4/GetIndexPositionOfList.java | 39 ++++++++++++++++ .../section4/GetKeyForTargetItem.java | 42 +++++++++++++++++ .../section4/GetKthSmallestElement.java | 20 +++++++++ .../section4/MissingNumberFinder.java | 42 +++++++++++++++++ .../SearchForSpecificElementLinkedHm.java | 33 ++++++++++++++ .../SearchForSpecificElementTreeMp.java | 33 ++++++++++++++ .../section4/SortAndKeepUniques.java | 29 ++++++++++++ .../section4/SumOfArrayElements.java | 20 +++++++++ 13 files changed, 430 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section4/BubbleSortElements.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/CheckHashSetsEqualityStatus.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/FindDuplicateElements.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/GetFirstNonRepeatedElements.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/GetIndexPositionOfList.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/GetKeyForTargetItem.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/GetKthSmallestElement.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/MissingNumberFinder.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/SearchForSpecificElementLinkedHm.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/SearchForSpecificElementTreeMp.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/SortAndKeepUniques.java create mode 100644 src/main/java/com/udemy/sdetintcod/section4/SumOfArrayElements.java diff --git a/src/main/java/com/udemy/sdetintcod/section4/AlphabeticalSortOfWeekArray.java b/src/main/java/com/udemy/sdetintcod/section4/AlphabeticalSortOfWeekArray.java index 6b48099..58f531f 100644 --- a/src/main/java/com/udemy/sdetintcod/section4/AlphabeticalSortOfWeekArray.java +++ b/src/main/java/com/udemy/sdetintcod/section4/AlphabeticalSortOfWeekArray.java @@ -14,8 +14,14 @@ public static void main(String[] args) { String[] strWeekArray={"sun","mon","tue","wed","thu","fri","sat"}; System.out.println("\nInput string array : "+Arrays.toString(strWeekArray)); System.out.println("\nResultant Sorted Array : "+Arrays.toString(alphaSortedArrayItems(strWeekArray))); + System.out.println("*****************************************************************"); + + String[] studNames= {"Atif","Chuhan","KK","Aslam","Farhan","Zaved","Bilal","Faisal","Noor","Lata","Mika","Sonu"}; + performBubbleSortOnTextArray(studNames); + } + /** * Using TreeSet inbuilt sorted property * @@ -29,5 +35,32 @@ private static String[] alphaSortedArrayItems(String[] strWeekArray) { } return sortedSet.toArray(new String[0]); } + + + /** + * Do bubble sort on Text array + * + * @param strNamesArr + * + */ + private static void performBubbleSortOnTextArray(String[] strNamesArr) { + int arrayLen = strNamesArr.length - 1; + + for (int i = 0; i < arrayLen; i++) { + for (int j = 0; j < arrayLen - i; j++) { + if (strNamesArr[j].compareTo(strNamesArr[j + 1]) > 0) { + String strTemp = strNamesArr[j]; + strNamesArr[j] = strNamesArr[j + 1]; + strNamesArr[j + 1] = strTemp; + } + } + } + + System.out.println("\n********* Sorted Names *********************"); + for (String strNameItems : strNamesArr) { + System.out.print(strNameItems + ", "); + } + } + } \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/BubbleSortElements.java b/src/main/java/com/udemy/sdetintcod/section4/BubbleSortElements.java new file mode 100644 index 0000000..1b8444f --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/BubbleSortElements.java @@ -0,0 +1,31 @@ +package com.udemy.sdetintcod.section4; +import java.util.Arrays; + +public class BubbleSortElements { + + public static void main(String[] args) { + double[] numArray={1,2,105,6,7,8,99,9,3,400,5,390,200}; + doBubbleSortOnArrayElements(numArray); + } + + /** + * Perform bubble sort with input array. + * @param numArray + */ + private static void doBubbleSortOnArrayElements(double[] numArray) { + System.out.println("\nInput Array Elements : " + Arrays.toString(numArray)); + int arrLen = numArray.length - 1; + for (int i = 0; i < arrLen; i++) { + for (int j = 0; j < arrLen - i; j++) { + if (numArray[j] > numArray[j + 1]) { + double tempHold = numArray[j]; + numArray[j] = numArray[j + 1]; + numArray[j + 1] = tempHold; + } + + } + } + System.out.println("\nResultant Sorted Array : " + Arrays.toString(numArray)); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/CheckHashSetsEqualityStatus.java b/src/main/java/com/udemy/sdetintcod/section4/CheckHashSetsEqualityStatus.java new file mode 100644 index 0000000..cf44fec --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/CheckHashSetsEqualityStatus.java @@ -0,0 +1,45 @@ +package com.udemy.sdetintcod.section4; +import java.util.HashSet; +import java.util.Set; + +public class CheckHashSetsEqualityStatus { + + public static void main(String[] args) { + Set strSet1 = new HashSet<>(); + Set strSet2 = new HashSet<>(); + strSet1.add("Test"); + strSet2.add("Test"); + strSet1.add("Abhinay"); + strSet2.add("Abhinay"); + strSet1.add("KK"); + strSet2.add("KK"); + strSet1.add("CartLane"); + strSet2.add("CartLane"); + checkHashSetsEqualityStatus(strSet1,strSet2); + + strSet1.add("SDJD"); + strSet2.add("Test"); + strSet1.add("Abhi"); + strSet2.add("Abhinay"); + strSet1.add("KK"); + strSet1.add("KK"); + strSet2.add("KK"); + strSet1.add("QA"); + strSet2.add("CartLane"); + strSet2.add("SDET"); + strSet2.add("DevOps"); + strSet2.add("DevOps"); + checkHashSetsEqualityStatus(strSet1,strSet2); + } + + private static void checkHashSetsEqualityStatus(Set strSet1, Set strSet2) { + System.out.println("\nValue of Set 1 : "+strSet1); + System.out.println("\nValue of Set 2 : "+strSet2); + if (strSet1.equals(strSet2)) { + System.out.println("\nBoth the hashSets are equal."); + } else { + System.out.println("\nBoth hashSets are Not-equal."); + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/FindDuplicateElements.java b/src/main/java/com/udemy/sdetintcod/section4/FindDuplicateElements.java new file mode 100644 index 0000000..cfbb679 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/FindDuplicateElements.java @@ -0,0 +1,29 @@ +package com.udemy.sdetintcod.section4; +import java.util.Arrays; +import java.util.Set; +import java.util.TreeSet; + +public class FindDuplicateElements { + + public static void main(String[] args) { + int[] numArray = {5,6,0,3,3,1,10,20,15,22,3,55,20,6,7,10}; + System.out.println("\nInput array : " + Arrays.toString(numArray)); + System.out.println("\n********* Duplicate Array elements ***********"); + getDuplicateArrayElements(numArray); + } + + private static void getDuplicateArrayElements(int[] numArray) { + Arrays.sort(numArray); + Set numHash = new TreeSet<>(); + for (int numItems : numArray) { + if (numHash.contains(numItems)) { + numHash.add(numItems); + System.out.print(""+numItems+", "); + } else { + numHash.add(numItems); + } + } + System.out.println("\nTest data : "+numHash); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/GetFirstNonRepeatedElements.java b/src/main/java/com/udemy/sdetintcod/section4/GetFirstNonRepeatedElements.java new file mode 100644 index 0000000..4fba35d --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/GetFirstNonRepeatedElements.java @@ -0,0 +1,34 @@ +package com.udemy.sdetintcod.section4; +import java.util.LinkedHashMap; +import java.util.Map; + +public class GetFirstNonRepeatedElements { + + public static void main(String[] args) { + int[] numArray={7,4,30,5,7,7,3,4,0,1,2}; + findFirstNonRepatedItems(numArray); + } + + private static void findFirstNonRepatedItems(int[] numArray) { + // Store frequency of each elements + Map freqLnkMp = new LinkedHashMap<>(); + + // push data into linkedHashMap + for (int i : numArray) { + freqLnkMp.put(i, freqLnkMp.getOrDefault(i, 0) + 1); + } + System.out.println("\nPopulated values : " + freqLnkMp); + System.out.println("\nFirst Non-repeating element : "); + + for (Map.Entry entry : freqLnkMp.entrySet()) { + int key = entry.getKey(); + int val = entry.getValue(); + if (val == 1) { + System.out.print(key+""); + return; + } + } + + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/GetIndexPositionOfList.java b/src/main/java/com/udemy/sdetintcod/section4/GetIndexPositionOfList.java new file mode 100644 index 0000000..a067515 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/GetIndexPositionOfList.java @@ -0,0 +1,39 @@ +package com.udemy.sdetintcod.section4; +import java.util.ArrayList; +import java.util.List; + +public class GetIndexPositionOfList { + + @SuppressWarnings("null") + public static void main(String[] args) { + List lstItems = new ArrayList<>();; + lstItems.add(500); + lstItems.add(50); + lstItems.add(5); + lstItems.add(99); + lstItems.add(100); + lstItems.add(20); + lstItems.add(35); + lstItems.add(70); + + int targetItem=300; + getIndexOfTargetItem(lstItems,targetItem); + + int targetItem1=99; + getIndexOfTargetItem(lstItems,targetItem1); + + } + + private static void getIndexOfTargetItem(List lstItems, int targetItem) { + int resultPostion = -1; + for (int i : lstItems) { + resultPostion = (i == targetItem) ? lstItems.indexOf(i) : resultPostion; + } + if (resultPostion != -1) { + System.out.println("\nThe traget Item : " + targetItem + " found at : " + resultPostion + ""); + } else { + System.out.println("\nItem not found!.."); + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/GetKeyForTargetItem.java b/src/main/java/com/udemy/sdetintcod/section4/GetKeyForTargetItem.java new file mode 100644 index 0000000..c7ac3b8 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/GetKeyForTargetItem.java @@ -0,0 +1,42 @@ +package com.udemy.sdetintcod.section4; +import java.util.HashMap; +import java.util.Map; + +public class GetKeyForTargetItem { + + public static void main(String[] args) { + Map capitalMap=new HashMap<>(); + capitalMap.put("HYD","Telengan"); + capitalMap.put("Vizak","Andharpradesh"); + capitalMap.put("Chennai","Tamil Nadu"); + capitalMap.put("Mumbai","Maharshtra"); + capitalMap.put("Kolkata","West Bengal"); + capitalMap.put("Kathmandu","Nepal"); + capitalMap.put("POK","Pakisthan"); + + String strTarget="West Bengal"; + getKeyForTragetItem(capitalMap,strTarget); + + String str2Target="Atif"; + getKeyForTragetItem(capitalMap,str2Target); + } + + private static void getKeyForTragetItem(Map capitalMap, String strTarget) { + boolean statusFlg = false; + for (Map.Entry entry : capitalMap.entrySet()) { + String key = entry.getKey(); + String val = entry.getValue(); + if (val.equalsIgnoreCase(strTarget)) { + System.out.println("\nThe value : '"+strTarget+"' present at key : "+key+""); + statusFlg=true; + break; + } + } + + if (!statusFlg) { + System.out.println("\nUnable to get the key!!.."); + } + + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/GetKthSmallestElement.java b/src/main/java/com/udemy/sdetintcod/section4/GetKthSmallestElement.java new file mode 100644 index 0000000..29bad95 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/GetKthSmallestElement.java @@ -0,0 +1,20 @@ +package com.udemy.sdetintcod.section4; +import java.util.Arrays; + +public class GetKthSmallestElement { + + public static void main(String[] args) { + int[] numArray = { 7, 10,4,3,20,15 }; + int kthTarget = 4; + getTheKthSmallestElement(numArray, kthTarget); + } + + private static void getTheKthSmallestElement(int[] numArray, int kthTarget) { + // Sort the array Elements + Arrays.sort(numArray); + System.out.println("\nSorted input Array : "+Arrays.toString(numArray)); + int kthSmallTerm=numArray[kthTarget-1]; + System.out.println("\nValues of Kth Smallest element : "+kthSmallTerm); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/MissingNumberFinder.java b/src/main/java/com/udemy/sdetintcod/section4/MissingNumberFinder.java new file mode 100644 index 0000000..759902d --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/MissingNumberFinder.java @@ -0,0 +1,42 @@ +package com.udemy.sdetintcod.section4; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class MissingNumberFinder { + + public static void main(String[] args) { + int[] numArray = {5,6,0,3,3,1,10,20,15}; + System.out.println("\nInput array : " + Arrays.toString(numArray)); + System.out.println("\n********* Missing Elements of Array ***********"); + missingArrayElements(numArray); + } + + private static void missingArrayElements(int[] numArray) { + // Sort the Array Elements : + Arrays.sort(numArray); + int first = numArray[0]; + int last = numArray[numArray.length - 1]; + System.out.println("\nSorted Array Elements : " + Arrays.toString(numArray)); + + List arrList = new ArrayList<>(); + for (int i = first; i <= last; i++) { + if (!containsArrayItems(numArray, i)) { + arrList.add(i); + } + } + System.out.println("\nList of Missing Items : " + arrList); + + } + + private static boolean containsArrayItems(int[] numArr, int target) { + boolean flag = false; + for (int items : numArr) { + if (items == target) { + flag = true; + } + } + return flag; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/SearchForSpecificElementLinkedHm.java b/src/main/java/com/udemy/sdetintcod/section4/SearchForSpecificElementLinkedHm.java new file mode 100644 index 0000000..db3ed97 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/SearchForSpecificElementLinkedHm.java @@ -0,0 +1,33 @@ +package com.udemy.sdetintcod.section4; +import java.util.LinkedHashMap; +import java.util.Map; + +public class SearchForSpecificElementLinkedHm { + + public static void main(String[] args) { + Map strLnkHm = null; + String strTargetValue="Aslam"; + checkValuesStatusIntoMap(strLnkHm,strTargetValue); + String strTargetValue1="Disha"; + checkValuesStatusIntoMap(strLnkHm,strTargetValue1); + } + + private static void checkValuesStatusIntoMap(Map strLnkHm,String strTargetValue) { + strLnkHm=new LinkedHashMap<>(); + strLnkHm.put(101,"Abhinay"); + strLnkHm.put(102,"Atif"); + strLnkHm.put(105,"Disha"); + strLnkHm.put(108,"Subham"); + strLnkHm.put(110,"Rupam"); + strLnkHm.put(120,"Susmita"); + strLnkHm.put(140,"KK"); + System.out.println("\nEmployee Directory : "+strLnkHm); + if(strLnkHm.containsValue(strTargetValue)) { + System.out.println("\nValue : "+strTargetValue+" present."); + } else { + System.out.println("\nValue not found!.."); + } + } + + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/SearchForSpecificElementTreeMp.java b/src/main/java/com/udemy/sdetintcod/section4/SearchForSpecificElementTreeMp.java new file mode 100644 index 0000000..a8cbe0c --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/SearchForSpecificElementTreeMp.java @@ -0,0 +1,33 @@ +package com.udemy.sdetintcod.section4; +import java.util.Map; +import java.util.TreeMap; + +public class SearchForSpecificElementTreeMp { + + public static void main(String[] args) { + Map strLnkHm = null; + String strTargetValue="Aslam"; + checkValuesStatusIntoMap(strLnkHm,strTargetValue); + String strTargetValue1="Disha"; + checkValuesStatusIntoMap(strLnkHm,strTargetValue1); + } + + private static void checkValuesStatusIntoMap(Map strTreeMp,String strTargetValue) { + strTreeMp=new TreeMap<>(); + strTreeMp.put(101,"Abhinay"); + strTreeMp.put(106,"Atif"); + strTreeMp.put(155,"Disha"); + strTreeMp.put(108,"Subham"); + strTreeMp.put(120,"Rupam"); + strTreeMp.put(20,"Susmita"); + strTreeMp.put(140,"KK"); + System.out.println("\nEmployee Directory : "+strTreeMp); + if(strTreeMp.containsValue(strTargetValue)) { + System.out.println("\nValue : "+strTargetValue+" present."); + } else { + System.out.println("\nValue not found!.."); + } + } + + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/SortAndKeepUniques.java b/src/main/java/com/udemy/sdetintcod/section4/SortAndKeepUniques.java new file mode 100644 index 0000000..b18bd4f --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/SortAndKeepUniques.java @@ -0,0 +1,29 @@ +package com.udemy.sdetintcod.section4; +import java.util.Arrays; +import java.util.Set; +import java.util.TreeSet; + +public class SortAndKeepUniques { + + public static void main(String[] args) { + double[] numericArray={0.49,-4.009,55,33,4,0,7,33,5,2,1,4,10,30,10}; + System.out.println("\nInput number array : "+Arrays.toString(numericArray)); + System.out.println("\nResultant Sorted Array : "+Arrays.toString(numericArrayItems(numericArray))); + } + + + /** + * Using TreeSet inbuilt sorted property + * + * @param strWeekArray + * @return + */ + private static Double[] numericArrayItems(double[] numArray) { + Set sortedSet = new TreeSet<>(); + for (Double strItems : numArray) { + sortedSet.add(strItems); + } + return sortedSet.toArray(new Double[0]); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/SumOfArrayElements.java b/src/main/java/com/udemy/sdetintcod/section4/SumOfArrayElements.java new file mode 100644 index 0000000..5abab4e --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section4/SumOfArrayElements.java @@ -0,0 +1,20 @@ +package com.udemy.sdetintcod.section4; +import java.util.Arrays; + +public class SumOfArrayElements { + + public static void main(String[] args) { + double[] numArray={1,2,6,7,8,9,4,5}; + doSumOfArrayElements(numArray); + } + + private static void doSumOfArrayElements(double[] numArray) { + System.out.println("\nInput Array : " + Arrays.toString(numArray)); + double sum = 0.0; + for (double numItems : numArray) { + sum += numItems; + } + System.out.println("\nSum of All elements : " + sum); + } + +} \ No newline at end of file From 175501951ff3f304b40adedbdcb74761a141d7e9 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Tue, 17 Mar 2026 17:40:59 +0530 Subject: [PATCH 07/18] added latest sec-5 array manipulations programs for SDET. --- .../section5/FindMissingNumbersOfArray.java | 45 ++++++++++++++ .../section5/IntersectionOfTwoArrays.java | 49 ++++++++++++++++ .../section5/MoveAllZerosToRightOrLeft.java | 58 +++++++++++++++++++ .../section5/RemoveGreaterItemsfromLists.java | 37 ++++++++++++ .../section5/ShowArrayInReverseOrder.java | 21 +++++++ 5 files changed, 210 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section5/FindMissingNumbersOfArray.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/IntersectionOfTwoArrays.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/MoveAllZerosToRightOrLeft.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/RemoveGreaterItemsfromLists.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/ShowArrayInReverseOrder.java diff --git a/src/main/java/com/udemy/sdetintcod/section5/FindMissingNumbersOfArray.java b/src/main/java/com/udemy/sdetintcod/section5/FindMissingNumbersOfArray.java new file mode 100644 index 0000000..a831113 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/FindMissingNumbersOfArray.java @@ -0,0 +1,45 @@ +package com.udemy.sdetintcod.section5; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class FindMissingNumbersOfArray { + + public static void main(String[] args) { + int[] inpNumArr={8, 2, 4, 5, 3, 7, 1}; + findMissingNumbersOfArray(inpNumArr); + + int[] inpNumArr2={4,3,2,7,8,2,3,1}; + findMissingNumbersOfArray(inpNumArr2); + } + + private static void findMissingNumbersOfArray(int[] inpNumArr) { + List missingItems = new ArrayList<>(); + + // For optimization sort the array + Arrays.sort(inpNumArr); + System.out.println("\nInput number Array : " + Arrays.toString(inpNumArr)); + int first = inpNumArr[0]; + int last = inpNumArr[inpNumArr.length - 1]; + for (int i = first; i <= last; i++) { + // Pushing non-avaible items to array List + if (!isMissingItemContains(inpNumArr, i)) { + missingItems.add(i); + } + } + if (missingItems.size() > 0) { + System.out.println("\nResultant Missing Items : " +Arrays.toString(missingItems.toArray(new Integer[0]))); + } else { + System.out.println("\nNo missing!.. items.."); + } + } + + private static boolean isMissingItemContains(int[] missingItems, int i) { + boolean resultFlag = false; + for (int items : missingItems) { + resultFlag = (items == i) ? true : resultFlag; + } + return resultFlag; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/IntersectionOfTwoArrays.java b/src/main/java/com/udemy/sdetintcod/section5/IntersectionOfTwoArrays.java new file mode 100644 index 0000000..2e9f05f --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/IntersectionOfTwoArrays.java @@ -0,0 +1,49 @@ +package com.udemy.sdetintcod.section5; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class IntersectionOfTwoArrays { + + public static void main(String[] args) { + int[] arrayA= {1,2,2,1}; + int[] arrayB= {2,2}; + getIntersectionsOfArrayElements(arrayA,arrayB); + + int[] arrayA2= {4,9,5}; + int[] arrayB2= {9,4,9,8,4}; + getIntersectionsOfArrayElements(arrayA2,arrayB2); + + } + + private static void getIntersectionsOfArrayElements(int[] arrayA, int[] arrayB) { + System.out.println("\nArray A : "+Arrays.toString(arrayA)); + System.out.println("\nArray B : "+Arrays.toString(arrayB)); + List lstItems=new ArrayList<>(); + + for (int outLoopItem : arrayA) { + int outCurrentItem = outLoopItem; + for (int innterLoopItem : arrayB) { + int innerCurrentItem = innterLoopItem; + if (outCurrentItem == innterLoopItem) { + //Only the Non-Seen Items to be added to arrayList + if(!isListItemContains(lstItems,innerCurrentItem)) { + lstItems.add(innerCurrentItem); + break; + } + } + } + } + System.out.println("\nIntersected Array : "+Arrays.toString(lstItems.toArray(new Integer[0]))); + + } + + private static boolean isListItemContains(List lstItems, int innerCurrentItem) { + boolean resultFlag = false; + for (Integer items : lstItems) { + resultFlag = (items == innerCurrentItem) ? true : resultFlag; + } + return resultFlag; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/MoveAllZerosToRightOrLeft.java b/src/main/java/com/udemy/sdetintcod/section5/MoveAllZerosToRightOrLeft.java new file mode 100644 index 0000000..66a7d05 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/MoveAllZerosToRightOrLeft.java @@ -0,0 +1,58 @@ +package com.udemy.sdetintcod.section5; +import java.util.Arrays; + +public class MoveAllZerosToRightOrLeft { + + public static void main(String[] args) { + int[] inpNumArray={0,1,9,0,2,4,0,3}; + System.out.println("\nInput numbers array : "+Arrays.toString(inpNumArray)); + //Moving all zero's to right + moveAllZerosToRightEnd(inpNumArray); + System.out.println("\nUpdated array post moving to zero's to right : "+Arrays.toString(inpNumArray)); + int[] inpNumArray2={0,1,9,0,2,4,0,3}; + //Moving all zero's to left + moveAllZerosToLeftEnd(inpNumArray2); + System.out.println("\nUpdated array post moving to zero's to left : "+Arrays.toString(inpNumArray2)); + } + + private static void moveAllZerosToLeftEnd(int[] inpNumArray) { + int itrLen=inpNumArray.length-1; + // Pointer to the position where the next non-zero element should be placed (starting from the end) + int rightIndex = itrLen; + + // Iterate through the array from the end + for (int j = itrLen; j>=0; j--) { + int currentItem = inpNumArray[j]; + // If the current element is non-zero, place it at the writePointer position + if (currentItem != 0) { + inpNumArray[rightIndex] = currentItem; + // Move the write pointer to the left + rightIndex--; + } + } + + // Fill the remaining positions at the front with zeros + while (rightIndex>=0) { + inpNumArray[rightIndex]=0; + rightIndex--; + } + } + + + private static void moveAllZerosToRightEnd(int[] inpNumArray) { + int nonZeroIndex = 0; + for (int i = 0; i < inpNumArray.length; i++) { + int currentItem = inpNumArray[i]; + if (currentItem != 0) { + int tempItem = currentItem; + inpNumArray[i] = inpNumArray[nonZeroIndex]; + inpNumArray[nonZeroIndex] = tempItem; + + // Move forward the nonZeroIndex + nonZeroIndex++; + } + } + } + + +} diff --git a/src/main/java/com/udemy/sdetintcod/section5/RemoveGreaterItemsfromLists.java b/src/main/java/com/udemy/sdetintcod/section5/RemoveGreaterItemsfromLists.java new file mode 100644 index 0000000..a501098 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/RemoveGreaterItemsfromLists.java @@ -0,0 +1,37 @@ +package com.udemy.sdetintcod.section5; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +public class RemoveGreaterItemsfromLists { + + public static void main(String[] args) { + List inpLstItems=new ArrayList<>(); + inpLstItems.add(50); + inpLstItems.add(90); + inpLstItems.add(120); + inpLstItems.add(20); + inpLstItems.add(6); + inpLstItems.add(12); + inpLstItems.add(2); + inpLstItems.add(183); + inpLstItems.add(400); + inpLstItems.add(29); + System.out.println("\nInput List : "+inpLstItems); + int targetLimit=10; + System.out.println("\nSet the limit value : "+targetLimit); + removeGreaterValuesOfList(inpLstItems,targetLimit); + System.out.println("\nUpdated List post in-memory operations : "+inpLstItems); + } + + private static void removeGreaterValuesOfList(List inpLstItems, int targetLimit) { + Iterator lstItr = inpLstItems.iterator(); + while (lstItr.hasNext()) { + int currentItem = lstItr.next(); + if (currentItem > targetLimit) { + lstItr.remove(); + } + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/ShowArrayInReverseOrder.java b/src/main/java/com/udemy/sdetintcod/section5/ShowArrayInReverseOrder.java new file mode 100644 index 0000000..8046d7e --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/ShowArrayInReverseOrder.java @@ -0,0 +1,21 @@ +package com.udemy.sdetintcod.section5; +import java.util.Arrays; + +public class ShowArrayInReverseOrder { + + public static void main(String[] args) { + double[] numArray = { 1, 2, 105, 6, 7, 8, 99, 9, 3, 400, 5, 390, 200 }; + doArrayReversal(numArray); + } + + private static void doArrayReversal(double[] numArray) { + System.out.println("\nInput array : "+Arrays.toString(numArray)); + + System.out.println("\nOutput reversed array Elements: "); + for (int i = numArray.length-1; i>=0; i--) { + System.out.print(numArray[i]+", "); + } + + } + +} \ No newline at end of file From f98cd28b7d7cfef247ac772efdd87b3f3115beee Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Mon, 23 Mar 2026 14:08:05 +0530 Subject: [PATCH 08/18] latest problems solutions of arrays - with 2 pointers+1 DP Udemy SDET Sec-5 --- .../section5/CheckQualityOfTwoArrays.java | 43 ++++++++++++ .../section5/CommonElementsOfTwoArrays.java | 32 +++++++++ .../section5/Find2ndMinAnd2ndMaxOfArray.java | 56 ++++++++++++++++ .../section5/FindMajorityElements.java | 52 ++++++++++++++ .../section5/LinearSearchToArray.java | 40 +++++++++++ .../section5/LongestCommonSubSequenceLen.java | 47 +++++++++++++ .../sdetintcod/section5/MergeSortedArray.java | 56 ++++++++++++++++ .../section5/MoveAllNegativesToLeftEnd.java | 55 +++++++++++++++ .../section5/RotateByKthPosition.java | 67 +++++++++++++++++++ 9 files changed, 448 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section5/CheckQualityOfTwoArrays.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/CommonElementsOfTwoArrays.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/Find2ndMinAnd2ndMaxOfArray.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/FindMajorityElements.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/LinearSearchToArray.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/LongestCommonSubSequenceLen.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/MergeSortedArray.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/MoveAllNegativesToLeftEnd.java create mode 100644 src/main/java/com/udemy/sdetintcod/section5/RotateByKthPosition.java diff --git a/src/main/java/com/udemy/sdetintcod/section5/CheckQualityOfTwoArrays.java b/src/main/java/com/udemy/sdetintcod/section5/CheckQualityOfTwoArrays.java new file mode 100644 index 0000000..a039ee7 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/CheckQualityOfTwoArrays.java @@ -0,0 +1,43 @@ +package com.udemy.sdetintcod.section5; +import java.util.Arrays; + +public class CheckQualityOfTwoArrays { + + public static void main(String[] args) { + int[] arrayA={1, 2, 3, 4, 5}; + int[] arrayB={1, 2, 3, 4, 5}; + System.out.println("\nCheck Quality status : "+getQualityStatusOfArrayElements(arrayA,arrayB)); + + int c[] = { 10, 20, 30 }; + int d[] = { 45, 50, 55, 60, 65 }; + + System.out.println("\nCheck Quality status : "+getQualityStatusOfArrayElements(c,d)); + System.out.println("************* Evaluation using Arrays in-build methdo ******************"); + boolean flagVal=Arrays.equals(arrayA, arrayB); + String statusFld=(flagVal==true)?"Equals.":"Not-Equals."; + System.out.println("\nCheck Quality status using in-built method : "+statusFld); + + boolean flag1Val=Arrays.equals(c, d); + String status1Fld=(flag1Val==true)?"Equals.":"Not-Equals."; + System.out.println("\nCheck Quality status using in-built method : "+status1Fld); + } + + private static String getQualityStatusOfArrayElements(int[] arrayA, int[] arrayB) { + System.out.println("\nInput array A : "+Arrays.toString(arrayA)); + System.out.println("\nInput array B : "+Arrays.toString(arrayB)); + String strResult = "Equals"; + if (arrayA.length == arrayB.length) { + for (int i = 0; i < arrayA.length; i++) { + for (int j = 0; j < arrayB.length; j++) { + if (arrayA[i] != arrayB[i]) { + strResult = "Not Equals."; + } + } + } + } else { + strResult = "Not Equals."; + } + return strResult; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/CommonElementsOfTwoArrays.java b/src/main/java/com/udemy/sdetintcod/section5/CommonElementsOfTwoArrays.java new file mode 100644 index 0000000..36910fc --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/CommonElementsOfTwoArrays.java @@ -0,0 +1,32 @@ +package com.udemy.sdetintcod.section5; +import java.util.Arrays; + +public class CommonElementsOfTwoArrays { + + public static void main(String[] args) { + int[] arrayA={1,2,3,4,5}; + int[] arrayB={4,5,6,7,8}; + getCommonArrayElements(arrayA,arrayB); + + int[] array2A={1, 1, 1}; + int[] array2B={1, 1, 1, 1, 1}; + getCommonArrayElements(array2A,array2B); + + + } + + private static void getCommonArrayElements(int[] arrayA, int[] arrayB) { + System.out.println("\nArray A : " + Arrays.toString(arrayA)); + System.out.println("\nArray B : " + Arrays.toString(arrayB)); + System.out.println("\nCommon Array Elements : "); + for (int i = 0; i < arrayA.length; i++) { + for (int j = 0; j < arrayB.length; j++) { + if (arrayA[i] == arrayB[j]) { + System.out.print(arrayA[i] + ", "); + break; + } + } + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/Find2ndMinAnd2ndMaxOfArray.java b/src/main/java/com/udemy/sdetintcod/section5/Find2ndMinAnd2ndMaxOfArray.java new file mode 100644 index 0000000..4b2cca8 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/Find2ndMinAnd2ndMaxOfArray.java @@ -0,0 +1,56 @@ +package com.udemy.sdetintcod.section5; +import java.util.Arrays; +import java.util.Scanner; + +public class Find2ndMinAnd2ndMaxOfArray { + + public static void main(String[] args) { + Scanner scInp = new Scanner(System.in); + System.out.print("\nEnter the size of input array : "); + int sizeOfArray = scInp.nextInt(); + find2ndMaxAnd2ndMinFromArray(sizeOfArray); + scInp.close(); + } + + private static void find2ndMaxAnd2ndMinFromArray(int sizeOfArray) { + Scanner scInp = new Scanner(System.in); + int[] inptArray = new int[sizeOfArray]; + System.out.print("Enter the array elements : "); + for (int i = 0; i < inptArray.length; i++) { + inptArray[i] = scInp.nextInt(); + } + System.out.println("\nInput number array : " + Arrays.toString(inptArray)); + //Assigning the Maximum integer value to minNum , hence any number should less than that. + int minNum=Integer.MAX_VALUE; + //Assigning the Maximum integer value to secNdMin , hence any number should less than that. + int secNdMin=Integer.MAX_VALUE; + + //Assigning the Minimum integer value to maxNum , hence any number should greater than that. + int maxNum=Integer.MIN_VALUE; + //Assigning the Minimum integer value to secNdMax , hence any number should greater than that. + int secNdMax=Integer.MIN_VALUE; + + for (int i : inptArray) { + if (i < minNum) { + secNdMin = minNum; + minNum = i; + } else if (i < secNdMin && minNum < secNdMin) { + secNdMin = i; + } + + if (i > maxNum) { + secNdMax = maxNum; + maxNum = i; + } else if (i > secNdMax && maxNum > secNdMax) { + secNdMax = i; + } + } + System.out.println("\nValue of Min : "+minNum); + System.out.println("\nValue of 2nd Min : "+secNdMin); + + System.out.println("\nValue of Max : "+maxNum); + System.out.println("\nValue of 2nd Max : "+secNdMax); + scInp.close(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/FindMajorityElements.java b/src/main/java/com/udemy/sdetintcod/section5/FindMajorityElements.java new file mode 100644 index 0000000..6ef4717 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/FindMajorityElements.java @@ -0,0 +1,52 @@ +package com.udemy.sdetintcod.section5; +import java.util.Arrays; +import java.util.Scanner; + +public class FindMajorityElements { + + public static void main(String[] args) { + Scanner scInp=new Scanner(System.in); + System.out.print("\nEnter the size of input array : "); + int sizeOfArray=scInp.nextInt(); + getMejorityElement(sizeOfArray); + scInp.close(); + } + + private static void getMejorityElement(int sizeOfArray) { + Scanner scInp = new Scanner(System.in); + int[] inptArray = new int[sizeOfArray]; + System.out.println("\nEnter the array elements : \n"); + for (int i = 0; i < inptArray.length; i++) { + inptArray[i] = scInp.nextInt(); + } + System.out.println("\nInput number array : " + Arrays.toString(inptArray)); + int majoCandid = -1; + int count = 0; + int halfLen = (inptArray.length / 2); + System.out.println("\nHalf Length of input array : " + halfLen); + // Traverse to the array to find the majority element. + for (int itNum : inptArray) { + if(count == 0) { + majoCandid=itNum; + } + // Increase or Decrease the majority element + count += (majoCandid == itNum) ? 1 : -1; + } + count = 0; + // verification of majority element + for (int itNum : inptArray) { + if(majoCandid == itNum) { + count++; + } + } + + if (count > halfLen) { + System.out.println("\nMejority element found : " + majoCandid); + } else { + System.out.println("\nMejority element No!!.. found"); + } + + scInp.close(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/LinearSearchToArray.java b/src/main/java/com/udemy/sdetintcod/section5/LinearSearchToArray.java new file mode 100644 index 0000000..5de0220 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/LinearSearchToArray.java @@ -0,0 +1,40 @@ +package com.udemy.sdetintcod.section5; +import java.util.Arrays; +import java.util.Scanner; + +public class LinearSearchToArray { + + public static void main(String[] args) { + Scanner scInp=new Scanner(System.in); + System.out.print("\nEnter the size of input array : "); + int sizeOfArray=scInp.nextInt(); + System.out.print("\nEnter the target element : "); + int target=scInp.nextInt(); + performLinearSearch(sizeOfArray,target); + scInp.close(); + } + + private static void performLinearSearch(int sizeOfArray, int target) { + Scanner scInp = new Scanner(System.in); + int[] inptArray = new int[sizeOfArray]; + System.out.println("\nEnter the array elements : "); + for (int i = 0; i < inptArray.length; i++) { + inptArray[i] = scInp.nextInt(); + } + System.out.println("\nInput number array : "+Arrays.toString(inptArray)); + int result = -1; + for (int i = 0; i < inptArray.length; i++) { + if (inptArray[i] == target) { + result = i; + break; + } + } + if (result != -1) { + System.out.println("\nElement found in the array at : " + result); + } else { + System.out.println("\nElement not found!!.."); + } + scInp.close(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/LongestCommonSubSequenceLen.java b/src/main/java/com/udemy/sdetintcod/section5/LongestCommonSubSequenceLen.java new file mode 100644 index 0000000..85eb00a --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/LongestCommonSubSequenceLen.java @@ -0,0 +1,47 @@ +package com.udemy.sdetintcod.section5; + +public class LongestCommonSubSequenceLen { + + public static void main(String[] args) { + int[] arrayA={1,3,4,5,6,7}; + int[] arrayB={3,5,6,8}; + int len=getLengthOfLCS(arrayA,arrayB); + System.out.println("\nLength of Longest common sub-sequence : "+len); + + int[] array2A={10,9,2,5,3,7,101,18}; + int[] array2B={2,3,7,101}; + int len2=getLengthOfLCS(array2A,array2B); + System.out.println("\nLength of Longest common sub-sequence : "+len2); + + + } + + private static int getLengthOfLCS(int[] arrayA, int[] arrayB) { + //Step-1: Get the length of each input array + int m=arrayA.length; + int n=arrayB.length; + + //Step-2:Dynamic programming 2D array initialization for lengths + int dynArr[][]=new int[m+1][n+1]; + + //Step-3:Fillout the 2D dynArr[][] array by traversing the arrayA & arrayB + //Outer loop to traverse to arrayA + for (int i = 1; i <= m; i++) { + // Inner loop to traverse to arrayB + for (int j = 1; j <= n; j++) { + // if the Current elements of both arrays element matches then added 1 to diagonal element dynArr[i-1][j-1] which will part of LCS + if (arrayA[i-1]==arrayB[j-1]) { + dynArr[i][j]=dynArr[i-1][j-1]+1; + } else { + //Step-4:Evaluate the maximum between top dynArr[i][j-1] and left item dynArr[i-1][j] + dynArr[i][j]=Math.max(dynArr[i][j-1],dynArr[i-1][j]); + } + + } + } + + //Returning the last final element which is the length of LCS + return dynArr[m][n]; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/MergeSortedArray.java b/src/main/java/com/udemy/sdetintcod/section5/MergeSortedArray.java new file mode 100644 index 0000000..653cc49 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/MergeSortedArray.java @@ -0,0 +1,56 @@ +package com.udemy.sdetintcod.section5; + +public class MergeSortedArray { + + public static void main(String[] args) { + int[] arrayA={1,2,4,6,9}; + int[] arrayB={7,10,11,0,-2,5,33,3,99}; + performMergeSort(arrayA,arrayB); + } + + private static void performMergeSort(int[] arrayA, int[] arrayB) { + int arrLenA = arrayA.length; + int arrLenB = arrayB.length; + // Initialization of resultant merged array + int[] resultArr = new int[arrLenA + arrLenB]; + + // pointer for 1st array. + int i = 0; + // pointer for 2nd array. + int j = 0; + // pointer for resultant array - keep track of current position. + int k = 0; + + while (i < arrLenA && j < arrLenB) { + + if(arrayA[i] < arrayB[j]) { + resultArr[k] = arrayA[i]; + //Move next number to arrayA + i++; + } + else { + resultArr[k] = arrayB[j]; + //Move next number to arrayB + j++; + } + //In either way the resultant array has to filled as one more spot is available. + k++; + } + + //if 1st array has left over elements. + while (i < arrLenA) { + resultArr[k++]=arrayA[i++]; + } + + //if 2nd array has left over elements. + while (j < arrLenB) { + resultArr[k++]=arrayB[j++]; + } + + for (int k2 = 0; k2 < resultArr.length; k2++) { + System.out.print(resultArr[k2]+", "); + } + + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section5/MoveAllNegativesToLeftEnd.java b/src/main/java/com/udemy/sdetintcod/section5/MoveAllNegativesToLeftEnd.java new file mode 100644 index 0000000..2301b5f --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section5/MoveAllNegativesToLeftEnd.java @@ -0,0 +1,55 @@ +package com.udemy.sdetintcod.section5; +import java.util.Arrays; +import java.util.Scanner; + +public class MoveAllNegativesToLeftEnd { + + public static void main(String[] args) { + Scanner scInp=new Scanner(System.in); + System.out.print("\nEnter the size of input array : "); + int sizeOfArray=scInp.nextInt(); + moveAllNegativeNumbersToLeft(sizeOfArray); + scInp.close(); + } + + /** + * Two pointer approach to traverse array elements + * @param sizeOfArray + */ + private static void moveAllNegativeNumbersToLeft(int sizeOfArray) { + Scanner scInp = new Scanner(System.in); + int[] inptArray = new int[sizeOfArray]; + System.out.println("\nEnter the array elements : \n"); + for (int i = 0; i < inptArray.length; i++) { + inptArray[i] = scInp.nextInt(); + } + System.out.println("\nInput number array : "+Arrays.toString(inptArray)); + //start index. + int left=0; + //End Index. + int right=inptArray.length-1; + + while (left<=right) { + + //Move left pointer to right if getting negatives number at the beginning it self. + while (left0 && inptArray[right]>0) { + right--; + } + + //Swap array elements if still left index is before right index. + if (left Date: Fri, 24 Apr 2026 20:06:40 +0530 Subject: [PATCH 09/18] sec-6: problem solvings of Array manipulations with Sliding-window,two-pointer & binary seachings. --- .../sdetintcod/section6/BinarySeachSpace.java | 47 +++++++++++++ .../FindElementRotatedSortedArray.java | 67 +++++++++++++++++++ .../FindLengthOfLongestSubString.java | 47 +++++++++++++ .../GenerateAllPossibleSubStrings.java | 27 ++++++++ ...GetLastOccuranceOfSortedArrayElements.java | 62 +++++++++++++++++ 5 files changed, 250 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section6/BinarySeachSpace.java create mode 100644 src/main/java/com/udemy/sdetintcod/section6/FindElementRotatedSortedArray.java create mode 100644 src/main/java/com/udemy/sdetintcod/section6/FindLengthOfLongestSubString.java create mode 100644 src/main/java/com/udemy/sdetintcod/section6/GenerateAllPossibleSubStrings.java create mode 100644 src/main/java/com/udemy/sdetintcod/section6/GetLastOccuranceOfSortedArrayElements.java diff --git a/src/main/java/com/udemy/sdetintcod/section6/BinarySeachSpace.java b/src/main/java/com/udemy/sdetintcod/section6/BinarySeachSpace.java new file mode 100644 index 0000000..88c5703 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section6/BinarySeachSpace.java @@ -0,0 +1,47 @@ +package com.udemy.sdetintcod.section6; +import java.util.Scanner; + +public class BinarySeachSpace { + + public static void main(String[] args) { + Scanner scin = new Scanner(System.in); + int[] numArry = { 3, 5, 7, 8, 10, 12, 15 }; + System.out.println("\nEnter the Target element : "); + int target = scin.nextInt(); + + int resultIndex = doBinarySearchToArray(numArry, target); + if (resultIndex != -1) { + System.out.println("\nTraget item : " + numArry[resultIndex] + " found at : " + resultIndex + ""); + } else { + System.out.println("\nItem not found!.."); + } + scin.close(); + } + + + private static int doBinarySearchToArray(int[] numArry, int target) { + int result = -1; + int left = 0; + int right = numArry.length - 1; + + while (left <= right) { + // Compute mid index + int midIndex = left + (right - left) / 2; + + if (numArry[midIndex] == target) { + result = midIndex; + } + + if (numArry[midIndex] < target) { + // search to right half by adjusting the 'left' index + left = midIndex + 1; + } else { + // search to left half by adjusting the 'right' index + right = midIndex - 1; + } + + } + return result; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section6/FindElementRotatedSortedArray.java b/src/main/java/com/udemy/sdetintcod/section6/FindElementRotatedSortedArray.java new file mode 100644 index 0000000..22c5a1b --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section6/FindElementRotatedSortedArray.java @@ -0,0 +1,67 @@ +package com.udemy.sdetintcod.section6; +import java.util.Scanner; + +public class FindElementRotatedSortedArray { + + public static void main(String[] args) { + Scanner scin = new Scanner(System.in); + int[] numArry = { 4, 5, 6, 7, 0, 1, 2 }; + System.out.println("\nEnter the Target element : "); + int target = scin.nextInt(); + + int resultIndex = findElementFromRotatedSortedArray(numArry, target); + if (resultIndex != -1) { + System.out.println("\n Traget item : " + numArry[resultIndex] + " found at : " + resultIndex + ""); + } else { + System.out.println("\nItem not found!.."); + } + scin.close(); + } + + /** + * Using two pointer approach. + * @param numArry + * @param target + * @return + * + */ + private static int findElementFromRotatedSortedArray(int[] numArry, int target) { + // Initialize start index. + int left = 0; + // Initialize right index. + int right = numArry.length - 1; + + while (left <= right) { + // Evaluate the mid-index + int midIndex = left + (right - left) / 2; + + if (numArry[midIndex] == target) { + // we found the index to store into result + return midIndex; + } + + //Helps to identify left half or right half is sorted. + if (numArry[left] <= numArry[midIndex]) { + if (target>=numArry[left] && targetnumArry[midIndex]) { + // Continue searching the right half by adjusting the 'left' index + left = midIndex + 1; + } else { + // Continue searching the left half by adjusting the 'right' index + right = midIndex - 1; + } + } + + } + return -1; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section6/FindLengthOfLongestSubString.java b/src/main/java/com/udemy/sdetintcod/section6/FindLengthOfLongestSubString.java new file mode 100644 index 0000000..ae73419 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section6/FindLengthOfLongestSubString.java @@ -0,0 +1,47 @@ +package com.udemy.sdetintcod.section6; +import java.util.HashMap; +import java.util.Scanner; + +public class FindLengthOfLongestSubString { + + public static void main(String[] args) { + Scanner scin = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strText = scin.nextLine(); + System.out.println("\nCalculated length of the longest sub-string : "+getLengthOfLongestSubString(strText)); + scin.close(); + } + + + /** + * Sliding window with HashMap + * @param strText + * @return + * + */ + private static int getLengthOfLongestSubString(String strText) { + int maxLen = 0; + // Declaration of hasMap to store keep track recent index of characters + HashMap hashMapCont = new HashMap<>(); + //start index of sliding window + int startIndex = 0; + + // Iterate through each character from input text. + for (int i = 0; i < strText.length(); i++) { + char charItems = strText.charAt(i); + + //If character is already into window , update the start position + if (hashMapCont.containsKey(charItems) && hashMapCont.get(charItems) >= startIndex) { + // update the startIndex to the right of the last occurrence + startIndex = hashMapCont.get(charItems) + 1; + } + // Keep track of current character with its associated most recent index of Integer value + hashMapCont.put(charItems, i); + + // Evaluate the length of current window and update the maxLen + maxLen = Math.max(maxLen, i - startIndex + 1); + } + return maxLen; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section6/GenerateAllPossibleSubStrings.java b/src/main/java/com/udemy/sdetintcod/section6/GenerateAllPossibleSubStrings.java new file mode 100644 index 0000000..f55920b --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section6/GenerateAllPossibleSubStrings.java @@ -0,0 +1,27 @@ +package com.udemy.sdetintcod.section6; +import java.util.Scanner; + +public class GenerateAllPossibleSubStrings { + + public static void main(String[] args) { + Scanner scin = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strText = scin.nextLine(); + System.out.println("************************************"); + populatePossibleSubStringsFromInput(strText); + scin.close(); + } + + private static void populatePossibleSubStringsFromInput(String strText) { + int strLen = strText.length(); + // Outer loop to traverse each characters + for (int i = 0; i < strLen; i++) { + // Inner loop to traverse next items after ith position till the inclusive of + // input text length + for (int j = i + 1; j <=strLen; j++) { + System.out.print(" " + strText.substring(i, j)); + } + } + } + +} diff --git a/src/main/java/com/udemy/sdetintcod/section6/GetLastOccuranceOfSortedArrayElements.java b/src/main/java/com/udemy/sdetintcod/section6/GetLastOccuranceOfSortedArrayElements.java new file mode 100644 index 0000000..f906a37 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section6/GetLastOccuranceOfSortedArrayElements.java @@ -0,0 +1,62 @@ +package com.udemy.sdetintcod.section6; +import java.util.Scanner; + +/** + * Get the position of last occurred element from sorted array + * + */ +public class GetLastOccuranceOfSortedArrayElements { + + public static void main(String[] args) { + Scanner scin = new Scanner(System.in); + int[] numArry = { 5,7,7,8,8,9,9,9,9,10,10,10,10,11 }; + System.out.println("\nEnter the Target element : "); + int target = scin.nextInt(); + + int resultIndex = getPositionOfLastOccuredTragetItem(numArry, target); + if (resultIndex != -1) { + System.out.println("\n Traget item : " + numArry[resultIndex] + " found at : " + resultIndex + ""); + } else { + System.out.println("\nItem not found!.."); + } + scin.close(); + } + + /** + * Two pointer approach to find traget element from sorted array. + * + * @param numArry + * @param target + * @return + * + */ + private static int getPositionOfLastOccuredTragetItem(int[] numArry, int target) { + //to store the last occurred elements index. + int result = -1; + int left = 0; + int right = numArry.length - 1; + + while (left <= right) { + // Compute mid-Index for cut-down the search space + int midIndex = left + (right - left) / 2; + + if (numArry[midIndex] == target) { + //we found the index to store into result + result = midIndex; + //** To continue searching to the right sorted space adjust left index. + left = midIndex + 1; + } + + //Vital step as continue searching left sorted space + if (numArry[midIndex] > target) { + // To continue searching to the left sorted space adjust 'right' index. + right = midIndex - 1; + } else { + // To continue searching to the right sorted space adjust 'left' index. + left = midIndex + 1; + } + } + return result; + } + +} \ No newline at end of file From 81590d1c953938090fa83ef3a233b632caab69f4 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Sat, 2 May 2026 02:28:06 +0530 Subject: [PATCH 10/18] Sec-6: remaining all sliding-window problems added. --- .../section6/FindMaxSumOfSubArraySizeK.java | 58 +++++++++++++++ ...Return1stNegativesListOfSubArraySizeK.java | 71 +++++++++++++++++++ src/main/resources/JavaStringProblems.md | 3 + 3 files changed, 132 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section6/FindMaxSumOfSubArraySizeK.java create mode 100644 src/main/java/com/udemy/sdetintcod/section6/Return1stNegativesListOfSubArraySizeK.java diff --git a/src/main/java/com/udemy/sdetintcod/section6/FindMaxSumOfSubArraySizeK.java b/src/main/java/com/udemy/sdetintcod/section6/FindMaxSumOfSubArraySizeK.java new file mode 100644 index 0000000..1b367bb --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section6/FindMaxSumOfSubArraySizeK.java @@ -0,0 +1,58 @@ +package com.udemy.sdetintcod.section6; +import java.util.Arrays; +import java.util.Scanner; + +/** + * Using sliding window technique : input Array={2,1,5,1,3,2}. Of window size + * K=n + * + * Possible SubArray - [2,1,5] - 8 [1,5,1] - 7 [5,1,3] - 9 - max [1,3,2] - 6 + * + */ +public class FindMaxSumOfSubArraySizeK { + + public static void main(String[] args) { + Scanner scpin=new Scanner(System.in); + int[] inpNumArray={2,1,5,1,3,2}; + System.out.println("\nEnter the sub-arrays window size K : "); + int kthWindowSize=scpin.nextInt(); + System.out.println("\nMax value of Sub-Arrays of window size: "+kthWindowSize+" is : "+findMaxOfSubArrayOfKsize(inpNumArray,kthWindowSize)); + + System.out.println("\nEnter the sub-arrays window size K1 : "); + int kthWindow2Size=scpin.nextInt(); + System.out.println("\nMax value of Sub-Arrays of window size: "+kthWindow2Size+" is : "+findMaxOfSubArrayOfKsize(inpNumArray,kthWindow2Size)); + scpin.close(); + } + + + private static int findMaxOfSubArrayOfKsize(int[] inpNumArray, int kthWindowSize) { + System.out.println("\nInput Array : "+Arrays.toString(inpNumArray)); + // store the max value + int maxResultValue = 0; + // store the value of sub-arrays window Sum + int windSum = 0; + // store 'start' index of window + int start = 0; + + // Traverse over the input array + for (int endIndex = 0; endIndex < inpNumArray.length; endIndex++) { + // Step-1: Compute the 'windSum' + windSum += inpNumArray[endIndex]; + + //VVIP Checking-condition for window size 'kthWindowSize' reached till end. + if (endIndex >= kthWindowSize - 1) { + // Step-2: compute the max result by comparing + maxResultValue = Math.max(maxResultValue, windSum); + + // Step-3: subtract elements which is outside of window + windSum -= inpNumArray[start]; + + // Move forward the 'start' index + start++; + } + + } + return maxResultValue; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section6/Return1stNegativesListOfSubArraySizeK.java b/src/main/java/com/udemy/sdetintcod/section6/Return1stNegativesListOfSubArraySizeK.java new file mode 100644 index 0000000..f0f8463 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section6/Return1stNegativesListOfSubArraySizeK.java @@ -0,0 +1,71 @@ +package com.udemy.sdetintcod.section6; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; +import java.util.Scanner; + +/** + * Using sliding window technique : Find list of 1st Negatives number form + * Sub-Arrays window size K=n for input array : {12,-1,-7,8,15,30,16,28} + * [12,-1,-7] - -1 [-1,-7,8] - -1 [-7,8,15] - -7 [8,15,30] - 0 [15,30,16] - 0 + * [30,16,28] - 0 + * + */ +public class Return1stNegativesListOfSubArraySizeK { + + public static void main(String[] args) { + Scanner scpin = new Scanner(System.in); + int[] inpNumArray = { 12, -1, -7, 8, 15, 30, 16, 28 }; + System.out.println("\nEnter the sub-arrays window size K : "); + int kthWindowSize = scpin.nextInt(); + System.out.println("\nArray of Negatives w.r.t Sub-Arrays window size: " + kthWindowSize + " is : "+ Arrays.toString(arryOfNegativesOfSubArrayOfKsize(inpNumArray, kthWindowSize))); + scpin.close(); + } + + + private static Integer[] arryOfNegativesOfSubArrayOfKsize(int[] inpNumArray, int kthWindowSize) { + System.out.println("\nInput array : " + Arrays.toString(inpNumArray)); + // Initialization of empty list to hold the result. + List resultList = new ArrayList<>(); + // Initialization of empty queue to keep track of negative index. + Queue negIndexQue = new LinkedList<>(); + + // Traverse each element of input array + for (int endIndex = 0; endIndex < inpNumArray.length; endIndex++) { + // Current element of input array + int currentNum = inpNumArray[endIndex]; + //1. check if the array element is negative to fill the 'negIndexQue' with indices + if (currentNum < 0) { + negIndexQue.add(endIndex); + } + + //2. once reached to full window size of 'kthWindowSize' + if (endIndex>=kthWindowSize - 1) + { + //3. checking if head of queue elements using peek() safely populated and should not + // reached till window size. + while (!negIndexQue.isEmpty() && negIndexQue.peek() < endIndex - kthWindowSize + 1) { + // removes element from head of que safely + negIndexQue.poll(); + } + + //step-4: + if (!negIndexQue.isEmpty()) { + // fill the result list with array elements w.r.t negIndexQue negatives indices + // safely populated using peek() + resultList.add(inpNumArray[negIndexQue.peek()]); + } else { + // No Negatives sub-array result to filled with 0 + resultList.add(0); + } + } + + } + //Step-5: return list by converting to array + return resultList.toArray(new Integer[0]); + } + + +} \ No newline at end of file diff --git a/src/main/resources/JavaStringProblems.md b/src/main/resources/JavaStringProblems.md index 5079fa7..f4acaab 100644 --- a/src/main/resources/JavaStringProblems.md +++ b/src/main/resources/JavaStringProblems.md @@ -31,4 +31,7 @@ 28️⃣ Convert CamelCase ➜ snake_case 29️⃣ Find the Lexicographically Smallest String 30️⃣ Remove Consecutive Duplicate Words from a Sentence + 31 InfoSys: Reverse alternate words from input text string. + + \ No newline at end of file From ecb55619a4e5edf085421907d450ef813ddc90bf Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Sat, 9 May 2026 02:20:18 +0530 Subject: [PATCH 11/18] Added sec-9 sliding-windows + StringBuilders manipulations, Recurrsions on string. --- .../section9/FirstNonRepeatedCharsOfText.java | 40 +++++++++++++++++++ .../section9/ReverseEachCharsOfInputText.java | 27 +++++++++++++ ...nlyAlternateWordsEachCharsOfInputText.java | 31 ++++++++++++++ .../section9/TextReversalWithoutLoop.java | 30 ++++++++++++++ 4 files changed, 128 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section9/FirstNonRepeatedCharsOfText.java create mode 100644 src/main/java/com/udemy/sdetintcod/section9/ReverseEachCharsOfInputText.java create mode 100644 src/main/java/com/udemy/sdetintcod/section9/ReverseOnlyAlternateWordsEachCharsOfInputText.java create mode 100644 src/main/java/com/udemy/sdetintcod/section9/TextReversalWithoutLoop.java diff --git a/src/main/java/com/udemy/sdetintcod/section9/FirstNonRepeatedCharsOfText.java b/src/main/java/com/udemy/sdetintcod/section9/FirstNonRepeatedCharsOfText.java new file mode 100644 index 0000000..400b955 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section9/FirstNonRepeatedCharsOfText.java @@ -0,0 +1,40 @@ +package com.udemy.sdetintcod.section9; +import java.util.HashMap; +import java.util.Map; +import java.util.Scanner; + +public class FirstNonRepeatedCharsOfText { + + public static void main(String[] args) { + Scanner scIn=new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInptText=scIn.nextLine(); + Character firstNonRepChar=getFirstNonRepeatedCharecterOfInputText(strInptText); + if (firstNonRepChar!=null) { + System.out.println("\nFirst non-repeated charecter : "+firstNonRepChar); + } else { + System.out.println("\nAll charecters in the input text is repeated."); + } + scIn.close(); + } + + private static Character getFirstNonRepeatedCharecterOfInputText(String strInptText) { + Character result = null; + // Declaration of 'charsMap' to keep track of each Characters of input text. + Map charsMap = new HashMap<>(); + + // Traverse through each character of input text. + for (char chs : strInptText.toCharArray()) { + // If particular 'Character' is seen the increase by 1 the 'value' part of 'charsMap' else keep 1 + charsMap.put(chs, charsMap.getOrDefault(chs, 0) + 1); + } + + // Traverse through the filled 'charsMap' + for (Map.Entry entry : charsMap.entrySet()) { + //if the entry value of charsMap is 1 w.r.t assigned key 'Character' then assign the 'result' else keep the default. + return result = (entry.getValue() == 1) ? entry.getKey() : result; + } + return result; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section9/ReverseEachCharsOfInputText.java b/src/main/java/com/udemy/sdetintcod/section9/ReverseEachCharsOfInputText.java new file mode 100644 index 0000000..f34f386 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section9/ReverseEachCharsOfInputText.java @@ -0,0 +1,27 @@ +package com.udemy.sdetintcod.section9; +import java.util.Scanner; + +public class ReverseEachCharsOfInputText { + + public static void main(String[] args) { + Scanner scIn=new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInptText=scIn.nextLine(); + System.out.println("\nReversed Each Words of input text : "+getWordOfReversedOfInputText(strInptText)); + scIn.close(); + } + + private static String getWordOfReversedOfInputText(String strInptText) { + StringBuilder strBuildObj = new StringBuilder(); + //Linear Time-complexity & space optimized implementation.(Better space complexity O(1) constant) + strBuildObj.append(new StringBuilder(strInptText).reverse()); + + /* //Time & space non-optimized implementation.(specifically poor space complexity) + for (int i = strInptText.length() - 1; i >= 0; i--) { + strBuildObj.append(strInptText.charAt(i)); + } + */ + return strBuildObj.toString(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section9/ReverseOnlyAlternateWordsEachCharsOfInputText.java b/src/main/java/com/udemy/sdetintcod/section9/ReverseOnlyAlternateWordsEachCharsOfInputText.java new file mode 100644 index 0000000..f8951f3 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section9/ReverseOnlyAlternateWordsEachCharsOfInputText.java @@ -0,0 +1,31 @@ +package com.udemy.sdetintcod.section9; +import java.util.Scanner; + +public class ReverseOnlyAlternateWordsEachCharsOfInputText { + + public static void main(String[] args) { + Scanner scIn=new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInptText=scIn.nextLine(); + System.out.println("\nReverse only alternate Words each charecters of input text : "+getOnlyAlternateWordsReverse(strInptText)); + scIn.close(); + } + + private static String getOnlyAlternateWordsReverse(String strInptText) { + String[] wordsArray=strInptText.split(" "); + StringBuilder strBuildObj = new StringBuilder(); + + for (int i = 0; i < wordsArray.length; i++) { + String strEachWords=wordsArray[i]; + if (i%2!=0) { + //Linear Time-complexity & space optimized implementation.(Better space complexity O(1) constant) + strBuildObj.append(new StringBuilder(strEachWords).reverse()).append(" "); + } else { + strBuildObj.append(new StringBuilder(strEachWords)).append(" "); + } + } + + return strBuildObj.toString().trim(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section9/TextReversalWithoutLoop.java b/src/main/java/com/udemy/sdetintcod/section9/TextReversalWithoutLoop.java new file mode 100644 index 0000000..50fe52d --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section9/TextReversalWithoutLoop.java @@ -0,0 +1,30 @@ +package com.udemy.sdetintcod.section9; +import java.util.Scanner; + +/** + * String reversal with recursion. + * + */ +public class TextReversalWithoutLoop { + + public static void main(String[] args) { + Scanner scIn=new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInptText=scIn.nextLine(); + System.out.println("\nValue of Reversed text without loop : "+textReverseWithoutLoop(strInptText)); + scIn.close(); + } + + private static String textReverseWithoutLoop(String strInptText) { + // defining base condition. + if (strInptText == null || strInptText.isEmpty() || strInptText.length() == 1) { + return strInptText; + } + + // reversal by calling the same method by reducing length using through + // substring() starting from 2nd position and appending 1st charecter of input + // string + return textReverseWithoutLoop(strInptText.substring(1)) + strInptText.charAt(0); + } + +} \ No newline at end of file From 110ee5a40ea512f3ea768735421bb2ff356678b7 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Sat, 9 May 2026 20:45:23 +0530 Subject: [PATCH 12/18] updated the warnings! from scanner resource .close() + section-9: Latest String manipulations examples with StringBuilders,HashMaps. --- .../FindTargetValueIndexBySumOfInputs.java | 2 + .../RemoveTargetElementFromArray.java | 76 +++++++++++++++++ .../SortByAscForSquareOfArrayItems.java | 61 ++++++++++++++ .../ArrayIntersectionWithTwoPointer.java | 71 ++++++++++++++++ .../FindSumOfTwoNumsWithTwoPointers.java | 81 +++++++++++++++++++ .../MergeSortingWithTwoPointers.java | 37 +++++++++ .../MoveAllZeroToRightByTwoPointerProb.java | 58 +++++++++++++ .../RemoveArrItemUsingTwoPointer.java | 76 +++++++++++++++++ .../ReversingVowelsByTwoPointers.java | 78 ++++++++++++++++++ .../TwoPointerReversalProb.java | 60 ++++++++++++++ .../TestDriverForBinaryTreeOperation.java | 2 + .../queues/ArrayDequeWithInBuildQueue.java | 2 + .../DriverForPriorityQueueOperations.java | 2 + .../queues/DriverForQueueOperations.java | 2 + .../queues/HybridQueueUsingStack.java | 2 + .../queues/ReversingQueueUsingStack.java | 2 + .../queues/SimpleBuildInPriorityQueue.java | 2 + ...rraySumFactorialFobonaciWithRecursion.java | 2 + .../dsapart1/searching/BinarySearching.java | 2 + .../dsapart1/searching/JumpSearching.java | 2 + .../dsapart1/searching/LinearSearching.java | 2 + .../dsapart1/sortings/BubbleSorting.java | 2 + .../MergeSortingUsingDivideAndConquer.java | 2 + .../dsapart1/sortings/SelectionSorting.java | 2 + .../stacks/CustomPushAndPopToStack.java | 2 + .../stacks/FindMinimumElementFromStack.java | 2 + .../stacks/ReversalWithTempStack.java | 2 + .../stacks/SimpleStackOperations.java | 2 + .../stacks/StackBalancedStringChecker.java | 1 + .../udemy/dsapart1/stacks/StackSorting.java | 2 + .../ConstantTimeComplexityExample.java | 2 + .../ExponentialTimeComplexityExample.java | 2 + .../timecomplexity/LinearTimeComplexity.java | 2 + .../section9/FindUniqueCharsOfText.java | 41 ++++++++++ .../RemoveDuplicateCharsFromText.java | 30 +++++++ ...nlyAlternateWordsEachCharsOfInputText.java | 5 +- 36 files changed, 718 insertions(+), 3 deletions(-) create mode 100644 src/main/java/com/testleaf/selfpaced/fundamentalsArrays/RemoveTargetElementFromArray.java create mode 100644 src/main/java/com/testleaf/selfpaced/fundamentalsArrays/SortByAscForSquareOfArrayItems.java create mode 100644 src/main/java/com/testleaf/selfpaced/twopointersArrays/ArrayIntersectionWithTwoPointer.java create mode 100644 src/main/java/com/testleaf/selfpaced/twopointersArrays/FindSumOfTwoNumsWithTwoPointers.java create mode 100644 src/main/java/com/testleaf/selfpaced/twopointersArrays/MergeSortingWithTwoPointers.java create mode 100644 src/main/java/com/testleaf/selfpaced/twopointersArrays/MoveAllZeroToRightByTwoPointerProb.java create mode 100644 src/main/java/com/testleaf/selfpaced/twopointersArrays/RemoveArrItemUsingTwoPointer.java create mode 100644 src/main/java/com/testleaf/selfpaced/twopointersArrays/ReversingVowelsByTwoPointers.java create mode 100644 src/main/java/com/testleaf/selfpaced/twopointersArrays/TwoPointerReversalProb.java create mode 100644 src/main/java/com/udemy/sdetintcod/section9/FindUniqueCharsOfText.java create mode 100644 src/main/java/com/udemy/sdetintcod/section9/RemoveDuplicateCharsFromText.java diff --git a/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/FindTargetValueIndexBySumOfInputs.java b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/FindTargetValueIndexBySumOfInputs.java index 962d6ea..2a965c7 100644 --- a/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/FindTargetValueIndexBySumOfInputs.java +++ b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/FindTargetValueIndexBySumOfInputs.java @@ -30,6 +30,7 @@ public static void main(String[] args) { double targetVal=scInp.nextDouble(); System.out.println("\nOutput Index pairs : "); findSumOfTwoIndicesAgainstTarget(inputArr,targetVal); + scInp.close(); } @@ -97,6 +98,7 @@ public static void pushElementsIntoArray(double inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = scInp1Obj.nextDouble(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/RemoveTargetElementFromArray.java b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/RemoveTargetElementFromArray.java new file mode 100644 index 0000000..9e17ed8 --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/RemoveTargetElementFromArray.java @@ -0,0 +1,76 @@ +package com.testleaf.selfpaced.fundamentalsArrays; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Scanner; + +/* + * +prob-1 - Given an array and target remove the matching target from the array. + +1) understand the problem. +2) Ask example of Input/Output and reconfirm it. +3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case. +4) Don't show excitement to solve the problem infront of interviewer. +5) Ask for Hints !! if at all required. +6) Think for alternate solution. +7) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? + ask interviewer which to apply. +8) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!. +9) Initially to improve the logic build start with Psudo code. +10) Keep Talking while implementing the code. +11) After solving the problem please execute step 3. +12) Debug your failure to with breakPoints , watch variables fix and re-run your code. + +Step 6 to Step 12 plays vital role to crack interviews. + +*/ + +public class RemoveTargetElementFromArray { + + public static void main(String[] args) { + Scanner sc=new Scanner(System.in); + double[] dataItems= {7,9,22,76,88,45,90,56,45}; + System.out.println("\nEnter the Target Item : "); + double target=sc.nextDouble(); + System.out.println("\nInput Array Data : "+Arrays.toString(dataItems)); + System.out.println("\nArray Data avaiable : "+Arrays.toString(removeTargettedElement(dataItems, target))); + sc.close(); + } + + //Two Pass --> Time Complexity - O(n) + //Space complexity --> O(2n) + public static double[] removeTargettedElement(double[] inpArr, double targetItem) { + boolean blFlag = false; + ArrayList arrList = new ArrayList<>(); + if (inpArr == null) { + throw new RuntimeException("Operation can't be done for Null Array.."); + } + + if (inpArr.length == 0) { + throw new RuntimeException("Empty!! array.."); + } + + //Single pass --> O(n) + for (int i = 0; i < inpArr.length; i++) { + if (inpArr[i] != targetItem) { + arrList.add(inpArr[i]); + blFlag = true; + } else { + continue; + } + } + + if (!blFlag) { + throw new RuntimeException("No Match found!!.."); + } + int newArrListSize = arrList.size(); + inpArr = new double[newArrListSize]; + //Two pass --> O(n) + for (int i = 0; i < newArrListSize; i++) { + inpArr[i] = (double) arrList.get(i); + } + return inpArr; + } + + +} \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/SortByAscForSquareOfArrayItems.java b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/SortByAscForSquareOfArrayItems.java new file mode 100644 index 0000000..53d5c53 --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/fundamentalsArrays/SortByAscForSquareOfArrayItems.java @@ -0,0 +1,61 @@ +package com.testleaf.selfpaced.fundamentalsArrays; +import java.util.Arrays; + +/* + * +prob-1 - Given Sorted array in Non-Descending(i.e ASC or may be same) order , return the array of the square of each number sorted in Non-Descending(i.e ASC or may be same) order +Try to solve using two pointer approach. + +1) understand the problem. +2) Ask example of Input/Output and reconfirm it. +3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case. +4) Don't show excitement to solve the problem infront of interviewer. +5) Ask for Hints !! if at all required. +6) Think for alternate solution. +7) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? + ask interviewer which to apply. +8) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!. +9) Initially to improve the logic build start with Psudo code. +10) Keep Talking while implementing the code. +11) After solving the problem please execute step 3. +12) Debug your failure to with breakPoints , watch variables fix and re-run your code. ++ +Step 6 to Step 12 plays vital role to crack interviews. + +*/ + +public class SortByAscForSquareOfArrayItems { + + public static void main(String[] args) { + double[] numArr= {-7,10,-5,14,4,11,7}; + System.out.println("\nInput array : "+Arrays.toString(numArr)); + System.out.println("\nOutput Array of Sorted Squared Items : "+Arrays.toString(getSortedSquaredItems(numArr))); + } + + + /* + * prob-1 - Given Sorted array in Non-Descending(i.e ASC or may be same) order , + * return the array of the square of each number sorted in Non-Descending(i.e + * ASC) order + * + * Time Complexity - Best Case --> O(n/2) (When dataset mix of +ve , -ve) , Wrost Case --> O(n) (When dataset only +ve or -ve) + * Space Complexity - O(n) + * + */ + private static double[] getSortedSquaredItems(double[] numArr) { + double[] sqarArr = new double[numArr.length]; + int l = 0; + int r = numArr.length - 1; + int rInsPos = numArr.length - 1; + while (l <= r) { + if (Math.abs(numArr[l]) < Math.abs(numArr[r])) { + sqarArr[rInsPos--] = numArr[r] * numArr[r--]; + } else { + sqarArr[rInsPos--] = numArr[l] * numArr[l++]; + } + } + Arrays.sort(sqarArr); + return sqarArr; + } + +} \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/twopointersArrays/ArrayIntersectionWithTwoPointer.java b/src/main/java/com/testleaf/selfpaced/twopointersArrays/ArrayIntersectionWithTwoPointer.java new file mode 100644 index 0000000..d36f185 --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/twopointersArrays/ArrayIntersectionWithTwoPointer.java @@ -0,0 +1,71 @@ +package com.testleaf.selfpaced.twopointersArrays; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/* + * +prob-2 - Array (Sorted items) intersection using eqidirection. (with two pointer approach) + +1) understand the problem. +2) Ask example of Input/Output and reconfirm it. +3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case. +4) Don't show excitement to solve the problem infront of interviewer. +5) Ask for Hints !! if at all required. +6) Think for alternate solution. +7) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? + ask interviewer which to apply. +8) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!. +9) Initially to improve the logic build start with Psudo code. +10) Keep Talking while implementing the code. +11) After solving the problem please execute step 3. +12) Debug your failure to with breakPoints , watch variables fix and re-run your code. + +Step 6 to Step 12 plays vital role to crack interviews. + +*/ + +public class ArrayIntersectionWithTwoPointer { + + public static void main(String[] args) { + int[] x= {1,2,4,6,7,11,12,14,20,40}; + int[] y= {2,12,7,15,20}; + System.out.println("\nInput Array-1 : "+Arrays.toString(x)); + System.out.println("\nInput Array-2 : "+Arrays.toString(y)); + findIntersectionOfInputArrays(x,y); + } + + private static void findIntersectionOfInputArrays(int[] x, int[] y) { + int l = 0; + int r = 0; + List lst = new ArrayList<>(); + boolean blFlag = false; + if (x == null || y == null) { + System.err.println("\nIntersection can't be done for NULL arrays!!.."); + return; + } + if (x.length == 0 || y.length == 0) { + System.err.println("\nIntersection can't be done for Empty! arrays!!.."); + return; + } + + while (l < x.length && r < y.length) { + if (x[l] == y[r]) { + lst.add(x[l]); + blFlag = true; + l++; + r++; + } else if (x[l] < y[r]) { + l++; + } else { + r++; + } + } + + if (!blFlag) { + System.err.println("\nNo intersection found!!.."); + } + System.out.println("\nInterseced Items : " +Arrays.toString(lst.toArray())); + } + +} \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/twopointersArrays/FindSumOfTwoNumsWithTwoPointers.java b/src/main/java/com/testleaf/selfpaced/twopointersArrays/FindSumOfTwoNumsWithTwoPointers.java new file mode 100644 index 0000000..9858eb3 --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/twopointersArrays/FindSumOfTwoNumsWithTwoPointers.java @@ -0,0 +1,81 @@ +package com.testleaf.selfpaced.twopointersArrays; +import java.util.Arrays; +import java.util.Scanner; + +/* + * + * +prob-1 - Given the Sorted input array, find the sum of first two indices of the matching given the target using two pointer approach. + +1) understand the problem. +2) Ask example of Input/Output and reconfirm it. +3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case. +4) Don't show excitement to solve the problem infront of interviewer. +5) Ask for Hints !! if at all required. +6) Think for alternate solution. +7) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? + ask interviewer which to apply. +8) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!. +9) Initially to improve the logic build start with Psudo code. +10) Keep Talking while implementing the code. +11) After solving the problem please execute step 3. +12) Debug your failure to with breakPoints , watch variables fix and re-run your code. + +Step 6 to Step 12 plays vital role to crack interviews. + +*/ + +public class FindSumOfTwoNumsWithTwoPointers { + + public static void main(String[] args) { + try (Scanner sc = new Scanner(System.in)) { + double[] appArr= {4,5,8,10,13,16,22,30,40,45,55,65,70,85,99,100}; + System.out.println("\nInput array : "+Arrays.toString(appArr)); + System.out.print("\nEnter Target Value : "); + double targetVal=sc.nextDouble(); + System.out.println("\nOutput Index pairs : "); + optimizedTwoPointerfindSumOfTwoIndicesByTarget(appArr,targetVal); + } + + } + + /* + * Left Index - 0 , right index - last index. Loop through the array until Left + * index less than right index. + * 1) if target == sum of left index + right index Items --> return left index , right index. + * 2) if target < sum of left index + right index Items --> move Right to left direction in array by decrement right index. + * 3) if target > sum of left index + right index Items --> move Left to right direction in array by increment left index. + * + */ + private static void optimizedTwoPointerfindSumOfTwoIndicesByTarget(double[] appArr, double targetVal) { + boolean blFlag = false; + if (appArr == null) { + throw new RuntimeException("Operation can't be done for Null Array.."); + } + + if (appArr.length == 0) { + throw new RuntimeException("Empty!! array.."); + } + int l = 0; + int r = appArr.length - 1; + while (l < r) { + double sum = appArr[l] + appArr[r]; + if (sum == targetVal) { + blFlag = true; + System.out.println("\nFound Index : (" + l + " , " + r + ") "); + break; + } else if (sum > targetVal) { + r--; + } else { + l++; + } + + } + + if (!blFlag) { + throw new RuntimeException("No Match found!!.."); + } + + } + +} \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/twopointersArrays/MergeSortingWithTwoPointers.java b/src/main/java/com/testleaf/selfpaced/twopointersArrays/MergeSortingWithTwoPointers.java new file mode 100644 index 0000000..41d078f --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/twopointersArrays/MergeSortingWithTwoPointers.java @@ -0,0 +1,37 @@ +package com.testleaf.selfpaced.twopointersArrays; + +import java.util.Arrays; + +/* + * +prob-1 - Two arrays Merge sort of using two pointers algorithms. + +1) understand the problem. +2) Ask example of Input/Output and reconfirm it. +3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case. +4) Don't show excitement to solve the problem infront of interviewer. +5) Ask for Hints !! if at all required. +6) Think for alternate solution. +7) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? + ask interviewer which to apply. +8) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!. +9) Initially to improve the logic build start with Psudo code. +10) Keep Talking while implementing the code. +11) After solving the problem please execute step 3. +12) Debug your failure to with breakPoints , watch variables fix and re-run your code. + +Step 6 to Step 12 plays vital role to crack interviews. + +*/ + +public class MergeSortingWithTwoPointers { + + public static void main(String[] args) { + double inp1Arr[]= {5.5,4,6,7.45,3.3,5}; + double inp2Arr[]= {2.5,-3,6,8.03,6.5}; + System.out.println("\nArray1 data : "+Arrays.toString(inp1Arr)); + System.out.println("\nArray2 data : "+Arrays.toString(inp2Arr)); + } + + +} \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/twopointersArrays/MoveAllZeroToRightByTwoPointerProb.java b/src/main/java/com/testleaf/selfpaced/twopointersArrays/MoveAllZeroToRightByTwoPointerProb.java new file mode 100644 index 0000000..73acf06 --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/twopointersArrays/MoveAllZeroToRightByTwoPointerProb.java @@ -0,0 +1,58 @@ +package com.testleaf.selfpaced.twopointersArrays; +import java.util.Arrays; + +/* + * +prob-3 - Move all zeros to the end of array. (with two pointer approach) (Position of Non-Zero Should be maintained. + +1) understand the problem. +2) Ask example of Input/Output and reconfirm it. +3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case. +4) Don't show excitement to solve the problem infront of interviewer. +5) Ask for Hints !! if at all required. +6) Think for alternate solution. +7) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? + ask interviewer which to apply. +8) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!. +9) Initially to improve the logic build start with Psudo code. +10) Keep Talking while implementing the code. +11) After solving the problem please execute step 3. +12) Debug your failure to with breakPoints , watch variables fix and re-run your code. + +Step 6 to Step 12 plays vital role to crack interviews. + +*/ + +public class MoveAllZeroToRightByTwoPointerProb { + + public static void main(String[] args) { + double[] dataItems= {8,0,23,1,-34,0,7,34,0,59,0}; + System.out.println("\nInput Array Data : "+Arrays.toString(dataItems)); + System.out.println("\nPost Zero Shift/Move to right resultant Array Data : "+Arrays.toString(twoPointerMoveAllZerosToRight(dataItems))); + + } + + private static double[] twoPointerMoveAllZerosToRight(double[] dataItems) { + if (dataItems == null) { + System.err.println("Operation can't be done for Null Array.."); + } + + if (dataItems.length == 0) { + System.err.println("Empty!! array.."); + } + int l = 0; + int r = 0; + while (r < dataItems.length) { + if (dataItems[r] != 0) { + double temDat = dataItems[r]; + dataItems[r] = dataItems[l]; + dataItems[l++] = temDat; + } + r++; + } + return dataItems; + } + + + +} \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/twopointersArrays/RemoveArrItemUsingTwoPointer.java b/src/main/java/com/testleaf/selfpaced/twopointersArrays/RemoveArrItemUsingTwoPointer.java new file mode 100644 index 0000000..22c701a --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/twopointersArrays/RemoveArrItemUsingTwoPointer.java @@ -0,0 +1,76 @@ +package com.testleaf.selfpaced.twopointersArrays; +import java.util.Arrays; +import java.util.Scanner; + +/* + * +prob-1 - Given an array and target remove the matching target from the array using two pointers approach. + +1) understand the problem. +2) Ask example of Input/Output and reconfirm it. +3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case. +4) Don't show excitement to solve the problem infront of interviewer. +5) Ask for Hints !! if at all required. +6) Think for alternate solution. +7) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? + ask interviewer which to apply. +8) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!. +9) Initially to improve the logic build start with Psudo code. +10) Keep Talking while implementing the code. +11) After solving the problem please execute step 3. +12) Debug your failure to with breakPoints , watch variables fix and re-run your code. + +Step 6 to Step 12 plays vital role to crack interviews. + +*/ + +public class RemoveArrItemUsingTwoPointer { + + public static void main(String[] args) { + Scanner sc=new Scanner(System.in); + double[] dataItems= {7,9,22,76,88,45,90,56,45,78}; + System.out.println("\nInput Array Data : "+Arrays.toString(dataItems)); + System.out.println("\nEnter the Target Item : "); + double target=sc.nextDouble(); + System.out.println("\nArray Data avaiable : "+Arrays.toString(removeElementUsingTwoPointers(dataItems, target))); + sc.close(); + } + + /* + * static arrays & dynamic arrays + * static arrays - capacity size is fixed as number of elements is declared at the beginning. + * In order to solve static arrays capacity issue create another dynamic array using - Arrays.copyOf(primitiveArray,newSize) + * dynamic arrays - dynamic arrays size is growable or shrinkable. + * Like - ArrayList , List , LinkedList , Map etc. + * + */ + //Time & Space Complexity of --> O(n) + private static double[] removeElementUsingTwoPointers(double[] dataItems, double target) { + boolean flgStatus = false; + if (dataItems == null) { + throw new RuntimeException("Operation can't be done for Null Array.."); + } + + if (dataItems.length == 0) { + throw new RuntimeException("Empty!! array.."); + } + + int l = 0; + int r = 0; + while (r < dataItems.length) { + if (dataItems[r] != target) { + dataItems[l++] = dataItems[r]; + } else { + flgStatus = true; + } + r++; + } + if (!flgStatus) { + throw new RuntimeException("No!! match found..."); + } + System.out.println("\nItem found!! & removed.."); + return Arrays.copyOf(dataItems, l); + } + + +} \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/twopointersArrays/ReversingVowelsByTwoPointers.java b/src/main/java/com/testleaf/selfpaced/twopointersArrays/ReversingVowelsByTwoPointers.java new file mode 100644 index 0000000..cc756ae --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/twopointersArrays/ReversingVowelsByTwoPointers.java @@ -0,0 +1,78 @@ +package com.testleaf.selfpaced.twopointersArrays; +import java.util.Scanner; + +/* + * +prob-1 - Reversing the vowels with two pointer approach (though the Time Complexity is O(n/2) but technically its better solution than O(n) +prob-2 - Array (Sorted items) intersection using eqidirection. (with two pointer approach) + +1) understand the problem. +2) Ask example of Input/Output and reconfirm it. +3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case. +4) Don't show excitement to solve the problem infront of interviewer. +5) Ask for Hints !! if at all required. +6) Think for alternate solution. +7) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? + ask interviewer which to apply. +8) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!. +9) Initially to improve the logic build start with Psudo code. +10) Keep Talking while implementing the code. +11) After solving the problem please execute step 3. +12) Debug your failure to with breakPoints , watch variables fix and re-run your code. + +Step 6 to Step 12 plays vital role to crack interviews. + +*/ + +public class ReversingVowelsByTwoPointers { + + public static void main(String[] args) { + try (Scanner sc = new Scanner(System.in)) { + System.out.println("\nEnter the input string : "); + String inpStr=sc.nextLine(); + System.out.println("\nReversing Vowels Output String : "+twoPointersReversingVowelStrings(inpStr)); + } + } + + /* + * This problem solves in both direction left , right and stops at the middle it + * self hence best time complexity : O(n/2) , wrost case - O(n) + * + */ + public static String twoPointersReversingVowelStrings(String inpStr) { + inpStr = inpStr.toLowerCase(); + if (inpStr == null) { + return "Operation can't be done for Null String.."; + } + + if (inpStr.length() == 0) { + return "Empty!! String.."; + } + + if (inpStr.length() == 1) { + return "Non reverseable : " + inpStr; + } + + int l = 0; + int r = inpStr.length() - 1; + char[] charItems = inpStr.toCharArray(); + while (l < r) { + if (isVowel(charItems[l]) && isVowel(charItems[r])) { + char temChar = charItems[l]; + charItems[l++] = charItems[r]; + charItems[r--] = temChar; + } else if (isVowel(charItems[l])) { + r--; + } else { + l++; + } + } + return new String(charItems); + } + + + public static boolean isVowel(char ch) { + return (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u'); + } + +} \ No newline at end of file diff --git a/src/main/java/com/testleaf/selfpaced/twopointersArrays/TwoPointerReversalProb.java b/src/main/java/com/testleaf/selfpaced/twopointersArrays/TwoPointerReversalProb.java new file mode 100644 index 0000000..5e5d6ef --- /dev/null +++ b/src/main/java/com/testleaf/selfpaced/twopointersArrays/TwoPointerReversalProb.java @@ -0,0 +1,60 @@ +package com.testleaf.selfpaced.twopointersArrays; +import java.util.Scanner; + +/* + * +prob-1 - Reverse input String with two pointer approach (though the Time Complexity is O(n/2) but technically its better solution than O(n) + +1) understand the problem. +2) Ask example of Input/Output and reconfirm it. +3) Find the 3 Types test data to solve the problem - +Positive , -Negative , edge case. +4) Don't show excitement to solve the problem infront of interviewer. +5) Ask for Hints !! if at all required. +6) Think for alternate solution. +7) If we know more than one solution - explain approaches which solution is better (Time/Space complexity wise)/ why? + ask interviewer which to apply. +8) If we are sure about optimal solution at least start with wrost case(Then show optimal if known) solution - brute force approach!!. +9) Initially to improve the logic build start with Psudo code. +10) Keep Talking while implementing the code. +11) After solving the problem please execute step 3. +12) Debug your failure to with breakPoints , watch variables fix and re-run your code. + +Step 6 to Step 12 plays vital role to crack interviews. + +*/ + +public class TwoPointerReversalProb { + + public static void main(String[] args) { + Scanner sc=new Scanner(System.in); + System.out.println("\nEnter the input String : "); + String inpData=sc.nextLine(); + System.out.println("\nOutPut Reversed String : "+getReversedStringByTwoPointerSwapApproach(inpData)); + sc.close(); + } + + public static String getReversedStringByTwoPointerSwapApproach(String inpStr) { + if (inpStr == null) { + return "Operation can't be done for Null String.."; + } + + if (inpStr.length() == 0) { + return "Empty!! String.."; + } + + if (inpStr.length() == 1) { + return "Non reverseable : " + inpStr; + } + int lIdx = 0; + int rIdx = inpStr.length() - 1; + char charItems[] = inpStr.toCharArray(); + while (lIdx < rIdx) { + char tem = charItems[rIdx]; + charItems[rIdx--] = charItems[lIdx]; + charItems[lIdx++] = tem; + } + return new String(charItems); + } + + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/binarytrees/TestDriverForBinaryTreeOperation.java b/src/main/java/com/udemy/dsapart1/binarytrees/TestDriverForBinaryTreeOperation.java index 563d2e9..4d71090 100644 --- a/src/main/java/com/udemy/dsapart1/binarytrees/TestDriverForBinaryTreeOperation.java +++ b/src/main/java/com/udemy/dsapart1/binarytrees/TestDriverForBinaryTreeOperation.java @@ -34,6 +34,7 @@ public static void main(String[] args) { System.out.print("\nEnter element to check in tree : "); double searchDataItem = scInp.nextDouble(); System.out.println("\nIs the seached item present in Tree : "+binTreeObj.isElementPresent(searchDataItem)); + scInp.close(); } @@ -45,6 +46,7 @@ private static void pushElementsIntoTreeLikeArray(double[] inputArr2) { //Inserting nodes to Binary Tree. binTreeObj.insertANode(inputArr[i]); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/queues/ArrayDequeWithInBuildQueue.java b/src/main/java/com/udemy/dsapart1/queues/ArrayDequeWithInBuildQueue.java index b3ab6c5..da1c6fa 100644 --- a/src/main/java/com/udemy/dsapart1/queues/ArrayDequeWithInBuildQueue.java +++ b/src/main/java/com/udemy/dsapart1/queues/ArrayDequeWithInBuildQueue.java @@ -24,6 +24,7 @@ public static void main(String[] args) { System.out.println("\nLatest peeked item : "+doubleQueue.peek()); System.out.println("\nItem removed : "+doubleQueue.remove()); System.out.println("\nFinal latest updated ArrayDeque Items : "+doubleQueue); + scInpObj.close(); } @@ -35,6 +36,7 @@ private static void pushElementsIntoArray(int sizeOfQue) { arrayOfQue[i]=scInp1Obj.nextDouble(); doubleQueue.add(arrayOfQue[i]); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/queues/DriverForPriorityQueueOperations.java b/src/main/java/com/udemy/dsapart1/queues/DriverForPriorityQueueOperations.java index 2304df8..b3039fc 100644 --- a/src/main/java/com/udemy/dsapart1/queues/DriverForPriorityQueueOperations.java +++ b/src/main/java/com/udemy/dsapart1/queues/DriverForPriorityQueueOperations.java @@ -23,6 +23,7 @@ public static void main(String[] args) { queObj.priorityEnqueueOperation(9001); System.out.println("\nNew Priority Sorted Queue after Enqueue operation : "+Arrays.toString(queObj.getDataItem())); System.out.println("\nLatest size of Priority Queue : "+queObj.getSizeOfQue()); + scInpObj.close(); } @@ -34,6 +35,7 @@ private static void pushElementsIntoArray(int sizeOfQue) { arrayOfQue[i]=scInp1Obj.nextDouble(); queObj.priorityEnqueueOperation(arrayOfQue[i]); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/queues/DriverForQueueOperations.java b/src/main/java/com/udemy/dsapart1/queues/DriverForQueueOperations.java index 882ee63..34aaaed 100644 --- a/src/main/java/com/udemy/dsapart1/queues/DriverForQueueOperations.java +++ b/src/main/java/com/udemy/dsapart1/queues/DriverForQueueOperations.java @@ -21,6 +21,7 @@ public static void main(String[] args) { queObj.doEnqueInsertElement(5000.34); System.out.println("\nNew Que after Enqueue operation : "+Arrays.toString(queObj.getDataItem())); System.out.println("\nLatest size of Queue : "+queObj.getSizeOfQue()); + scInpObj.close(); } @@ -32,6 +33,7 @@ private static void pushElementsIntoArray(int sizeOfQue) { arrayOfQue[i]=scInp1Obj.nextDouble(); queObj.doEnqueInsertElement(arrayOfQue[i]); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/queues/HybridQueueUsingStack.java b/src/main/java/com/udemy/dsapart1/queues/HybridQueueUsingStack.java index 6f55f9a..76a548d 100644 --- a/src/main/java/com/udemy/dsapart1/queues/HybridQueueUsingStack.java +++ b/src/main/java/com/udemy/dsapart1/queues/HybridQueueUsingStack.java @@ -24,6 +24,7 @@ public static void main(String[] args) { performCustomDeque(); performCustomDeque(); System.out.println("\nLatest hybrid-Queue status : "+srcStack); + scInpObj.close(); } @@ -55,6 +56,7 @@ private static void pushElementsIntoArray(int sizeOfQue) { arrayOfQue[i]=scInp1Obj.nextDouble(); performCustomEnque(arrayOfQue[i]); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/queues/ReversingQueueUsingStack.java b/src/main/java/com/udemy/dsapart1/queues/ReversingQueueUsingStack.java index cb6984c..c78d57b 100644 --- a/src/main/java/com/udemy/dsapart1/queues/ReversingQueueUsingStack.java +++ b/src/main/java/com/udemy/dsapart1/queues/ReversingQueueUsingStack.java @@ -17,6 +17,7 @@ public static void main(String[] args) { pushElementsIntoArray(sizeOfQue); System.out.println("\nInput initial ArrayDeque Items : "+doubleQueue); System.out.println("\nResultant Revered ArrayDeque Items : "+doReverseItemsOfArrayDeque(doubleQueue)); + scInpObj.close(); } @@ -40,6 +41,7 @@ private static void pushElementsIntoArray(int sizeOfQue) { arrayOfQue[i]=scInp1Obj.nextDouble(); doubleQueue.add(arrayOfQue[i]); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/queues/SimpleBuildInPriorityQueue.java b/src/main/java/com/udemy/dsapart1/queues/SimpleBuildInPriorityQueue.java index 58167e1..a66844d 100644 --- a/src/main/java/com/udemy/dsapart1/queues/SimpleBuildInPriorityQueue.java +++ b/src/main/java/com/udemy/dsapart1/queues/SimpleBuildInPriorityQueue.java @@ -24,6 +24,7 @@ public static void main(String[] args) { System.out.println("\nLatest peeked item : "+priorQue.peek()); System.out.println("\nItem removed : "+priorQue.remove()); System.out.println("\nFinal latest updated Priority Queue Items : "+priorQue); + scInpObj.close(); } @@ -35,6 +36,7 @@ private static void pushElementsIntoArray(int sizeOfQue) { arrayOfQue[i]=scInp1Obj.nextDouble(); priorQue.add(arrayOfQue[i]); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/recursion/ArraySumFactorialFobonaciWithRecursion.java b/src/main/java/com/udemy/dsapart1/recursion/ArraySumFactorialFobonaciWithRecursion.java index 147a563..9ab782e 100644 --- a/src/main/java/com/udemy/dsapart1/recursion/ArraySumFactorialFobonaciWithRecursion.java +++ b/src/main/java/com/udemy/dsapart1/recursion/ArraySumFactorialFobonaciWithRecursion.java @@ -42,6 +42,7 @@ public static void main(String[] args) { System.out.println(""+nthNumInput+"th Fibonacci number : "); long fiboNumVal=getNthFibonaciNumber(nthNumInput); System.out.println(fiboNumVal); + scInpObj.close(); } @@ -90,6 +91,7 @@ public static void pushElementsIntoArray(double inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = scInp1Obj.nextDouble(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/searching/BinarySearching.java b/src/main/java/com/udemy/dsapart1/searching/BinarySearching.java index 3617d1d..778c6b1 100644 --- a/src/main/java/com/udemy/dsapart1/searching/BinarySearching.java +++ b/src/main/java/com/udemy/dsapart1/searching/BinarySearching.java @@ -28,6 +28,7 @@ public static void main(String[] args) { double target2Item = scInp.nextDouble(); int result2Index=recursiveBinarySearching(inputArr,target2Item,0,inputArr.length-1); System.out.println("\nTarget element found at index : "+result2Index); + scInp.close(); } @@ -147,6 +148,7 @@ public static void pushElementsIntoArray(double inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = scInp1Obj.nextDouble(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/searching/JumpSearching.java b/src/main/java/com/udemy/dsapart1/searching/JumpSearching.java index 76dbacd..ecc0f1c 100644 --- a/src/main/java/com/udemy/dsapart1/searching/JumpSearching.java +++ b/src/main/java/com/udemy/dsapart1/searching/JumpSearching.java @@ -23,6 +23,7 @@ public static void main(String[] args) { double targetItem = scInp.nextDouble(); int resultIndex=performJumpSearchingOnSortedArray(inputArr,targetItem); System.out.println("\nTarget element found at index : "+resultIndex); + scInp.close(); } @@ -121,6 +122,7 @@ public static void pushElementsIntoArray(double inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = scInp1Obj.nextDouble(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/searching/LinearSearching.java b/src/main/java/com/udemy/dsapart1/searching/LinearSearching.java index 86c210c..edfb4a2 100644 --- a/src/main/java/com/udemy/dsapart1/searching/LinearSearching.java +++ b/src/main/java/com/udemy/dsapart1/searching/LinearSearching.java @@ -21,6 +21,7 @@ public static void main(String[] args) { double targetItem = scInp.nextDouble(); int resultIndex=performLinearSearching(inputArr,targetItem); System.out.println("\nTarget element found at index : "+resultIndex); + scInp.close(); } @@ -49,6 +50,7 @@ public static void pushElementsIntoArray(double inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = scInp1Obj.nextDouble(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/sortings/BubbleSorting.java b/src/main/java/com/udemy/dsapart1/sortings/BubbleSorting.java index a5e5f0b..d738c92 100644 --- a/src/main/java/com/udemy/dsapart1/sortings/BubbleSorting.java +++ b/src/main/java/com/udemy/dsapart1/sortings/BubbleSorting.java @@ -14,6 +14,7 @@ public static void main(String[] args) { System.out.println("\nInput Array : " + Arrays.toString(inputArr)); performBubbleSort(inputArr); System.out.println("\nRequired bubble Sorted array : "+Arrays.toString(inputArr)); + scInp.close(); } @@ -57,6 +58,7 @@ public static void pushElementsIntoArray(double inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = scInp1Obj.nextDouble(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/sortings/MergeSortingUsingDivideAndConquer.java b/src/main/java/com/udemy/dsapart1/sortings/MergeSortingUsingDivideAndConquer.java index b750f2d..5df052b 100644 --- a/src/main/java/com/udemy/dsapart1/sortings/MergeSortingUsingDivideAndConquer.java +++ b/src/main/java/com/udemy/dsapart1/sortings/MergeSortingUsingDivideAndConquer.java @@ -14,6 +14,7 @@ public static void main(String[] args) { System.out.println("\nInput Array : " + Arrays.toString(inputArr)); performMergeSort(inputArr); System.out.println("\nRequired Merge Sorted array : "+Arrays.toString(inputArr)); + scInp.close(); } @@ -80,6 +81,7 @@ public static void pushElementsIntoArray(double inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = scInp1Obj.nextDouble(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/sortings/SelectionSorting.java b/src/main/java/com/udemy/dsapart1/sortings/SelectionSorting.java index addb1a5..b6d0a18 100644 --- a/src/main/java/com/udemy/dsapart1/sortings/SelectionSorting.java +++ b/src/main/java/com/udemy/dsapart1/sortings/SelectionSorting.java @@ -14,6 +14,7 @@ public static void main(String[] args) { System.out.println("\nInput Array : " + Arrays.toString(inputArr)); performSelectionSort(inputArr); System.out.println("\nRequired Selection Sorted array : "+Arrays.toString(inputArr)); + scInp.close(); } @@ -59,6 +60,7 @@ public static void pushElementsIntoArray(double inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = scInp1Obj.nextDouble(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/stacks/CustomPushAndPopToStack.java b/src/main/java/com/udemy/dsapart1/stacks/CustomPushAndPopToStack.java index 35bcb1a..c1f0dce 100644 --- a/src/main/java/com/udemy/dsapart1/stacks/CustomPushAndPopToStack.java +++ b/src/main/java/com/udemy/dsapart1/stacks/CustomPushAndPopToStack.java @@ -25,6 +25,7 @@ public static void main(String[] args) { int indexToPop = scInpObj.nextInt(); doCustomPopToStackByIndex(indexToPop,firstStack); System.out.println("\nUpdated Stack post pop of elements : " + firstStack); + scInpObj.close(); } @@ -65,6 +66,7 @@ private static void pushElementsIntoStack(int sizeOfStack) { System.out.print("\npush the element No " + (i + 1) + " : "); firstStack.push(scInp1Obj.nextDouble()); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/stacks/FindMinimumElementFromStack.java b/src/main/java/com/udemy/dsapart1/stacks/FindMinimumElementFromStack.java index 23be581..244ed51 100644 --- a/src/main/java/com/udemy/dsapart1/stacks/FindMinimumElementFromStack.java +++ b/src/main/java/com/udemy/dsapart1/stacks/FindMinimumElementFromStack.java @@ -27,6 +27,7 @@ public static void main(String[] args) { customPush(1000.300); System.out.println("\nFinal updated stack post push,pop operation : "+firstStack); System.out.println("\nMinimum peeked element from Stack : "+firstStack.peek()); + scInpObj.close(); } @@ -56,6 +57,7 @@ private static void pushElementsIntoStack(int sizeOfStack) { System.out.print("\npush the element No " + (i + 1) + " : "); firstStack.push(scInp1Obj.nextDouble()); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/stacks/ReversalWithTempStack.java b/src/main/java/com/udemy/dsapart1/stacks/ReversalWithTempStack.java index 7a0e7d5..5d317bd 100644 --- a/src/main/java/com/udemy/dsapart1/stacks/ReversalWithTempStack.java +++ b/src/main/java/com/udemy/dsapart1/stacks/ReversalWithTempStack.java @@ -22,6 +22,7 @@ public static void main(String[] args) { moveStackElementsToReverseItems(tempSecStack,temp3rdStack); moveStackElementsToReverseItems(temp3rdStack,firstStack); System.out.println("\nOutput Reversed Stack : "+firstStack); + scInpObj.close(); } @@ -40,6 +41,7 @@ private static void pushElementsIntoStack(int sizeOfStack) { System.out.print("\npush the element No " + (i + 1) + " : "); firstStack.push(scInp1Obj.nextDouble()); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/stacks/SimpleStackOperations.java b/src/main/java/com/udemy/dsapart1/stacks/SimpleStackOperations.java index 13031be..946aa0f 100644 --- a/src/main/java/com/udemy/dsapart1/stacks/SimpleStackOperations.java +++ b/src/main/java/com/udemy/dsapart1/stacks/SimpleStackOperations.java @@ -50,6 +50,7 @@ public static void main(String[] args) { System.out.println("\nCurrent new final Stack status : "+firstStack); System.out.println("\nFinal size of stack - "+firstStack.size()); System.out.println("\nFinal capacity of stack - "+firstStack.capacity()); + scInpObj.close(); } private static void pushElementsIntoStack(int sizeOfStack) { @@ -58,6 +59,7 @@ private static void pushElementsIntoStack(int sizeOfStack) { System.out.print("\npush the element No " + (i + 1) + " : "); firstStack.push(scInp1Obj.nextDouble()); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/stacks/StackBalancedStringChecker.java b/src/main/java/com/udemy/dsapart1/stacks/StackBalancedStringChecker.java index 565b0c1..e728529 100644 --- a/src/main/java/com/udemy/dsapart1/stacks/StackBalancedStringChecker.java +++ b/src/main/java/com/udemy/dsapart1/stacks/StackBalancedStringChecker.java @@ -9,6 +9,7 @@ public static void main(String[] args) { System.out.print("\nEnter the input string : "); String inputStr = scInpObj.nextLine(); System.out.println("\nCheck is the input string is balanced : "+isStringBalanced(inputStr)); + scInpObj.close(); } private static boolean isStringBalanced(String inputStr) { diff --git a/src/main/java/com/udemy/dsapart1/stacks/StackSorting.java b/src/main/java/com/udemy/dsapart1/stacks/StackSorting.java index 42b7565..b09d9ba 100644 --- a/src/main/java/com/udemy/dsapart1/stacks/StackSorting.java +++ b/src/main/java/com/udemy/dsapart1/stacks/StackSorting.java @@ -18,6 +18,7 @@ public static void main(String[] args) { System.out.println("\nInput Stack : " + firstStack); System.out.println("\nOutput Stack sorted in increasing/ascending order : " +sortStackByAscOrder(firstStack)); System.out.println("\nOutput Stack sorted in dicreasing/descending order : " +sortStackByDescOrder(secStack)); + scInpObj.close(); } @@ -55,6 +56,7 @@ private static void pushElementsIntoStack(int sizeOfStack) { firstStack.push(dataItem); secStack.push(dataItem); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/timecomplexity/ConstantTimeComplexityExample.java b/src/main/java/com/udemy/dsapart1/timecomplexity/ConstantTimeComplexityExample.java index f905fd5..35f93de 100644 --- a/src/main/java/com/udemy/dsapart1/timecomplexity/ConstantTimeComplexityExample.java +++ b/src/main/java/com/udemy/dsapart1/timecomplexity/ConstantTimeComplexityExample.java @@ -21,6 +21,7 @@ public static void main(String[] args) { System.out.print("\nEnter the target Index : "); int targetIndex = scInp.nextInt(); System.out.println("\nCheck Null value exists into target index of Array : "+checkNullValueExists(inputArr,targetIndex)); + scInp.close(); } @@ -61,5 +62,6 @@ public static void pushElementsIntoArray(Object inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = (Object)scInp1Obj.nextLine(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/timecomplexity/ExponentialTimeComplexityExample.java b/src/main/java/com/udemy/dsapart1/timecomplexity/ExponentialTimeComplexityExample.java index f579993..afe9d10 100644 --- a/src/main/java/com/udemy/dsapart1/timecomplexity/ExponentialTimeComplexityExample.java +++ b/src/main/java/com/udemy/dsapart1/timecomplexity/ExponentialTimeComplexityExample.java @@ -17,6 +17,7 @@ public static void main(String[] args) { pushElementsIntoArray(inputArr); System.out.println("\nInput Array data : "+Arrays.toString(inputArr)); print2DMatrix(inputArr,rowSize); + scInp.close(); } @@ -47,6 +48,7 @@ public static void pushElementsIntoArray(double inputArr[][]) { inputArr[i][j] = scInp1Obj.nextDouble(); } } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/dsapart1/timecomplexity/LinearTimeComplexity.java b/src/main/java/com/udemy/dsapart1/timecomplexity/LinearTimeComplexity.java index 3eba298..bcaf6b3 100644 --- a/src/main/java/com/udemy/dsapart1/timecomplexity/LinearTimeComplexity.java +++ b/src/main/java/com/udemy/dsapart1/timecomplexity/LinearTimeComplexity.java @@ -15,6 +15,7 @@ public static void main(String[] args) { pushElementsIntoArray(inputArr); System.out.println("\nInput Array : " + Arrays.toString(inputArr)); evaluateMinAndMaxElementFromArray(inputArr); + scInp.close(); } @@ -43,6 +44,7 @@ public static void pushElementsIntoArray(double inputArr[]) { System.out.print("\nEnter the element No " + (i + 1) + " : "); inputArr[i] = scInp1Obj.nextDouble(); } + scInp1Obj.close(); } } \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section9/FindUniqueCharsOfText.java b/src/main/java/com/udemy/sdetintcod/section9/FindUniqueCharsOfText.java new file mode 100644 index 0000000..29f72f0 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section9/FindUniqueCharsOfText.java @@ -0,0 +1,41 @@ +package com.udemy.sdetintcod.section9; +import java.util.HashMap; +import java.util.Map; +import java.util.Scanner; + +public class FindUniqueCharsOfText { + + public static void main(String[] args) { + Scanner scIn=new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInptText=scIn.nextLine(); + System.out.println("\n********** Unique Items from input text **************\n"); + FindUniqueCharsFromInputText(strInptText); + scIn.close(); + } + + private static void FindUniqueCharsFromInputText(String strInptText) { + // Initialization of hasMap to keep track of input chars and its repetation + // count. + Map charMaps = new HashMap<>(); + + // Traverse through each 'Character' of input text. + for (Character chItems : strInptText.toCharArray()) { + //If current 'Character' key already exists into map then update the current item with Map value +1. + if (charMaps.containsKey(chItems)) { + charMaps.put(chItems,charMaps.get(chItems)+1); + } else { + //If current 'Character' key exists into 'charMaps' only once then update the value w.r.t key as 1. + charMaps.put(chItems,1); + } + } + + // Iterate through 'charMaps' + for (Map.Entry charMapEntry : charMaps.entrySet()) { + if (charMapEntry.getValue() == 1) { + System.out.print(charMapEntry.getKey() + " "); + } + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section9/RemoveDuplicateCharsFromText.java b/src/main/java/com/udemy/sdetintcod/section9/RemoveDuplicateCharsFromText.java new file mode 100644 index 0000000..4e3eea6 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section9/RemoveDuplicateCharsFromText.java @@ -0,0 +1,30 @@ +package com.udemy.sdetintcod.section9; +import java.util.Scanner; + +public class RemoveDuplicateCharsFromText { + + public static void main(String[] args) { + Scanner scIn=new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInptText=scIn.nextLine(); + System.out.println("\nDuplicate charecter removed text : "+removeDuplicateCharsOfInputText(strInptText)); + scIn.close(); + } + + private static String removeDuplicateCharsOfInputText(String strInptText) { + //Diclaration of mutable stringBuilder for better manipulation performance + StringBuilder strBuildObj=new StringBuilder(); + //diclaration of boolean array of size 256 for possible character sets (ASCII Set) + boolean[] blnSeen=new boolean[256]; + + for (char currItems:strInptText.toCharArray()) { + if (!blnSeen[currItems]) { + blnSeen[currItems]=true; + strBuildObj.append(currItems); + } + } + return strBuildObj.toString(); + } + + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section9/ReverseOnlyAlternateWordsEachCharsOfInputText.java b/src/main/java/com/udemy/sdetintcod/section9/ReverseOnlyAlternateWordsEachCharsOfInputText.java index f8951f3..e200852 100644 --- a/src/main/java/com/udemy/sdetintcod/section9/ReverseOnlyAlternateWordsEachCharsOfInputText.java +++ b/src/main/java/com/udemy/sdetintcod/section9/ReverseOnlyAlternateWordsEachCharsOfInputText.java @@ -23,9 +23,8 @@ private static String getOnlyAlternateWordsReverse(String strInptText) { } else { strBuildObj.append(new StringBuilder(strEachWords)).append(" "); } - } - - return strBuildObj.toString().trim(); + } + return strBuildObj.toString().trim(); } } \ No newline at end of file From 119b6afe3e7f89619104612e9a8c3daf19b13f39 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Wed, 13 May 2026 23:44:56 +0530 Subject: [PATCH 13/18] section-7: Linked-Lists and Custom-Stack implimentations. --- .../section7/FindMidElementOfLinkedList.java | 32 +++++++ .../LinkedListsBothEndOperations.java | 35 ++++++++ .../section7/StackDriverEx59OfTwoArrays.java | 31 +++++++ .../sdetintcod/section7/StackOfTwoArrays.java | 90 +++++++++++++++++++ 4 files changed, 188 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section7/FindMidElementOfLinkedList.java create mode 100644 src/main/java/com/udemy/sdetintcod/section7/LinkedListsBothEndOperations.java create mode 100644 src/main/java/com/udemy/sdetintcod/section7/StackDriverEx59OfTwoArrays.java create mode 100644 src/main/java/com/udemy/sdetintcod/section7/StackOfTwoArrays.java diff --git a/src/main/java/com/udemy/sdetintcod/section7/FindMidElementOfLinkedList.java b/src/main/java/com/udemy/sdetintcod/section7/FindMidElementOfLinkedList.java new file mode 100644 index 0000000..db04c34 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section7/FindMidElementOfLinkedList.java @@ -0,0 +1,32 @@ +package com.udemy.sdetintcod.section7; +import java.util.LinkedList; +import java.util.List; +import java.util.Scanner; + +public class FindMidElementOfLinkedList { + + public static void main(String[] args) { + Scanner scin = new Scanner(System.in); + System.out.println("\nEnter the Linked-list capacity : "); + int lnkCapacity = scin.nextInt(); + int midElement=getMidElementOfLinkedList(lnkCapacity); + System.out.println("\nValue of Middle Element : "+midElement); + scin.close(); + } + + private static int getMidElementOfLinkedList(int lnkCapacity) { + Scanner scin = new Scanner(System.in); + List list = new LinkedList<>(); + System.out.println("\nEnter the linked-List items : "); + for (int i = 0; i < lnkCapacity; i++) { + int numDt = scin.nextInt(); + list.add(numDt); + } + System.out.println("\nData Items of Linked-List : " + list); + int midIndex=(list.size()/2); + System.out.println("\nEvaluated mid index position : "+midIndex); + scin.close(); + return list.get(midIndex); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section7/LinkedListsBothEndOperations.java b/src/main/java/com/udemy/sdetintcod/section7/LinkedListsBothEndOperations.java new file mode 100644 index 0000000..fa5c006 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section7/LinkedListsBothEndOperations.java @@ -0,0 +1,35 @@ +package com.udemy.sdetintcod.section7; +import java.util.LinkedList; +import java.util.List; +import java.util.Scanner; + +public class LinkedListsBothEndOperations { + + public static void main(String[] args) { + Scanner scin = new Scanner(System.in); + System.out.println("\nEnter the Linked-list capacity : "); + int lnkCapacity = scin.nextInt(); + doLinkedListBothEndsOperations(lnkCapacity); + scin.close(); + } + + private static void doLinkedListBothEndsOperations(int lnkCapacity) { + Scanner scin = new Scanner(System.in); + List list = new LinkedList<>(); + System.out.println("\nEnter the linked-List items : "); + for (int i = 0; i < lnkCapacity; i++) { + String strDataItem = scin.nextLine(); + list.add(strDataItem); + } + System.out.println("\nData Items of Linked-List : " + list); + System.out.print("Add Element to the first : "); + String strFirstEle = scin.nextLine(); + list.addFirst(strFirstEle); + System.out.print("Add Element to the last : "); + String strEndEle = scin.nextLine(); + list.addLast(strEndEle); + System.out.println("\nLatest data items of Linked-List : " + list); + scin.close(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section7/StackDriverEx59OfTwoArrays.java b/src/main/java/com/udemy/sdetintcod/section7/StackDriverEx59OfTwoArrays.java new file mode 100644 index 0000000..04e92e9 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section7/StackDriverEx59OfTwoArrays.java @@ -0,0 +1,31 @@ +package com.udemy.sdetintcod.section7; +import java.util.Scanner; + +public class StackDriverEx59OfTwoArrays { + + public static void main(String[] args) { + Scanner scin = new Scanner(System.in); + System.out.println("\nEnter the stack capacity : "); + int stkCapacity = scin.nextInt(); + System.out.println("************************************"); + StackOfTwoArrays stackObj=new StackOfTwoArrays(stkCapacity); + System.out.println("\nPush data to stack : "); + for (int i = 0; i < stkCapacity; i++) { + int dataItem=scin.nextInt(); + stackObj.pushToStack(dataItem); + } + stackObj.showStack(); + System.out.println("\nShow me current size of stack : "+stackObj.getCurrentSize()); + System.out.println("\nRemoving items-1 : "+stackObj.popFromStack()); + System.out.println("\nRemoving items-2 : "+stackObj.popFromStack()); + System.out.println("\nGet Peek Element of stack : "+stackObj.getStackPeek()); + stackObj.showStack(); + System.out.println("\nRemoving items-4 : "+stackObj.popFromStack()); + stackObj.showStack(); + System.out.println("\nShow me current size of stack : "+stackObj.getCurrentSize()); + System.out.println("\nEmpty Status of stack : "+stackObj.isStackEmpty()); + + scin.close(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section7/StackOfTwoArrays.java b/src/main/java/com/udemy/sdetintcod/section7/StackOfTwoArrays.java new file mode 100644 index 0000000..8a39b82 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section7/StackOfTwoArrays.java @@ -0,0 +1,90 @@ +package com.udemy.sdetintcod.section7; + +/** + * Entity representation for stack implementations + * + */ +public class StackOfTwoArrays { + + // max size of stack + private int capacity; + // current size of stack + private int size; + // index of top element of stack + private int stackTop; + // to hold stack data. + private int[] dataArray; + // Auxiliary array to keep track of stack index. + private int[] indexArray; + + // Constructor of type + public StackOfTwoArrays(int capacity) { + this.capacity = capacity; + // space allocation of data array + this.dataArray = new int[capacity]; + // space allocation of Auxiliary index array + this.indexArray = new int[capacity]; + // initialization current size of stack + this.size = 0; + // initialization of top elements position. + this.stackTop = -1; + System.out.println("\nStack initialized with initial capacity : " + capacity); + } + + public boolean isStackEmpty() { + return (size == 0); + } + + public int getCurrentSize() { + return size; + } + + public void pushToStack(int dataValue) { + if (size >= capacity) { + System.out.println("\nStack is overflowed! - unable to push item."); + return; + } + stackTop++; + dataArray[stackTop] = dataValue; + indexArray[stackTop] = stackTop; + size++; + System.out.println("\nValue : " + dataValue + " pushed to stack."); + } + + public int popFromStack() { + if (size == 0) { + System.out.println("\nStack is Empty!.."); + return -1; + } + int popedValued = dataArray[stackTop]; + stackTop--; + size--; + System.out.println("\nValue : " + popedValued + " removed/pop-out from top of stack."); + return popedValued; + } + + public int getStackPeek() { + if (size == 0) { + System.out.println("\nStack is Empty!.."); + return -1; + } + int peekElement = dataArray[stackTop]; + System.out.println("\nValue : " + peekElement + " peeked at top of stack."); + return peekElement; + } + + public void showStack() { + System.out.println("**************************************"); + System.out.println("\nContent of data-array : "); + for (int i = 0; i < getCurrentSize(); i++) { + System.out.print(dataArray[i] + ", "); + } + System.out.println(" "); + System.out.println("\nContent of index-array : "); + for (int i = 0; i < getCurrentSize(); i++) { + System.out.print(indexArray[i] + ", "); + } + System.out.println("\n"); + } + +} \ No newline at end of file From 20e698548f9ab7d4a14a9c7ce6bfcd55f67a1807 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Sat, 16 May 2026 20:17:47 +0530 Subject: [PATCH 14/18] Sec-8: latest problem 4 sols with two pointers approach. --- .../section8/FindPairOfTargetSum.java | 54 +++++++++++++++++++ ...InPlaceReversalOfArraysWithTwoPointer.java | 32 +++++++++++ .../IntersectionOfTwoSortedArrays.java | 51 ++++++++++++++++++ .../TwoPointersMoveAllZerosToRight.java | 33 ++++++++++++ 4 files changed, 170 insertions(+) create mode 100644 src/main/java/com/udemy/sdetintcod/section8/FindPairOfTargetSum.java create mode 100644 src/main/java/com/udemy/sdetintcod/section8/InPlaceReversalOfArraysWithTwoPointer.java create mode 100644 src/main/java/com/udemy/sdetintcod/section8/IntersectionOfTwoSortedArrays.java create mode 100644 src/main/java/com/udemy/sdetintcod/section8/TwoPointersMoveAllZerosToRight.java diff --git a/src/main/java/com/udemy/sdetintcod/section8/FindPairOfTargetSum.java b/src/main/java/com/udemy/sdetintcod/section8/FindPairOfTargetSum.java new file mode 100644 index 0000000..2d38e22 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section8/FindPairOfTargetSum.java @@ -0,0 +1,54 @@ +package com.udemy.sdetintcod.section8; +import java.util.Arrays; +import java.util.Scanner; + +public class FindPairOfTargetSum { + + public static void main(String[] args) { + Scanner scInp = new Scanner(System.in); + int[] inpArry = { 1, 2, 4, 7, 11, 15 }; + System.out.println("\nInput Array : " + Arrays.toString(inpArry)); + System.out.println("\nEnter the traget value : "); + int target = scInp.nextInt(); + + if (isPairOfTargetSumExists(inpArry, target)) { + System.out.println("\nYes, a pair of given sum exists."); + } else { + System.out.println("\nNo Pair! available for given target sum."); + } + scInp.close(); + } + + private static boolean isPairOfTargetSumExists(int[] inpArry, int target) { + boolean blnResult = false; + // Initialization of 'left' and 'right' index pointers. + int left = 0; + int right = inpArry.length - 1; + + // Traverse through array elements. + while (left < right) { + // evaluation of current sum w.r.t 'left' and 'right' index + int currentSum = inpArry[left] + inpArry[right]; + + // Step-1:Check Condition if 'target' matched with 'currentSum' + if (currentSum == target) { + System.out.println("\nPair : ( " + inpArry[left] + " , " + inpArry[right] + " )"); + return blnResult=true; + } + + // Step-2:VVIP to Check Condition if 'currentSum' is < 'target' + else if (currentSum < target) { + // Required pair should be available to right part of array , hence adjust + // 'left' index. + left++; + } else { + // Required pair should be available to left part of array , hence adjust + // 'right' index. + right--; + } + } + + return blnResult; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section8/InPlaceReversalOfArraysWithTwoPointer.java b/src/main/java/com/udemy/sdetintcod/section8/InPlaceReversalOfArraysWithTwoPointer.java new file mode 100644 index 0000000..8f1cec1 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section8/InPlaceReversalOfArraysWithTwoPointer.java @@ -0,0 +1,32 @@ +package com.udemy.sdetintcod.section8; +import java.util.Arrays; + +public class InPlaceReversalOfArraysWithTwoPointer { + + public static void main(String[] args) { + int[] arr = {1, 2, 3, 4, 5}; + System.out.println("\nInput array : "+Arrays.toString(arr)); + performInPlaceReversal(arr); + System.out.println("\nIn-Place Reversed array with two pointers : "+Arrays.toString(arr)); + } + + private static void performInPlaceReversal(int[] arr) { + // initialization of two pointers + int left = 0; + int right = arr.length - 1; + + // Traverse through array elements + while (left < right) { + // perform array elements swapping w.r.t to 'left' and 'right' index. + int tempHold = arr[left]; + arr[left] = arr[right]; + arr[right] = tempHold; + + // move forward 'left' index to right direction of array + left++; + // move forward 'right' index to left direction of array + right--; + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section8/IntersectionOfTwoSortedArrays.java b/src/main/java/com/udemy/sdetintcod/section8/IntersectionOfTwoSortedArrays.java new file mode 100644 index 0000000..f575a56 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section8/IntersectionOfTwoSortedArrays.java @@ -0,0 +1,51 @@ +package com.udemy.sdetintcod.section8; +import java.util.ArrayList; +import java.util.List; + +public class IntersectionOfTwoSortedArrays { + + public static void main(String[] args) { + int[] arr1 = { 1, 1, 2, 2, 2, 4 }; + int[] arr2 = { 2, 2, 4, 4 }; + + int[] arr3 = { 1, 2 }; + int[] arr4 = { 3, 4 }; + + int[] arr5 = { 1, 2, 3 }; + int[] arr6 = { 1, 2, 3 }; + + List interList = getIntersectedListItems(arr1, arr2); + System.out.println("\nValue of intersected list : " + interList); + + List inter2List = getIntersectedListItems(arr3, arr4); + System.out.println("\nValue of intersected-1 list : " + inter2List); + + List inter3List = getIntersectedListItems(arr5, arr6); + System.out.println("\nValue of intersected-2 list : " + inter3List); + } + + private static List getIntersectedListItems(int[] arr1, int[] arr2) { + List resultList = new ArrayList<>(); + // Initialization of two pointers - one for each array. + int left = 0; + int right = 0; + + while (left < arr1.length && right < arr2.length) { + // step-1:check condition for equality of elements + if (arr1[left] == arr2[right]) { + resultList.add(arr1[left]); + left++; + right++; + } + // step-2:check condition for element at left position is < element at right position + else if (arr1[left] < arr2[right]) { + left++; + } else { + // step-3:check condition for element at left position is > element at right position + right++; + } + } + return resultList; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section8/TwoPointersMoveAllZerosToRight.java b/src/main/java/com/udemy/sdetintcod/section8/TwoPointersMoveAllZerosToRight.java new file mode 100644 index 0000000..09ca196 --- /dev/null +++ b/src/main/java/com/udemy/sdetintcod/section8/TwoPointersMoveAllZerosToRight.java @@ -0,0 +1,33 @@ +package com.udemy.sdetintcod.section8; +import java.util.Arrays; + +public class TwoPointersMoveAllZerosToRight { + + public static void main(String[] args) { + int[] inpNumArr={5,6,0,7,0,66,9,0,100,10,0,11}; + System.out.println("\nInput Data Array : "+Arrays.toString(inpNumArr)); + moveAllZerosToRightEnd(inpNumArr); + System.out.println("\nTransformed Array after moving all zeros to right end : "+Arrays.toString(inpNumArr)); + } + + private static void moveAllZerosToRightEnd(int[] inpNumArr) { + // non-zero elements index initialization. + int nonZeroIndex = 0; + + //Traverse through input array. + for (int i = 0; i < inpNumArr.length; i++) { + //Condition to check non-zero elements + if (inpNumArr[i] != 0) { + if (i != nonZeroIndex) { + //Swap current array element with 'nonZeroIndex' positioned elements + int temp = inpNumArr[i]; + inpNumArr[i] = inpNumArr[nonZeroIndex]; + inpNumArr[nonZeroIndex] = temp; + } + //Move forward the 'nonZeroIndex' + nonZeroIndex++; + } + } + } + +} \ No newline at end of file From 1f381a805eda2ff6728dd226bd0febe0f750c911 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Sun, 19 Jul 2026 20:48:53 +0530 Subject: [PATCH 15/18] Tech SDET with Jatin2026 Solutions till Custom LinkList with LinkedLists Reversals --- .../prep26/arrays/Q1TransposeOf2DMatrix.java | 63 ++++++++++ .../arrays/Q6Q7DuplicateRemovalOfArray.java | 33 +++++ .../Q5MapReversalBySwappingKeyValues.java | 36 ++++++ .../lnklist/CustomLinkedListEntity.java | 119 ++++++++++++++++++ .../lnklist/LinkListPalindromChecker.java | 71 +++++++++++ .../prep26/lnklist/LinkedListReversal.java | 41 ++++++ .../prep26/lnklist/LinkedNode.java | 33 +++++ .../prep26/lnklist/Q4LinkedListDriver.java | 29 +++++ .../Q3AndQ2TextLengthWithoutInbuild.java | 31 +++++ .../RemoveOnlyConsicutiveDuplicates.java | 2 +- 10 files changed, 457 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/udemy/autocodinground/prep26/arrays/Q1TransposeOf2DMatrix.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/arrays/Q6Q7DuplicateRemovalOfArray.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/hashing/Q5MapReversalBySwappingKeyValues.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/lnklist/CustomLinkedListEntity.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkListPalindromChecker.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkedListReversal.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkedNode.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/lnklist/Q4LinkedListDriver.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q3AndQ2TextLengthWithoutInbuild.java diff --git a/src/main/java/com/udemy/autocodinground/prep26/arrays/Q1TransposeOf2DMatrix.java b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q1TransposeOf2DMatrix.java new file mode 100644 index 0000000..11a40b8 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q1TransposeOf2DMatrix.java @@ -0,0 +1,63 @@ +package com.udemy.autocodinground.prep26.arrays; +import java.util.Scanner; + +public class Q1TransposeOf2DMatrix { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter number of Row : "); + int row=scpIn.nextInt(); + System.out.println("\nEnter number of Column : "); + int col=scpIn.nextInt(); + int[][] inputNumArray=new int[row][col]; + if (inputNumArray == null || inputNumArray.length == 0 || inputNumArray[0].length == 0) { + System.out.println("\nTranspose is not!! possible.."); + } else { + genarateInputMatrix(inputNumArray, row, col); + System.out.println("\nResultant Transpose Matrix : "); + performMatrixTranspose(inputNumArray); + } + scpIn.close(); + } + + private static void performMatrixTranspose(int[][] inputNumArray) { + int rowCount = inputNumArray.length; + int colCount = inputNumArray[0].length; + int[][] resutMat=new int[colCount][rowCount]; + + //Traverse through input array 'inputNumArray' w.r.t row x col + for (int row = 0; row < rowCount; row++) { + for (int col = 0; col < colCount; col++) { + //Fill 'resutMat' transpose matrix elements w.r.t col x row with 'inputNumArray' 'row', 'col' + resutMat[col][row]=inputNumArray[row][col]; + } + } + showInputMatrix(resutMat); + } + + private static void genarateInputMatrix(int[][] inputNumArray,int row, int col) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the "+row+" x "+col+" matrix elements : "); + for (int i = 0; i < row; i++) { + for (int j = 0; j < col; j++) { + inputNumArray[i][j]=scpIn.nextInt(); + } + } + showInputMatrix(inputNumArray); + scpIn.close(); + } + + private static void showInputMatrix(int[][] inputMat) { + int rowCount = inputMat.length; + int colCount = inputMat[0].length; + System.out.println("\nValue of "+rowCount+" x "+colCount+" Matrix : "); + for (int i = 0; i < rowCount; i++) { + for (int j = 0; j < colCount; j++) { + System.out.print(inputMat[i][j]+" "); + } + System.out.print("\n"); + } + } + + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/arrays/Q6Q7DuplicateRemovalOfArray.java b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q6Q7DuplicateRemovalOfArray.java new file mode 100644 index 0000000..a7f3048 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q6Q7DuplicateRemovalOfArray.java @@ -0,0 +1,33 @@ +package com.udemy.autocodinground.prep26.arrays; +import java.util.Arrays; +import java.util.LinkedHashSet; +import java.util.Set; + +public class Q6Q7DuplicateRemovalOfArray { + + public static void main(String[] args) { + int[] numArray={20,10,30,20,10,40}; + System.out.println("\nInput data array : "+Arrays.toString(numArray)); + int[] uniqueResultSet=duplicateRemovalUsingSet(numArray); + System.out.println("\nUnique resultant data items : "+Arrays.toString(uniqueResultSet)); + quickDuplicateRemovalWithStreams(numArray); + } + + //Implementation using stream(). + private static void quickDuplicateRemovalWithStreams(int[] numArray) { + numArray=Arrays.stream(numArray).distinct().toArray(); + System.out.println("\nResultant unique Data : "+Arrays.toString(numArray)); + } + + //Implementation using Set + private static int[] duplicateRemovalUsingSet(int[] numArray) { + // To store the unique elements by preserving order of element. + Set resultDataSet = new LinkedHashSet<>(); + for (int items : numArray) { + resultDataSet.add(items); + } + //convertion to stream() objects int map using mapToInt() terminal operation to convert back to original array. + return resultDataSet.stream().mapToInt(Integer::intValue).toArray(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/hashing/Q5MapReversalBySwappingKeyValues.java b/src/main/java/com/udemy/autocodinground/prep26/hashing/Q5MapReversalBySwappingKeyValues.java new file mode 100644 index 0000000..dd31844 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/hashing/Q5MapReversalBySwappingKeyValues.java @@ -0,0 +1,36 @@ +package com.udemy.autocodinground.prep26.hashing; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Scanner; + +public class Q5MapReversalBySwappingKeyValues { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nHow manay Entrys you want to added into your map : "); + int mapSize = scpIn.nextInt(); + performMapReversalBySwappingKeyValues(mapSize); + scpIn.close(); + } + + private static void performMapReversalBySwappingKeyValues(int mapSize) { + Scanner scpIn = new Scanner(System.in); + // Initialization of Map + Map lnkMap = new LinkedHashMap<>(); + Map reversedMap = new LinkedHashMap<>(); + for (int i = 0; i < mapSize; i++) { + System.out.print("Enter " + (i + 1) + " Value : "); + String lnkValue = scpIn.nextLine(); + lnkMap.put(i,lnkValue); + } + System.out.println("\nInput Map : "+lnkMap); + + for (Map.Entry entry : lnkMap.entrySet()) { + reversedMap.put(entry.getValue(), entry.getKey()); + } + + System.out.println("\nTransformed Revered Map : "+reversedMap); + scpIn.close(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/lnklist/CustomLinkedListEntity.java b/src/main/java/com/udemy/autocodinground/prep26/lnklist/CustomLinkedListEntity.java new file mode 100644 index 0000000..7704992 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/lnklist/CustomLinkedListEntity.java @@ -0,0 +1,119 @@ +package com.udemy.autocodinground.prep26.lnklist; + +public class CustomLinkedListEntity { + + LinkedNode headNode=null; + LinkedNode tailNode=null; + private int size; + + /** + * @return the headNode + */ + public LinkedNode getHeadNode() { + return headNode; + } + + /** + * @return the tailNode + */ + public LinkedNode getTailNode() { + return tailNode; + } + + /** + * @return the size + */ + public int getSize() { + return size; + } + + public void insertAtHead(T inptData) { + LinkedNode currentTmpNd = new LinkedNode<>(inptData); + if (headNode == null) { + insertAtTail(inptData); + } else { + currentTmpNd.setNextRef(headNode); + headNode = currentTmpNd; + size++; + } + } + + public void insertAtTail(T inptData) { + LinkedNode currentTmpNd = new LinkedNode<>(inptData); + if (headNode == null) { + headNode=tailNode=currentTmpNd; + } else { + tailNode.setNextRef(currentTmpNd); + } + tailNode=currentTmpNd; + size++; + } + + + public void insertAt(int index,T inptData) { + if (index==0) { + insertAtHead(inptData); + return; + } + if (index==getSize()) { + insertAtTail(inptData); + return; + } + if (index<0 || index>getSize()) { + System.out.println("\nInsertion not possible!!.."); + return; + } + LinkedNode currentTempHead=headNode; + LinkedNode newNode = new LinkedNode<>(inptData); + for (int i=1; i<=index-1; i++) { + currentTempHead=currentTempHead.getNextRef(); + } + newNode.getNextRef().setNextRef(currentTempHead.getNextRef()); + currentTempHead.getNextRef().setNextRef(newNode); + + size++; + } + + + public void removeAt(int index) { + if (index==0) { + headNode.setNextRef(headNode.getNextRef()); + size--; + return; + } + if (index<0 || index>getSize()) { + System.out.println("Insertion not possible!!.."); + return; + } + LinkedNode currentTempHead=headNode; + for (int i=1; i<=index-1; i++) { + currentTempHead=currentTempHead.getNextRef(); + } + currentTempHead.getNextRef().setNextRef(currentTempHead.getNextRef().getNextRef()); + headNode=currentTempHead; + + size--; + } + + public void viewLinkLists() { + System.out.println("\nExisting link-List item count : " + getSize()); + LinkedNode currentTempHead = headNode; + while (currentTempHead != null) { + System.out.print(currentTempHead.getDataItem() + "--> "); + currentTempHead = currentTempHead.getNextRef(); + } + System.out.println(" "); + } + + + public void viewLinkLists(LinkedNode headNode) { + System.out.println("\nHead-Passed Existing link-List item count : " + getSize()); + LinkedNode currentTempHead = headNode; + while (currentTempHead != null) { + System.out.print(currentTempHead.getDataItem() + "--> "); + currentTempHead = currentTempHead.getNextRef(); + } + System.out.println(" "); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkListPalindromChecker.java b/src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkListPalindromChecker.java new file mode 100644 index 0000000..c3e5daf --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkListPalindromChecker.java @@ -0,0 +1,71 @@ +package com.udemy.autocodinground.prep26.lnklist; + +public class LinkListPalindromChecker { + + public static void main(String[] args) { + CustomLinkedListEntity lnkObjs=new CustomLinkedListEntity<>(); + lnkObjs.insertAtHead(1); + lnkObjs.insertAt(1,2); + lnkObjs.insertAt(2,3); + lnkObjs.insertAt(3,2); + lnkObjs.insertAtTail(1); + lnkObjs.viewLinkLists(); + String palStatus=(isLinkListPalindrom(lnkObjs.getHeadNode()))?"is Palindrom.":"not Palindrom."; + System.out.println(palStatus); + + CustomLinkedListEntity lnk2Objs=new CustomLinkedListEntity<>(); + lnk2Objs.insertAtHead(1); + lnk2Objs.insertAt(1,2); + lnk2Objs.insertAtTail(3); + lnk2Objs.viewLinkLists(); + String pal2Status=(isLinkListPalindrom(lnk2Objs.getHeadNode()))?"is Palindrom.":"not Palindrom."; + System.out.println(pal2Status); + } + + + private static LinkedNode performLinkedListReversal(LinkedNode currentHead) { + if (currentHead==null || currentHead.getNextRef()==null) { + return currentHead; + } + LinkedNode currentNode = currentHead; + LinkedNode prevNode = null; + LinkedNode afterNode = null; + + while (currentNode != null) { + afterNode = currentNode.getNextRef(); + currentNode.setNextRef(prevNode); + prevNode = currentNode; + currentNode = afterNode; + } + return prevNode; + } + + + private static LinkedNode getMidNode(LinkedNode currentHead) { + LinkedNode slowNode = currentHead; + LinkedNode fastNode = currentHead; + + while (fastNode != null && fastNode.getNextRef() != null) { + slowNode = slowNode.getNextRef(); + fastNode = fastNode.getNextRef().getNextRef(); + } + return slowNode; + } + + private static boolean isLinkListPalindrom(LinkedNode currentHead) { + boolean result = true; + LinkedNode p1 = currentHead; + LinkedNode midNode = getMidNode(currentHead); + LinkedNode p2 = performLinkedListReversal(midNode); + + while (p2 != null) { + if (p1.getDataItem() != p2.getDataItem()) { + return result = false; + } + p1 = p1.getNextRef(); + p2 = p2.getNextRef(); + } + return result; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkedListReversal.java b/src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkedListReversal.java new file mode 100644 index 0000000..af5c8fe --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkedListReversal.java @@ -0,0 +1,41 @@ +package com.udemy.autocodinground.prep26.lnklist; + +public class LinkedListReversal { + + public static void main(String[] args) { + CustomLinkedListEntity lnkObjs=new CustomLinkedListEntity<>(); + lnkObjs.insertAtHead(0); + lnkObjs.insertAt(1,50); + lnkObjs.insertAt(2,100); + lnkObjs.insertAt(3,150); + lnkObjs.insertAt(4,200); + lnkObjs.insertAt(5,250); + lnkObjs.insertAtTail(500); + lnkObjs.insertAt(7,300); + lnkObjs.insertAtHead(25); + lnkObjs.viewLinkLists(); + LinkedNode currentTempHead=lnkObjs.getHeadNode(); + LinkedNode revLnkListHead=performLinkedListReversal(currentTempHead); + + System.out.println("\nThe reversed linked-List :"); + lnkObjs.viewLinkLists(revLnkListHead); + } + + private static LinkedNode performLinkedListReversal(LinkedNode currentHead) { + if (currentHead==null || currentHead.getNextRef()==null) { + return currentHead; + } + LinkedNode currentNode = currentHead; + LinkedNode prevNode = null; + LinkedNode afterNode = null; + + while (currentNode != null) { + afterNode = currentNode.getNextRef(); + currentNode.setNextRef(prevNode); + prevNode = currentNode; + currentNode = afterNode; + } + return prevNode; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkedNode.java b/src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkedNode.java new file mode 100644 index 0000000..ff6791b --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/lnklist/LinkedNode.java @@ -0,0 +1,33 @@ +package com.udemy.autocodinground.prep26.lnklist; + +public class LinkedNode { + + private T dataItem; + private LinkedNode nextRef; + + public LinkedNode(T dataItem) { + this.dataItem = dataItem; + } + + /** + * @return the dataItem + */ + public T getDataItem() { + return dataItem; + } + + /** + * @return the nextRef + */ + public LinkedNode getNextRef() { + return nextRef; + } + + /** + * @param nextRef the nextRef to set + */ + public void setNextRef(LinkedNode nextRef) { + this.nextRef = nextRef; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/lnklist/Q4LinkedListDriver.java b/src/main/java/com/udemy/autocodinground/prep26/lnklist/Q4LinkedListDriver.java new file mode 100644 index 0000000..f9d78ab --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/lnklist/Q4LinkedListDriver.java @@ -0,0 +1,29 @@ +package com.udemy.autocodinground.prep26.lnklist; + +public class Q4LinkedListDriver { + + public static void main(String[] args) { + CustomLinkedListEntity custObj1=new CustomLinkedListEntity<>(); + custObj1.insertAtHead(2939); + custObj1.insertAtTail(6666); + custObj1.insertAt(2,99000); + custObj1.insertAt(3,111111); + custObj1.insertAt(4,121); + custObj1.insertAt(5,33333); + custObj1.viewLinkLists(); + + CustomLinkedListEntity custObj2=new CustomLinkedListEntity<>(); + custObj2.insertAtHead("SDET"); + custObj2.insertAtHead("Atif"); + custObj2.insertAtTail("ITCI"); + custObj2.insertAtHead("ANDROID-16"); + custObj2.insertAt(4,"Java-17-SDK"); + custObj2.insertAt(5,"Carat:ame"); + custObj2.insertAtTail("Abhinay"); + custObj2.viewLinkLists(); + custObj2.removeAt(3); + custObj2.removeAt(2); + custObj2.viewLinkLists(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q3AndQ2TextLengthWithoutInbuild.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q3AndQ2TextLengthWithoutInbuild.java new file mode 100644 index 0000000..5d2e828 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q3AndQ2TextLengthWithoutInbuild.java @@ -0,0 +1,31 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.Scanner; + +public class Q3AndQ2TextLengthWithoutInbuild { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInputText=scpIn.nextLine(); + evaluateLenOfInputText(strInputText); + scpIn.close(); + } + + private static void evaluateLenOfInputText(String strInputText) { + int lenCount = 0; + while (true) { + try { + char chItem=strInputText.charAt(lenCount); + //Move forward the 'lenCount' + lenCount++; + System.out.println("\nInput charecter : "+chItem); + } catch (StringIndexOutOfBoundsException e) { + //when charAt() encountered with exception this block will executed. + System.out.println("\nLength of input text : '" + strInputText + "' is : " + lenCount); + // Vital step to terminate the loop after exception. + break; + } + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/sdetintcod/section4/RemoveOnlyConsicutiveDuplicates.java b/src/main/java/com/udemy/sdetintcod/section4/RemoveOnlyConsicutiveDuplicates.java index 0c97c99..c9ece8a 100644 --- a/src/main/java/com/udemy/sdetintcod/section4/RemoveOnlyConsicutiveDuplicates.java +++ b/src/main/java/com/udemy/sdetintcod/section4/RemoveOnlyConsicutiveDuplicates.java @@ -41,7 +41,7 @@ private static void removeOnlyConsicutiveDuplicatesRepeatedChars(String textInpu isConsecutiveDuplicate = true; } - // Strictly append only if it is a consecutive duplicate + // Strictly append only if it is a non-consecutive duplicate if (!isConsecutiveDuplicate) { result.append(current); } From 364c8b0abfa0fda97755cc8f781250b0b26dff57 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Wed, 22 Jul 2026 01:02:22 +0530 Subject: [PATCH 16/18] Added latest string oriented problem solvings tech-with-jathin-Q89-10-12-13 --- .../Q10Q11Find2ndMaxNumFromAlphanumText.java | 62 +++++++++++++++++++ .../Q12CharCountWithoutTrailingSpaces.java | 33 ++++++++++ .../strings/Q13CountFrequencyOfWords.java | 34 ++++++++++ ...ReverseFirstWordByKeepingOthersIntact.java | 41 ++++++++++++ .../Q9CountUpperCaseAndLowerCaseChars.java | 34 ++++++++++ 5 files changed, 204 insertions(+) create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q10Q11Find2ndMaxNumFromAlphanumText.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q12CharCountWithoutTrailingSpaces.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q13CountFrequencyOfWords.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q8ReverseFirstWordByKeepingOthersIntact.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q9CountUpperCaseAndLowerCaseChars.java diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q10Q11Find2ndMaxNumFromAlphanumText.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q10Q11Find2ndMaxNumFromAlphanumText.java new file mode 100644 index 0000000..10c7c87 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q10Q11Find2ndMaxNumFromAlphanumText.java @@ -0,0 +1,62 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.Scanner; +import java.util.TreeSet; + +public class Q10Q11Find2ndMaxNumFromAlphanumText { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInputText = scpIn.nextLine(); + get2ndMaxNumFromInputText(strInputText); + System.out.println("\nEnter the 2nd input text : "); + String strInput2Text = scpIn.nextLine(); + int secMaxNum=extract2ndMaxNumFromText(strInput2Text); + System.out.println("\n2nd Max number from input text : "+secMaxNum); + scpIn.close(); + } + + private static int extract2ndMaxNumFromText(String strInput2Text) { + if (strInput2Text == null || strInput2Text.isEmpty()) { + System.out.println("\nOperation not possible as input text : " + strInput2Text); + return Integer.MIN_VALUE; + } + int maxNum; + TreeSet sortedSetDat = new TreeSet<>(); + for (char charItems : strInput2Text.toCharArray()) { + if (Character.isDigit(charItems)) { + // Character to Integer conversion w.r.t ASCII sub-stractions + int evalNum = charItems - '0'; + sortedSetDat.add(evalNum); + } + } + // Delete max num from set. + maxNum = sortedSetDat.pollLast(); + maxNum = sortedSetDat.getLast(); + return maxNum; + } + + private static void get2ndMaxNumFromInputText(String strInputText) { + if (strInputText == null || strInputText.isEmpty()) { + System.out.println("\nOperation not possible as input text : " + strInputText); + return; + } + int maxNum = Integer.MIN_VALUE; + int secMaxNum = Integer.MIN_VALUE; + for (char charItems : strInputText.toCharArray()) { + if (Character.isDigit(charItems)) { + System.out.println("Numberic Char Items : " + charItems); + // Corresponding integer value w.r.t ASCII sub-stration. + int evalNum = charItems - '0'; + if (evalNum > maxNum) { + secMaxNum = maxNum; + maxNum = evalNum; + } else if (evalNum > secMaxNum && secMaxNum < maxNum) { + secMaxNum = evalNum; + } + } + } + System.out.println("\n2nd Max number from input text : '" + strInputText + "' is : " + secMaxNum); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q12CharCountWithoutTrailingSpaces.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q12CharCountWithoutTrailingSpaces.java new file mode 100644 index 0000000..00f60b3 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q12CharCountWithoutTrailingSpaces.java @@ -0,0 +1,33 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.Scanner; + +public class Q12CharCountWithoutTrailingSpaces { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInputText = scpIn.nextLine(); + getCharCountWithWithoutTrailingWhiteSpaces(strInputText); + scpIn.close(); + } + + private static void getCharCountWithWithoutTrailingWhiteSpaces(String strInputText) { + if (strInputText == null || strInputText.isEmpty()) { + System.out.println("\nOperation not possible as input text : " + strInputText); + return; + } + int charCount = 0; + for (int i = 0; i < strInputText.length(); i++) { + if (strInputText.charAt(i) == ' ') { + continue; + } + boolean isAfterTrailSpace = (i < strInputText.length() - 1 && strInputText.charAt(i + 1) == ' '); + boolean isBeforeTrailSpace = (i > 0 && strInputText.charAt(i - 1) == ' '); + if (!isAfterTrailSpace && !isBeforeTrailSpace) { + charCount++; + } + } + System.out.println("\nCharecter count without trailing whilte-spaces : " + charCount); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q13CountFrequencyOfWords.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q13CountFrequencyOfWords.java new file mode 100644 index 0000000..77d2658 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q13CountFrequencyOfWords.java @@ -0,0 +1,34 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.HashMap; +import java.util.Map; +import java.util.Scanner; + +public class Q13CountFrequencyOfWords { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInputText = scpIn.nextLine(); + countFrequencyOfWordsFromInputText(strInputText); + scpIn.close(); + } + + private static void countFrequencyOfWordsFromInputText(String strInputText) { + if (strInputText.isEmpty() || strInputText == null) { + System.out.println("\nOperation not possible as input text : " + strInputText); + return; + } + Map hasMpObj = new HashMap<>(); + String[] inputWords = strInputText.split(" "); + for (String strWordItems:inputWords) { + hasMpObj.put(strWordItems, hasMpObj.getOrDefault(strWordItems, 0) + 1); + } + + for (Map.Entry entry : hasMpObj.entrySet()) { + String key = entry.getKey(); + Integer vals = entry.getValue(); + System.out.println("\n " + key + " ==> " + vals + " "); + } + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q8ReverseFirstWordByKeepingOthersIntact.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q8ReverseFirstWordByKeepingOthersIntact.java new file mode 100644 index 0000000..d1f2b57 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q8ReverseFirstWordByKeepingOthersIntact.java @@ -0,0 +1,41 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.Scanner; + +public class Q8ReverseFirstWordByKeepingOthersIntact { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInputText = scpIn.nextLine(); + reverseFirstWordFromInputText(strInputText); + scpIn.close(); + } + + private static void reverseFirstWordFromInputText(String strInputText) { + if (strInputText == null || strInputText.isEmpty()) { + System.out.println("\nOperation not possible as input text : "+strInputText); + return; + } + //Splitting the entire input text only into String[] of size 2 for effecient computation. + String[] strWordArr=strInputText.split(" ", 2); + //Char array conversion from string + char[] firstWordCharArr=strWordArr[0].toCharArray(); + String strRevWord=reverseFirstWord(firstWordCharArr); + String strResult=strRevWord+" "+strWordArr[1]; + System.out.println("\nResultant Output : "+strResult); + } + + private static String reverseFirstWord(char[] firstWordCharArr) { + int left = 0; + int right = firstWordCharArr.length - 1; + while (left < right) { + char strRevRes = firstWordCharArr[left]; + firstWordCharArr[left] = firstWordCharArr[right]; + firstWordCharArr[right] = strRevRes; + left++; + right--; + } + return String.valueOf(firstWordCharArr); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q9CountUpperCaseAndLowerCaseChars.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q9CountUpperCaseAndLowerCaseChars.java new file mode 100644 index 0000000..843cea9 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q9CountUpperCaseAndLowerCaseChars.java @@ -0,0 +1,34 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.Scanner; + +public class Q9CountUpperCaseAndLowerCaseChars { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInputText = scpIn.nextLine(); + countUpperCaseAndLowerCaseCharsFromInputText(strInputText); + scpIn.close(); + } + + private static void countUpperCaseAndLowerCaseCharsFromInputText(String strInputText) { + if (strInputText == null || strInputText.isEmpty()) { + System.out.println("\nOperation not possible as input text : " + strInputText); + return; + } + int upperCount = 0; + int lowerCount = 0; + for (char charItems : strInputText.toCharArray()) { + if (Character.isUpperCase(charItems)) { + System.out.println("Upper Char : "+charItems); + upperCount++; + } + if (Character.isLowerCase(charItems)) { + System.out.println("Lower Char : "+charItems); + lowerCount++; + } + } + System.out.println("\nUpper Case chars count : " + upperCount + " , Lower Case chars count : " + lowerCount + " "); + } + +} \ No newline at end of file From a0d2499cb6c681c1c8d1d86e7ee3c037a46f6ed3 Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Wed, 29 Jul 2026 17:38:19 +0530 Subject: [PATCH 17/18] Added latest Strings,Array standard problems till Question-23 tech-with-Jatin-SDET. --- ...arrangingAllEvensToLeftAndOddsToRight.java | 52 +++++++++++ .../Q16Reverse1stAnd2ndHalfOfArray.java | 90 +++++++++++++++++++ .../Q17Q18ArrayRotationByKPosition.java | 71 +++++++++++++++ .../arrays/Q22MountainArrayChecker.java | 56 ++++++++++++ .../prep26/arrays/Q23LeaderNumber.java | 29 ++++++ .../strings/Q15SumOfNumsFromSentence.java | 28 ++++++ .../strings/Q19Q20ReverseEachWords.java | 46 ++++++++++ 7 files changed, 372 insertions(+) create mode 100644 src/main/java/com/udemy/autocodinground/prep26/arrays/Q14RearrangingAllEvensToLeftAndOddsToRight.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/arrays/Q16Reverse1stAnd2ndHalfOfArray.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/arrays/Q17Q18ArrayRotationByKPosition.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/arrays/Q22MountainArrayChecker.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/arrays/Q23LeaderNumber.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q15SumOfNumsFromSentence.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q19Q20ReverseEachWords.java diff --git a/src/main/java/com/udemy/autocodinground/prep26/arrays/Q14RearrangingAllEvensToLeftAndOddsToRight.java b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q14RearrangingAllEvensToLeftAndOddsToRight.java new file mode 100644 index 0000000..0122ee8 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q14RearrangingAllEvensToLeftAndOddsToRight.java @@ -0,0 +1,52 @@ +package com.udemy.autocodinground.prep26.arrays; +import java.util.Arrays; + +public class Q14RearrangingAllEvensToLeftAndOddsToRight { + + public static void main(String[] args) { + // Data set1 + int[] numArray = { 20, 10, 30, 20, 10, 40, 50, 5, 7, 25, 16, 21 }; + System.out.println("\nInput data array : " + Arrays.toString(numArray)); + rearrangingAllEvensToLeftEndOddsToRightEnd(numArray); + + // Data set2 + int[] num2Array = { 3,9,55,32,44,121,500,137,23,34,6,15,115 }; + System.out.println("\nInput data2 array : " + Arrays.toString(num2Array)); + rearrangingAllEvensToLeftEndOddsToRightEnd(num2Array); + } + + private static void rearrangingAllEvensToLeftEndOddsToRightEnd(int[] numArray) { + int left = 0; + int right = numArray.length - 1; + + while (left < right) { + // Move the left pointer forward if the number is already even + while (left < right && numArray[left] % 2 == 0) { + left++; + } + + // Move the right pointer backward if the number is already odd + while (left < right && numArray[right] % 2 != 0) { + right--; + } + + //If left is still less than right, it means we found a misplaced pair. + //Swapping if left part element is odd & right part element is even + if (left < right) { + int temRes = numArray[left]; + numArray[left] = numArray[right]; + numArray[right] = temRes; + left++; + right--; + } + } + int evenEnd=0; + while (evenEnd maxNum) { + secMaxNum = maxNum; + maxNum = numItems; + } else if (numItems > secMaxNum && secMaxNum < maxNum) { + secMaxNum = numItems; + } + } + return secMaxNum; + } + + private static void reverseFirstHalfPartOfArray(int[] numArray) { + int l = 0; + int h = numArray.length - 1; + int mid = l + (h - l) / 2; + System.out.println("\nTotal Length : "+numArray.length+" ; Mid-Index of array : " + mid+" element : "+numArray[mid]); + while (l < mid) { + int temNum = numArray[l]; + numArray[l] = numArray[mid]; + numArray[mid] = temNum; + l++; + mid--; + } + System.out.println("\nResultant Partial 1st-Half Reversed Array : "+Arrays.toString(numArray)); + } + + + private static void reverseLastHalfPartOfArray(int[] numArray) { + int mid=(numArray.length/2); + int l=mid; + int h=numArray.length-1; + System.out.println("\nTotal Length : "+numArray.length+" ; Mid-Index of array : " + mid+" element : "+numArray[mid]); + while (l < h) { + int temNum = numArray[l]; + numArray[l] = numArray[h]; + numArray[h] = temNum; + l++; + h--; + } + System.out.println("\nResultant Partial 2nd-Half Reversed Array : "+Arrays.toString(numArray)); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/arrays/Q17Q18ArrayRotationByKPosition.java b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q17Q18ArrayRotationByKPosition.java new file mode 100644 index 0000000..ed3b6f4 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q17Q18ArrayRotationByKPosition.java @@ -0,0 +1,71 @@ +package com.udemy.autocodinground.prep26.arrays; +import java.util.Arrays; +import java.util.Scanner; + +public class Q17Q18ArrayRotationByKPosition { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + int[] inpNumArray={1, 2, 3, 4, 5, 6, 7}; + System.out.println("\nEnter number of Position you want to rotate : "); + int k=scpIn.nextInt(); + + //Array rotation to right with K position. + rotateRightByKPosition(inpNumArray,k); + + //Array rotation to left with K position. + int[] inp2NumArray={1, 2, 3, 4, 5, 6, 7}; + rotateLeftByKPosition(inp2NumArray,k); + + scpIn.close(); + } + + private static void rotateRightByKPosition(int[] inpNumArray, int k) { + System.out.println("\nInput Array : "+Arrays.toString(inpNumArray)); + int arrLen=inpNumArray.length; + int totalIndex=arrLen-1; + k=(k%arrLen); + + //Step1: Reverse the whole array. + inpNumArray=doTwoPointerReversalBySwapping(inpNumArray, 0, totalIndex); + + //step2: Reverse the array to k-th elements + inpNumArray=doTwoPointerReversalBySwapping(inpNumArray, 0, k-1); + + //step3: Reverse the remaining part of array till end from k-th position + inpNumArray=doTwoPointerReversalBySwapping(inpNumArray, k,totalIndex); + + System.out.println("\nRight rotated array with K="+k+" position : "+Arrays.toString(inpNumArray)); + } + + + private static void rotateLeftByKPosition(int[] inpNumArray, int k) { + System.out.println("\nInput Array : "+Arrays.toString(inpNumArray)); + int arrLen=inpNumArray.length; + int totalIndex=arrLen-1; + k=(k%arrLen); + + //step1: Reverse the array till first k-th elements + inpNumArray=doTwoPointerReversalBySwapping(inpNumArray,0,k-1); + + //step2: Reverse the remaining part of array till end from k-th position + inpNumArray=doTwoPointerReversalBySwapping(inpNumArray,k,totalIndex); + + //Step3: Reverse the whole array. + inpNumArray=doTwoPointerReversalBySwapping(inpNumArray, 0, totalIndex); + + System.out.println("\nLeft rotated array with K="+k+" position : "+Arrays.toString(inpNumArray)); + } + + private static int[] doTwoPointerReversalBySwapping(int[] arryItems, int left, int right) { + while (left < right) { + int numTempHold = arryItems[left]; + arryItems[left] = arryItems[right]; + arryItems[right] = numTempHold; + left++; + right--; + } + return arryItems; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/arrays/Q22MountainArrayChecker.java b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q22MountainArrayChecker.java new file mode 100644 index 0000000..145a16c --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q22MountainArrayChecker.java @@ -0,0 +1,56 @@ +package com.udemy.autocodinground.prep26.arrays; +import java.util.Arrays; + +public class Q22MountainArrayChecker { + + public static void main(String[] args) { + // set1 - check if its a Mountain array + int[] inp1TdArray = { 4, 4, 3, 2, 1 }; + System.out.println("\nCheck If the input array is Mountain type : " + checkIsAMountainArray(inp1TdArray)); + + // set2 - check if its a Mountain array + int[] inp2TdArray = { 1, 2, 3, 4, 9, 8, 7, 6, 5 }; + System.out.println("\nCheck If the input array is Mountain type : " + checkIsAMountainArray(inp2TdArray)); + + // set3 - check if its a Mountain array + int[] inp3TdArray = { 2, 1 }; + System.out.println("\nCheck If the input array is Mountain type : " + checkIsAMountainArray(inp3TdArray)); + + // set4 - check if its a Mountain array + int[] inp4TdArray = { 0, 1, 2, 3, 4, 5 }; + System.out.println("\nCheck If the input array is Mountain type : " + checkIsAMountainArray(inp4TdArray)); + + // set5 - check if its a Mountain array + int[] inp5TdArray = { 0, 3, 2, 1 }; + System.out.println("\nCheck If the input array is Mountain type : " + checkIsAMountainArray(inp5TdArray)); + + } + + private static boolean checkIsAMountainArray(int[] inp2TdArray) { + System.out.println("\nInput Array : " + Arrays.toString(inp2TdArray)); + boolean resultFlag = false; + int arrLen = inp2TdArray.length; + if (inp2TdArray == null || arrLen < 3) { + return resultFlag; + } + int right = arrLen - 1; + int mountCount = 0; + + // 1. Walk up: Move forward as long as elements are strictly increasing + while (mountCount + 1 < arrLen && inp2TdArray[mountCount] < inp2TdArray[mountCount + 1]) { + mountCount++; + } + + // 2. Validate Peak: The peak cannot be the first or the last element + if (mountCount == 0 || mountCount == right) { + return resultFlag; + } + + // 3. Walk down: Move forward as long as elements are strictly decreasing + while (mountCount + 1 < arrLen && inp2TdArray[mountCount] > inp2TdArray[mountCount + 1]) { + mountCount++; + } + return (right == mountCount); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/arrays/Q23LeaderNumber.java b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q23LeaderNumber.java new file mode 100644 index 0000000..b7307a2 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q23LeaderNumber.java @@ -0,0 +1,29 @@ +package com.udemy.autocodinground.prep26.arrays; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class Q23LeaderNumber { + + public static void main(String[] args) { + int[] leadNumArry={16,17,4,3,5,2}; + System.out.println("\nInput Array : "+Arrays.toString(leadNumArry)); + System.out.println("\nResultant leader numbers array : "+Arrays.toString(getLeaderNumbersArray(leadNumArry))); + } + + private static int[] getLeaderNumbersArray(int[] leadNumArry) { + List resultList=new ArrayList<>(); + int firstLeadElement=leadNumArry[leadNumArry.length-1]; + resultList.add(firstLeadElement); + for (int i=leadNumArry.length-2;i>=0;i--) { + int currentEle=leadNumArry[i]; + if (currentEle>firstLeadElement) { + firstLeadElement=currentEle; + resultList.add(firstLeadElement); + } + } + System.out.println("\nLead Elements : "+resultList); + return resultList.stream().mapToInt(Integer::valueOf).toArray(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q15SumOfNumsFromSentence.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q15SumOfNumsFromSentence.java new file mode 100644 index 0000000..47e2e7e --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q15SumOfNumsFromSentence.java @@ -0,0 +1,28 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.Scanner; + +public class Q15SumOfNumsFromSentence { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInputText = scpIn.nextLine(); + int sumOfNums=countSumOfNumbersInputSentence(strInputText); + System.out.println("\nSum of Nums : "+sumOfNums); + scpIn.close(); + } + + private static int countSumOfNumbersInputSentence(String strInputText) { + String[] strWords = strInputText.split(" "); + int resultSums = 0; + for (String letNums : strWords) { + try { + resultSums = resultSums + Integer.parseInt(letNums); + } catch (NumberFormatException e) { + //System.out.println("Exception : " + e); + } + } + return resultSums; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q19Q20ReverseEachWords.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q19Q20ReverseEachWords.java new file mode 100644 index 0000000..249cad1 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q19Q20ReverseEachWords.java @@ -0,0 +1,46 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.Scanner; + +public class Q19Q20ReverseEachWords { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInputText = scpIn.nextLine(); + System.out.println("\nReversal of words using new String() implimentation : "+wordsReversalOfInputText(strInputText)); + System.out.println("\nEffecient Reversal of words using srtBuiders : "+effectiveReversalOfInputText(strInputText)); + scpIn.close(); + } + + private static String effectiveReversalOfInputText(String strInputText) { + StringBuilder strBuildRes = new StringBuilder(); + for (String strEachWords : strInputText.split(" ")) { + strBuildRes = strBuildRes.append(new StringBuilder(strEachWords).reverse()).append(" "); + } + return strBuildRes.toString().trim(); + } + + private static String wordsReversalOfInputText(String strInputText) { + String strResult = ""; + String[] strWordsArr = strInputText.split(" "); + for (String strEachWords : strWordsArr) { + char[] charItems = strEachWords.toCharArray(); + int left = 0; + int right = charItems.length - 1; + strResult += String.valueOf(doTwoPointerCharSwapping(charItems, left, right)) + " "; + } + return strResult.trim(); + } + + private static char[] doTwoPointerCharSwapping(char[] charItems, int left, int right) { + while (left < right) { + char chTempHold = charItems[left]; + charItems[left] = charItems[right]; + charItems[right] = chTempHold; + left++; + right--; + } + return charItems; + } + +} \ No newline at end of file From 1cbbdd92d01aaa61410343ca9775dcb2cde3e5cd Mon Sep 17 00:00:00 2001 From: abhinay5993 Date: Fri, 31 Jul 2026 18:39:32 +0530 Subject: [PATCH 18/18] latest problem solvings on String-Hashing and number-Arrays till Q29. --- .../Q25Q26FindMaxProductTriplatesOfNums.java | 90 +++++++++++++++++++ .../hashing/Q27FindMaxProductQuantity.java | 38 ++++++++ .../Q10Q11Find2ndMaxNumFromAlphanumText.java | 2 +- .../strings/Q24FindUniqueSubString.java | 30 +++++++ .../strings/Q28EncodedCompressedText.java | 34 +++++++ .../strings/Q29DecodingTextSequence.java | 70 +++++++++++++++ 6 files changed, 263 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/udemy/autocodinground/prep26/arrays/Q25Q26FindMaxProductTriplatesOfNums.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/hashing/Q27FindMaxProductQuantity.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q24FindUniqueSubString.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q28EncodedCompressedText.java create mode 100644 src/main/java/com/udemy/autocodinground/prep26/strings/Q29DecodingTextSequence.java diff --git a/src/main/java/com/udemy/autocodinground/prep26/arrays/Q25Q26FindMaxProductTriplatesOfNums.java b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q25Q26FindMaxProductTriplatesOfNums.java new file mode 100644 index 0000000..c7ac4cd --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/arrays/Q25Q26FindMaxProductTriplatesOfNums.java @@ -0,0 +1,90 @@ +package com.udemy.autocodinground.prep26.arrays; +import java.util.Arrays; + +public class Q25Q26FindMaxProductTriplatesOfNums { + + public static void main(String[] args) { + // Set-1 + int[] nums1Arr = { -10, -10, 5, 2, 6 }; + System.out.println("\nMaximum Triplet Product: " + getOptimalMaxProductTriplet(nums1Arr)); + + // Set-2 + int[] nums2Arr = { 10, 3, 5, 6, 20 }; + System.out.println("\nMaximum Triplet Product: " + getOptimalMaxProductTriplet(nums2Arr)); + + // Set-3 + int[] nums3Arr = { -10, -3, -5, -6, -20 }; + System.out.println("\nMaximum Triplet Product: " + getOptimalMaxProductTriplet(nums3Arr)); + + // Set-4 + int[] nums4Arr = { 1, -4, 3, -6, 7, 0 }; + System.out.println("\nMaximum Triplet Product: " + getOptimalMaxProductTriplet(nums4Arr)); + + System.out.println("\n ****************** NON-Optimzed Naive Approach ******************** "); + + System.out.println("\nMaximum Triplet Product: "+nonOptMaxProductTriplet(nums1Arr)); + // Set-5 + int[] nums5Arr = { 1, -4 }; + System.out.println("\nMaximum Triplet Product: " + nonOptMaxProductTriplet(nums5Arr)); + + } + + private static int nonOptMaxProductTriplet(int[] nums1Arr) { + System.out.println("\nInput Data Array : "+Arrays.toString(nums1Arr)); + int arrLen = nums1Arr.length; + if (nums1Arr == null || arrLen < 3) { + System.err.println("\nOperation not!! possible.."); + return -1; + } + //Applying sort operation + Arrays.sort(nums1Arr); + //Picking-up last 3 maximum items from most right end of sorted array + int firstMaxProduct = (nums1Arr[arrLen-1] * nums1Arr[arrLen-2] * nums1Arr[arrLen-3]); + //Picking-up first 2 minimum items from most left end of sorted array + int secMaxProduct = (nums1Arr[0]*nums1Arr[1]*nums1Arr[arrLen-1]); + + System.out.println("\nmax & min product results : ( "+firstMaxProduct+" , "+secMaxProduct+" )"); + int resultMaxTripProdct = (firstMaxProduct > secMaxProduct) ? firstMaxProduct : secMaxProduct; + return resultMaxTripProdct; + } + + private static int getOptimalMaxProductTriplet(int[] nums1Arr) { + System.out.println("\nInput Data Array : "+Arrays.toString(nums1Arr)); + int arrLen = nums1Arr.length; + if (nums1Arr == null || arrLen < 3) { + System.err.println("\nOperation not!! possible.."); + return -1; + } + int max1Num = Integer.MIN_VALUE; + int secMax2Num = Integer.MIN_VALUE; + int thirdMax3Num = Integer.MIN_VALUE; + int min1Num = Integer.MAX_VALUE; + int secMin2Num = Integer.MAX_VALUE; + + for (int numItems : nums1Arr) { + if (numItems > max1Num) { + thirdMax3Num = secMax2Num; + secMax2Num = max1Num; + max1Num = numItems; + } else if (numItems > secMax2Num) { + thirdMax3Num = secMax2Num; + secMax2Num = numItems; + } else if (numItems > thirdMax3Num) { + thirdMax3Num = numItems; + } + + if (numItems < min1Num) { + secMin2Num = min1Num; + min1Num = numItems; + } else if (numItems < secMin2Num) { + secMin2Num = numItems; + } + } + int firstMaxProduct = (max1Num * secMax2Num * thirdMax3Num); + int secMaxProduct = (min1Num * secMin2Num * max1Num); + System.out.println("\nmax & min product results : ( "+firstMaxProduct+" , "+secMaxProduct+" )"); + int resultMaxTripProdct = (firstMaxProduct > secMaxProduct) ? firstMaxProduct : secMaxProduct; + return resultMaxTripProdct; + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/hashing/Q27FindMaxProductQuantity.java b/src/main/java/com/udemy/autocodinground/prep26/hashing/Q27FindMaxProductQuantity.java new file mode 100644 index 0000000..ba0d60a --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/hashing/Q27FindMaxProductQuantity.java @@ -0,0 +1,38 @@ +package com.udemy.autocodinground.prep26.hashing; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +public class Q27FindMaxProductQuantity { + + public static void main(String[] args) { + String[] strProductCatalog={"xyz 9","abc 20","xyz 21","test 56","abc 60"}; + getMaximumQuanityOfProduct(strProductCatalog); + } + + private static void getMaximumQuanityOfProduct(String[] strProductCatalog) { + System.out.println("\nInput data Array : " + Arrays.toString(strProductCatalog)); + int arrLen = strProductCatalog.length; + if (strProductCatalog == null || arrLen == 0) { + System.err.println("\nOperation not!! possible.."); + return; + } + Map hashMap = new HashMap<>(); + for (String strArrItems : strProductCatalog) { + String[] strProductQuant = strArrItems.split(" "); + String strProductName = strProductQuant[0]; + int prodQuantity = Integer.parseInt(strProductQuant[1]); + hashMap.put(strProductName, hashMap.getOrDefault(strProductName, 0) + prodQuantity); + } + int maxProdQuant = Integer.MIN_VALUE; + String strProductName = ""; + for (Map.Entry entry : hashMap.entrySet()) { + if (entry.getValue() > maxProdQuant) { + strProductName = entry.getKey(); + maxProdQuant = entry.getValue(); + } + } + System.out.println("\nMaximum quantity of product : " + strProductName + " => " + maxProdQuant + " "); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q10Q11Find2ndMaxNumFromAlphanumText.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q10Q11Find2ndMaxNumFromAlphanumText.java index 10c7c87..ee9a286 100644 --- a/src/main/java/com/udemy/autocodinground/prep26/strings/Q10Q11Find2ndMaxNumFromAlphanumText.java +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q10Q11Find2ndMaxNumFromAlphanumText.java @@ -25,7 +25,7 @@ private static int extract2ndMaxNumFromText(String strInput2Text) { TreeSet sortedSetDat = new TreeSet<>(); for (char charItems : strInput2Text.toCharArray()) { if (Character.isDigit(charItems)) { - // Character to Integer conversion w.r.t ASCII sub-stractions + // Character to Integer conversion w.r.t ASCII sub-stractions with '0' int evalNum = charItems - '0'; sortedSetDat.add(evalNum); } diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q24FindUniqueSubString.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q24FindUniqueSubString.java new file mode 100644 index 0000000..4c218f7 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q24FindUniqueSubString.java @@ -0,0 +1,30 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.LinkedHashSet; +import java.util.Scanner; +import java.util.Set; + +public class Q24FindUniqueSubString { + + public static void main(String[] args) { + Scanner scpIn = new Scanner(System.in); + System.out.println("\nEnter the input text : "); + String strInputText = scpIn.nextLine(); + System.out.println("\nThe extracted unique sub-string : "+evaluateUniqueSubSting(strInputText)); + scpIn.close(); + } + + private static String evaluateUniqueSubSting(String strInputText) { + if (strInputText == null || strInputText.isEmpty()) { + return strInputText; + } + StringBuilder strBuildObj = new StringBuilder(); + Set lnkHashSet = new LinkedHashSet<>(); + for (char chrItems : strInputText.toCharArray()) { + if (lnkHashSet.add(chrItems)) { + strBuildObj.append(chrItems); + } + } + return strBuildObj.toString(); + } + +} \ No newline at end of file diff --git a/src/main/java/com/udemy/autocodinground/prep26/strings/Q28EncodedCompressedText.java b/src/main/java/com/udemy/autocodinground/prep26/strings/Q28EncodedCompressedText.java new file mode 100644 index 0000000..763b5b9 --- /dev/null +++ b/src/main/java/com/udemy/autocodinground/prep26/strings/Q28EncodedCompressedText.java @@ -0,0 +1,34 @@ +package com.udemy.autocodinground.prep26.strings; +import java.util.Scanner; + +public class Q28EncodedCompressedText { + + public static void main(String[] args) { + Scanner scpIn=new Scanner(System.in); + System.out.print("\nEnter the alphanumeric input text : "); + String strInpText=scpIn.nextLine(); + System.out.println("\nThe resultant Encoded compressed version of text : "+convertToEncodedCompressedText(strInpText)); + scpIn.close(); + } + + private static String convertToEncodedCompressedText(String strInpText) { + if (strInpText == null || strInpText.isEmpty()) { + System.out.println("\nOperation can't be performed.."); + return strInpText; + } + StringBuilder strBuildObj = new StringBuilder(); + int strSrcTextLen = strInpText.length(); + int compOccCount=0; + for (int i = 0; i < strSrcTextLen; i++) { + compOccCount++; + if (i+1==strSrcTextLen || strInpText.charAt(i)!=strInpText.charAt(i+1)) { + strBuildObj.append(strInpText.charAt(i)).append(compOccCount); + // reseting the compOccCount count to 0. + compOccCount=0; + } + } + int lenOfComStr=strBuildObj.toString().length(); + return (lenOfComStr