├── .gitignore ├── src ├── PracticeProblems │ ├── MoveZeroes.java │ ├── FindDuplicates.java │ ├── StockBuySell_2.java │ ├── BinarySearchQuestions │ │ ├── BS_04_find_pivot_element.java │ │ ├── BS_03_peak_in_mountain_Array.java │ │ ├── BS_05_FindSquareRoot.java │ │ ├── BS_00_BinarySearch.java │ │ ├── BS_02_searchInSortedAndRotatedArray.java │ │ ├── AdvanceBinarySearchQuestion │ │ │ ├── BS_05_Roti_Prata_SPOJ.java │ │ │ ├── BS_04_EKO_EKO_SPOJ.java │ │ │ ├── BS_03_aggressive_cows.java │ │ │ ├── BS_01_Books_Allocation.java │ │ │ └── BS_02_PaintersPArtition.java │ │ └── BS_01_left_And_Right_Occurence.java │ ├── KadanesAlgorithm.java │ ├── FindAllDulicates.java │ ├── SearchIn_Infinite_sorted_Array.java │ ├── SortingAlgorithms │ │ ├── SA_02_Insertion_sort.java │ │ ├── SA_01_BubbleSort.java │ │ └── SA_03_Selection_Sort.java │ ├── IntersectinOfArrays.java │ ├── PairSum.java │ ├── Sort0And1.java │ ├── MergeTwoSortedArrays.java │ ├── Sort0_1_and_2.java │ ├── MajorityElements.java │ ├── StockBuySell_1.java │ └── RainWaterTrapping.java ├── Lecture22_charhacterArray │ ├── ReverseWords.java │ ├── First.java │ ├── RemovwSpaces.java │ ├── ValidPalindrome.java │ ├── CheckAlphaNumericOrNot.java │ └── ParenthesisMatching.java ├── lecture10LeetCodeProblems │ ├── DS_02_findUniqueElement.java │ ├── DS_03_findDuplicates.java │ ├── DS_01_SwapAlternates.java │ ├── DS_04_ArrayIntersection.java │ ├── DS_05_twoSum.java │ └── DS_06_findTriplet.java ├── QuestionsTillLec19 │ ├── collectionDemo.java │ ├── ReverseBitsOfBinary.java │ ├── RotateArray.java │ ├── BubbleSort.java │ ├── SelectionSort.java │ ├── SortedArrayIntersection.java │ ├── Sort0And1.java │ ├── AggressiveCows.java │ ├── RainWaterTrapping.java │ ├── MajorityElement.java │ ├── SquareRoot.java │ ├── BubbleSortAdaptive.java │ ├── InsertionSort.java │ ├── EkoSpoj.java │ ├── BooksAllocation.java │ ├── RotiPrata.java │ ├── PaintersPartition.java │ └── Sort0and1and2.java ├── Lecture7LeetCodeProblems │ ├── DS_02_DecimalToBinary.java │ ├── DS_01_BinaryToDecimal.java │ ├── DS_05_complimentOfBaseTen.java │ ├── DS_04_reverseNumber.java │ └── DS_03_powerOfTwo.java ├── Lecture20_questions │ ├── CheckSortesOrRotated.java │ ├── MoveZeroes.java │ └── MergeSortedArray.java ├── lecture14_BinarySearchQuestions │ ├── DS_Q852_peak_index_in_mountain_array.java │ ├── BooksAllocation.java │ ├── FirstOccurence.java │ └── BinarySearch.java ├── Lecture21_questins │ ├── RotareArray.java │ └── AddArrays.java ├── RainWaterTrappingProb.java ├── bubbleSort.java └── InsertAndDeleteInArray │ └── Insertion.java └── dsa with code Babbar.iml /.gitignore: -------------------------------------------------------------------------------- 1 | # Project exclude paths 2 | /out/ -------------------------------------------------------------------------------- /src/PracticeProblems/MoveZeroes.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class MoveZeroes { 4 | public static void main(String[] args) { 5 | 6 | } 7 | 8 | 9 | } 10 | -------------------------------------------------------------------------------- /src/Lecture22_charhacterArray/ReverseWords.java: -------------------------------------------------------------------------------- 1 | package Lecture22_charhacterArray; 2 | 3 | public class ReverseWords { 4 | public static void main(String[] args) { 5 | 6 | } 7 | 8 | static void reverse(String str){ 9 | 10 | 11 | 12 | 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/PracticeProblems/FindDuplicates.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class FindDuplicates { 4 | public static void main(String[] args) { 5 | int[] arr = {1,5,2,6,3,4,8,7,9,9}; 6 | System.out.println(findDuplicate(arr)); 7 | } 8 | 9 | 10 | static int findDuplicate(int[] arr){ 11 | int ans = 0; 12 | for (int i = 0; i < arr.length; i++) 13 | ans = ans ^ arr[i] ^ i; 14 | return ans; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /dsa with code Babbar.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | -------------------------------------------------------------------------------- /src/lecture10LeetCodeProblems/DS_02_findUniqueElement.java: -------------------------------------------------------------------------------- 1 | package lecture10LeetCodeProblems; 2 | 3 | public class DS_02_findUniqueElement { 4 | public static void main(String[] args) { 5 | int[] arr = {1, 1, 3, 3, 5, 6, 5, 7, 8, 7, 8}; 6 | System.out.println(uniqueElement(arr)); 7 | } 8 | 9 | 10 | static int uniqueElement(int[] arr) { 11 | int ans = 0; 12 | for (int i = 0; i < arr.length; i++) { 13 | ans ^= arr[i]; 14 | } 15 | return ans; 16 | } 17 | } -------------------------------------------------------------------------------- /src/PracticeProblems/StockBuySell_2.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class StockBuySell_2 { 4 | public static void main(String[] args) { 5 | int[] arr = {5,2,7,3,6,1,2,4}; 6 | System.out.println(maximixeProfit(arr)); 7 | } 8 | 9 | static int maximixeProfit(int[] arr) { 10 | int profit = 0; 11 | for (int i = 0; i < arr.length - 1; i++) { 12 | if (arr[i] < arr[i + 1]) { 13 | profit += (arr[i + 1] - arr[i]); 14 | } 15 | } 16 | return profit; 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/collectionDemo.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collections; 5 | 6 | 7 | public class collectionDemo { 8 | public static void main(String[] args) { 9 | ArrayList arr = new ArrayList<>(); 10 | arr.add(1); 11 | arr.add(4); 12 | arr.add(6); 13 | arr.add(2); 14 | arr.add(8); 15 | arr.add(3); 16 | System.out.println(arr); 17 | 18 | Collections.sort(arr); 19 | System.out.println(arr); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/ReverseBitsOfBinary.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class ReverseBitsOfBinary { 4 | public static void main(String[] args) { 5 | System.out.println(reverseBits(32)); 6 | } 7 | 8 | static long reverseBits(int num){ 9 | long reverse = 0; 10 | for (int i = 0; i < 32; i++) { 11 | reverse = reverse << 1; 12 | long mask = 1 << i; 13 | if ((num & mask) != 0) 14 | reverse = reverse | 1; 15 | } 16 | 17 | 18 | return reverse; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Lecture7LeetCodeProblems/DS_02_DecimalToBinary.java: -------------------------------------------------------------------------------- 1 | package Lecture7LeetCodeProblems; 2 | 3 | public class DS_02_DecimalToBinary { 4 | public static void main(String[] args) { 5 | int decimal = 13; 6 | System.out.println(toBinary(decimal)); 7 | } 8 | 9 | static int toBinary(int num) { 10 | int binary = 0; 11 | int i = 0; 12 | while (num != 0) { 13 | int bit = num % 2; 14 | binary = binary + bit * (int) Math.pow(10, i++); 15 | num = num / 2; 16 | } 17 | return binary; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Lecture7LeetCodeProblems/DS_01_BinaryToDecimal.java: -------------------------------------------------------------------------------- 1 | package Lecture7LeetCodeProblems; 2 | 3 | public class DS_01_BinaryToDecimal { 4 | public static void main(String[] args) { 5 | int binary = 11; 6 | System.out.println(toDecimal(binary)); 7 | } 8 | 9 | static int toDecimal(int num) { 10 | int decimal = 0; 11 | int i = 0; 12 | while (num != 0) { 13 | int digit = num % 10; 14 | decimal = decimal + digit * (int) Math.pow(2, i++); 15 | num = num / 10; 16 | } 17 | return decimal; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/Lecture7LeetCodeProblems/DS_05_complimentOfBaseTen.java: -------------------------------------------------------------------------------- 1 | package Lecture7LeetCodeProblems; 2 | 3 | public class DS_05_complimentOfBaseTen { 4 | public static void main(String[] args) { 5 | int num = 0; 6 | System.out.println(compliment(num)); 7 | } 8 | 9 | static int compliment(int num) { 10 | if (num == 0) return 1; 11 | int temp = num; 12 | int mask = 0; 13 | while (temp != 0) { 14 | mask = (mask << 1) | 1; 15 | temp >>= 1; 16 | } 17 | int result = mask & (~num); 18 | return result; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/lecture10LeetCodeProblems/DS_03_findDuplicates.java: -------------------------------------------------------------------------------- 1 | package lecture10LeetCodeProblems; 2 | 3 | public class DS_03_findDuplicates { 4 | public static void main(String[] args) { 5 | int[] arr = {6, 3, 1, 5, 4, 6, 2}; 6 | System.out.println(findDuplicate(arr)); 7 | } 8 | 9 | static int findDuplicate(int[] arr){ 10 | int ans = 0; 11 | for (int i = 0; i < arr.length; i++) { 12 | ans = ans ^ arr[i] ^ i; 13 | } 14 | // for (int i = 0; i < arr.length; i++) { 15 | // ans ^= i; 16 | // } 17 | 18 | return ans; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/Lecture7LeetCodeProblems/DS_04_reverseNumber.java: -------------------------------------------------------------------------------- 1 | package Lecture7LeetCodeProblems; 2 | 3 | public class DS_04_reverseNumber { 4 | public static void main(String[] args) { 5 | int num = 1999999999; 6 | System.out.println(reverseNum(num)); 7 | } 8 | 9 | static int reverseNum(int num) { 10 | int rev = 0; 11 | while (num != 0) { 12 | int digit = num % 10; 13 | if (rev > Integer.MAX_VALUE / 10 || rev < Integer.MIN_VALUE / 10) return 0; 14 | rev = rev * 10 + digit; 15 | num = num / 10; 16 | } 17 | return rev; 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /src/Lecture20_questions/CheckSortesOrRotated.java: -------------------------------------------------------------------------------- 1 | package Lecture20_questions; 2 | 3 | public class CheckSortesOrRotated { 4 | public static void main(String[] args) { 5 | int[] arr = {10,12, 2, 3, 4, 5, 6, 7, 8, 9}; 6 | System.out.println(check(arr)); 7 | } 8 | 9 | static boolean check(int[] arr) { 10 | int count = 0, n = arr.length; 11 | 12 | for (int i = 1; i < n; i++) { 13 | if (arr[i - 1] > arr[i]) { 14 | count++; 15 | } 16 | } 17 | if (arr[n - 1] > arr[0]) 18 | count++; 19 | 20 | return count <= 1; 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/BS_04_find_pivot_element.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions; 2 | 3 | public class BS_04_find_pivot_element { 4 | public static void main(String[] args) { 5 | int[] arr = {4,5,6,2,3}; 6 | System.out.println(findPivot(arr)); 7 | } 8 | 9 | static int findPivot(int[] arr){ 10 | int low = 0, high = arr.length - 1; 11 | while(low < high){ 12 | int mid = low +(high - low)/2; 13 | if (arr[mid] >= arr[0]) 14 | low = mid + 1; 15 | else 16 | high = mid; 17 | } 18 | return high; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/PracticeProblems/KadanesAlgorithm.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class KadanesAlgorithm { 4 | public static void main(String[] args) { 5 | int[] arr = {-2, -3, 4, -1, -2, 1, 5, -3}; 6 | System.out.println(maxSumSubArray(arr)); 7 | } 8 | 9 | static int maxSumSubArray(int[] arr) { 10 | int currentSum = 0, maxSum = 0; 11 | for (int i = 0; i < arr.length; i++) { 12 | currentSum += arr[i]; 13 | if (currentSum > maxSum) 14 | maxSum = currentSum; 15 | if (currentSum < 0) 16 | currentSum = 0; 17 | } 18 | return maxSum; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/BS_03_peak_in_mountain_Array.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions; 2 | 3 | public class BS_03_peak_in_mountain_Array { 4 | public static void main(String[] args) { 5 | int[] arr = {1, 4, 8, 9, 13, 2}; 6 | System.out.println(peakElement(arr)); 7 | } 8 | 9 | static int peakElement(int[] arr) { 10 | int low = 0, high = arr.length - 1; 11 | 12 | while (low < high) { 13 | int mid = low + (high - low) / 2; 14 | if (arr[mid] < arr[mid + 1]) 15 | low = mid + 1; 16 | else 17 | high = mid ; 18 | } 19 | return high; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/lecture14_BinarySearchQuestions/DS_Q852_peak_index_in_mountain_array.java: -------------------------------------------------------------------------------- 1 | package lecture14_BinarySearchQuestions; 2 | 3 | public class DS_Q852_peak_index_in_mountain_array { 4 | public static void main(String[] args) { 5 | int[] arr = {1,2,3,5,4,0}; 6 | System.out.println(peakIndex(arr)); 7 | } 8 | 9 | static int peakIndex(int[] arr) { 10 | int low = 0; 11 | int high = arr.length - 1; 12 | int mid = low + (high - low) / 2; 13 | 14 | while (low < high) { 15 | if (arr[mid] < arr[mid + 1]) low = mid + 1; 16 | else high = mid; 17 | mid = low + (high - low) / 2; 18 | } 19 | return low; 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /src/PracticeProblems/FindAllDulicates.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | import java.lang.reflect.Array; 4 | import java.util.ArrayList; 5 | 6 | public class FindAllDulicates { 7 | public static void main(String[] args) { 8 | int[] arr = {4,3,2,7,3,2,1,5}; 9 | ArrayList ans = findALlDuplicates(arr); 10 | System.out.println(ans ); 11 | } 12 | 13 | static ArrayList findALlDuplicates(int[] arr) { 14 | ArrayList ans = new ArrayList<>(); 15 | for (int i = 0; i < arr.length; i++) { 16 | int n = Math.abs(arr[i]); 17 | if (arr[n-1] > 0) 18 | arr[n-1] *= -1; 19 | else 20 | ans.add(arr[i]); 21 | } 22 | return ans; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Lecture22_charhacterArray/First.java: -------------------------------------------------------------------------------- 1 | package Lecture22_charhacterArray; 2 | 3 | public class First { 4 | public static void main(String[] args) { 5 | String name = "abaAbcbaABA"; 6 | System.out.println(isPlaindrome(name)); 7 | // System.out.println((char) (name.charAt(0) + 32)); 8 | } 9 | 10 | static boolean isPlaindrome(String str) { 11 | int i = 0, j = str.length() - 1; 12 | while (i < j) { 13 | if (str.charAt(i) == str.charAt(j) || 14 | str.charAt(i) == (str.charAt(j) + 32) || 15 | str.charAt(i) == (str.charAt(j) - 32)) { 16 | i++; 17 | j--; 18 | } else { 19 | return false; 20 | } 21 | } 22 | return true; 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /src/Lecture21_questins/RotareArray.java: -------------------------------------------------------------------------------- 1 | package Lecture21_questins; 2 | 3 | public class RotareArray { 4 | public static void main(String[] args) { 5 | int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}; 6 | printArray(arr); 7 | rotateArray(arr,3); 8 | printArray(arr); 9 | } 10 | 11 | static void printArray(int[] arr) { 12 | for (int i = 0; i < arr.length; i++) 13 | System.out.print(arr[i] + " "); 14 | System.out.println(); 15 | } 16 | 17 | static void rotateArray(int[] arr, int k) { 18 | int[] temp = new int[arr.length]; 19 | for (int i = 0; i < arr.length; i++) { 20 | temp[(i + k) % arr.length] = arr[i]; 21 | } 22 | for (int i = 0; i < arr.length; i++) { 23 | arr[i] = temp[i]; 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/lecture10LeetCodeProblems/DS_01_SwapAlternates.java: -------------------------------------------------------------------------------- 1 | package lecture10LeetCodeProblems; 2 | 3 | public class DS_01_SwapAlternates { 4 | public static void main(String[] args) { 5 | int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9}; 6 | printArray(arr); 7 | swapAlternate(arr); 8 | printArray(arr); 9 | } 10 | 11 | static void printArray(int[] arr) { 12 | for (int i = 0; i < arr.length; i++) { 13 | System.out.print(arr[i] + " "); 14 | } 15 | System.out.println(); 16 | } 17 | 18 | static void swapAlternate(int[] arr) { 19 | for (int i = 0; i < arr.length; i += 2) { 20 | if (i + 1 < arr.length) { 21 | int temp = arr[i]; 22 | arr[i] = arr[i + 1]; 23 | arr[i + 1] = temp; 24 | } 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /src/PracticeProblems/SearchIn_Infinite_sorted_Array.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class SearchIn_Infinite_sorted_Array { 4 | public static void main(String[] args) { 5 | 6 | } 7 | 8 | static int search(int[] arr, int key) { 9 | int low = 0, high = 1; 10 | while (key > arr[high]) { 11 | low = high; 12 | high = high * 2; 13 | } 14 | return binarySearch(arr, low, high, key); 15 | } 16 | 17 | static int binarySearch(int[] arr, int low, int high, int key) { 18 | while (low <= high) { 19 | int mid = low + (high - low) / 2; 20 | if (key == arr[mid]) 21 | return mid; 22 | if (key > arr[mid]) { 23 | low = mid + 1; 24 | } else 25 | high = mid - 1; 26 | } 27 | return -1; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/PracticeProblems/SortingAlgorithms/SA_02_Insertion_sort.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.SortingAlgorithms; 2 | 3 | public class SA_02_Insertion_sort { 4 | public static void main(String[] args) { 5 | int[] arr = {12, 35, 12, 78, 54, 23, 98, 90, 34, 67, 100}; 6 | print(arr); 7 | insertionSort(arr); 8 | print(arr); 9 | } 10 | 11 | static void print(int[] arr) { 12 | for (int n : arr) 13 | System.out.print(n + " "); 14 | System.out.println(); 15 | } 16 | 17 | static void insertionSort(int []arr){ 18 | int key, j; 19 | for (int i = 1 ; i < arr.length; i++) { 20 | key = arr[i]; 21 | j = i-1; 22 | while(key < arr[j] && j >= 0){ 23 | arr[j+1] = arr[j]; 24 | j--; 25 | } 26 | arr[j+1] = key; 27 | } 28 | 29 | 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/PracticeProblems/IntersectinOfArrays.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class IntersectinOfArrays { 6 | public static void main(String[] args) { 7 | int[] arr1 = {1, 3, 5, 9, 10}; 8 | int[] arr2 = {2, 3, 4, 5, 10}; 9 | ArrayList ans; 10 | ans = intersection(arr1, arr2); 11 | System.out.println(ans); 12 | } 13 | 14 | static ArrayList intersection(int[] arr1, int[] arr2) { 15 | int i = 0, j = 0; 16 | ArrayList arr3 = new ArrayList<>(); 17 | while (i < arr1.length && j < arr2.length) { 18 | if (arr1[i] == arr2[j]) { 19 | arr3.add(arr1[i]); 20 | i++; 21 | j++; 22 | } 23 | else if (arr1[i] < arr2[j]) i++; 24 | else j++; 25 | } 26 | return arr3; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/PracticeProblems/PairSum.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class PairSum { 6 | public static void main(String[] args) { 7 | int[] arr = {1, 2, 3, 4, 5, 6}; 8 | ArrayList> ans = pairSum(arr, 6); 9 | System.out.println(ans); 10 | } 11 | 12 | static ArrayList> pairSum(int[] arr, int k) { 13 | ArrayList> ans = new ArrayList<>(); 14 | for (int i = 0; i < arr.length; i++) { 15 | for (int j = i + 1; j < arr.length; j++) { 16 | ArrayList temp = new ArrayList<>(); 17 | if (arr[i] + arr[j] == k) { 18 | temp.add(arr[i]); 19 | temp.add(arr[j]); 20 | ans.add(temp); 21 | } 22 | } 23 | } 24 | return ans; 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/PracticeProblems/SortingAlgorithms/SA_01_BubbleSort.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.SortingAlgorithms; 2 | 3 | public class SA_01_BubbleSort { 4 | public static void main(String[] args) { 5 | int[] arr = {12, 35, 12, 78, 54, 23, 98, 90, 34, 67, 100}; 6 | print(arr); 7 | bubbleSort(arr); 8 | print(arr); 9 | } 10 | 11 | static void print(int[] arr) { 12 | for (int n : arr) 13 | System.out.print(n + " "); 14 | System.out.println(); 15 | } 16 | 17 | static void bubbleSort(int[] arr) { 18 | for (int i = 0; i < arr.length; i++) { 19 | for (int j = 0; j < arr.length - 1 - i; j++) { 20 | if (arr[j] > arr[j + 1]) { 21 | int temp = arr[j]; 22 | arr[j] = arr[j + 1]; 23 | arr[j + 1] = temp; 24 | } 25 | } 26 | } 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/Lecture20_questions/MoveZeroes.java: -------------------------------------------------------------------------------- 1 | package Lecture20_questions; 2 | 3 | public class MoveZeroes { 4 | 5 | public static void main(String[] args) { 6 | int arr[] = {0, 1, 0, 3, 12, 0, 12, 0, 54, 0, 10, 0, 0, 99}; 7 | int size = arr.length; 8 | printArray(arr, size); 9 | moveZeroes(arr, size); 10 | printArray(arr, size); 11 | } 12 | 13 | static void moveZeroes(int arr[], int n) { 14 | int j = 0; 15 | for (int i = 0; i < n; i++) { 16 | if (arr[i] != 0) { 17 | int temp = arr[i]; 18 | arr[i] = arr[j]; 19 | arr[j] = temp; 20 | j++; 21 | } 22 | } 23 | } 24 | 25 | static void printArray(int arr[], int n) { 26 | for (int i = 0; i < n; i++) { 27 | System.out.print(arr[i] + " "); 28 | } 29 | System.out.println(); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/RainWaterTrappingProb.java: -------------------------------------------------------------------------------- 1 | public class RainWaterTrappingProb { 2 | public static void main(String[] args) { 3 | int[] arr = {6, 2, 5, 0, 4, 5}; 4 | int ans = rainWater(arr); 5 | System.out.println("The water trapped is " + ans + " units"); 6 | } 7 | 8 | static int rainWater(int[] arr) { 9 | int n = arr.length; 10 | int[] left = new int[n]; 11 | int[] right = new int[n]; 12 | 13 | left[0] = arr[0]; 14 | for (int i = 1; i < n; i++) { 15 | left[i] = Math.max(left[i - 1], arr[i]); 16 | } 17 | right[n - 1] = arr[n - 1]; 18 | for (int i = n - 2; i >= 0; i--) { 19 | right[i] = Math.max(right[i + 1], arr[i]); 20 | } 21 | 22 | int ans = 0; 23 | for (int i = 0; i < n; i++) { 24 | ans = ans + Math.min(left[i], right[i]) - arr[i]; 25 | } 26 | return ans; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/BS_05_FindSquareRoot.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions; 2 | 3 | public class BS_05_FindSquareRoot { 4 | public static void main(String[] args) { 5 | System.out.println(sqrt(9)); 6 | System.out.println(sqrt(16)); 7 | System.out.println(sqrt(25)); 8 | System.out.println(sqrt(625)); 9 | System.out.println(sqrt(12325)); 10 | } 11 | 12 | static int sqrt(int num) { 13 | int low = 0, high = num; 14 | int ans = -1; 15 | while (low <= high) { 16 | int mid = low + (high - low) / 2; 17 | int square = mid * mid; 18 | if (square == num) return mid; 19 | if (square < num) { 20 | ans = mid; 21 | low = mid + 1; 22 | } 23 | else 24 | high = mid - 1; 25 | } 26 | return ans; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/PracticeProblems/Sort0And1.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class Sort0And1 { 4 | public static void main(String[] args) { 5 | int[] arr = {1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0}; 6 | printArr(arr); 7 | sort(arr); 8 | printArr(arr); 9 | } 10 | 11 | static void printArr(int[] arr) { 12 | for (int n : arr) { 13 | System.out.print(n + " "); 14 | } 15 | System.out.println(); 16 | } 17 | 18 | static void sort(int[] arr) { 19 | int i = 0, j = arr.length - 1; 20 | while (i < j) { 21 | while (arr[i] == 0 && i < j) i++; 22 | while (arr[j] == 1 && i < j) j--; 23 | if (arr[i] > arr[j]) { 24 | int temp = arr[i]; 25 | arr[i] = arr[j]; 26 | arr[j] = temp; 27 | i++; 28 | j--; 29 | } 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/RotateArray.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class RotateArray { 4 | public static void main(String[] args) { 5 | int[] arr = {2, 3, 4, 5, 6, 7, 8}; 6 | printArray(arr); 7 | // rotateArray(arr); 8 | rotateBySize(arr, 5); 9 | printArray(arr); 10 | } 11 | 12 | static void printArray(int[] arr) { 13 | for (int i = 0; i < arr.length; i++) { 14 | System.out.print(arr[i] + " "); 15 | } 16 | System.out.println(); 17 | } 18 | 19 | static void rotateArray(int[] arr) { 20 | int temp = arr[0]; 21 | for (int i = 0; i < arr.length - 1; i++) { 22 | arr[i] = arr[i + 1]; 23 | } 24 | arr[arr.length - 1] = temp; 25 | } 26 | 27 | static void rotateBySize(int[] arr, int d) { 28 | for (int i = 0; i < d; i++) { 29 | rotateArray(arr); 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/lecture10LeetCodeProblems/DS_04_ArrayIntersection.java: -------------------------------------------------------------------------------- 1 | package lecture10LeetCodeProblems; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class DS_04_ArrayIntersection { 6 | public static void main(String[] args) { 7 | int [] arr1 = { 1, 2, 2, 2, 3, 4}; 8 | int [] arr2 = {2, 2, 3, 3}; 9 | // int [] arr3 = intersection(arr1,arr2); 10 | } 11 | static ArrayList intersection(ArrayList arr1,ArrayList arr2){ 12 | ArrayList ans = null; 13 | int i = 0, j = 0; 14 | while(i < arr1.size() && j < arr2.size()){ 15 | if (arr1.get(i) < arr2.get(j)){ 16 | i++; 17 | } 18 | else if(arr1.get(i) == arr2.get(j)){ 19 | ans.add(arr1.get(i)); 20 | i++;j++; 21 | } 22 | else{ 23 | j++; 24 | } 25 | } 26 | 27 | 28 | return ans; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/bubbleSort.java: -------------------------------------------------------------------------------- 1 | public class bubbleSort { 2 | public static void main(String[] args) { 3 | int[] arr = {23, 12, 34, 67, 54, 98, 32, 11}; 4 | System.out.println("List before sorting"); 5 | printArray(arr); 6 | bubbleSort(arr); 7 | System.out.println("List after sorting"); 8 | printArray(arr); 9 | } 10 | 11 | static void printArray(int[] arr) { 12 | for (int i = 0; i < arr.length; i++) { 13 | System.out.print(arr[i] + " "); 14 | } 15 | System.out.println(); 16 | } 17 | 18 | static void bubbleSort(int[] arr) { 19 | for (int i = 0; i < arr.length; i++) { 20 | for (int j = 0; j < arr.length - 1 - i; j++) { 21 | if (arr[j] > arr[j+1]) { 22 | int temp = arr[j]; 23 | arr[j] = arr[j + 1]; 24 | arr[j + 1] = temp; 25 | } 26 | } 27 | } 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /src/Lecture22_charhacterArray/RemovwSpaces.java: -------------------------------------------------------------------------------- 1 | package Lecture22_charhacterArray; 2 | 3 | public class RemovwSpaces { 4 | public static void main(String[] args) { 5 | StringBuilder str = new StringBuilder("hii i am ayush"); 6 | 7 | // StringBuilder temp = removeSpace1(str); 8 | str = removeSpace1(str); 9 | System.out.println(str); 10 | } 11 | 12 | static String removeSpace(String str){ 13 | String temp = ""; 14 | 15 | for (int i = 0; i < str.length(); i++) { 16 | if (str.charAt(i) == ' ') 17 | temp = temp + "@40"; 18 | else 19 | temp = temp + str.charAt(i); 20 | } 21 | return temp; 22 | } 23 | 24 | static StringBuilder removeSpace1(StringBuilder str){ 25 | for (int i = 0; i < str.length(); i++) { 26 | if (str.charAt(i) == ' '){ 27 | str.insert(i,"@40"); 28 | } 29 | } 30 | return str; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/PracticeProblems/SortingAlgorithms/SA_03_Selection_Sort.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.SortingAlgorithms; 2 | 3 | public class SA_03_Selection_Sort { 4 | public static void main(String[] args) { 5 | int[] arr = {12, 35, 12, 78, 54, 23, 98, 90, 34, 67, 100}; 6 | print(arr); 7 | selectionSort(arr); 8 | print(arr); 9 | 10 | } 11 | 12 | static void print(int[] arr) { 13 | for (int n : arr) 14 | System.out.print(n + " "); 15 | System.out.println(); 16 | } 17 | 18 | static void selectionSort(int[] arr) { 19 | int indexOfMin, temp; 20 | for (int i = 0; i < arr.length; i++) { 21 | indexOfMin = i; 22 | for (int j = i + 1; j < arr.length; j++) { 23 | if (arr[indexOfMin] > arr[j]) 24 | indexOfMin = j; 25 | } 26 | temp = arr[i]; 27 | arr[i] = arr[indexOfMin]; 28 | arr[indexOfMin] = temp; 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/BS_00_BinarySearch.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions; 2 | 3 | import java.lang.reflect.Array; 4 | import java.util.Arrays; 5 | 6 | public class BS_00_BinarySearch { 7 | public static void main(String[] args) { 8 | int[] arr = {98, 3, 12, 43, 56, 77, 7, 9, 38, 79, 76, 5, 93}; 9 | int[] arr2 = {3, 5, 7, 9, 12, 38, 43, 56, 76, 77, 79, 93, 98}; 10 | Arrays.sort(arr); 11 | System.out.println(Arrays.toString(arr2)); 12 | System.out.println(binarySearch(arr2,76)); 13 | } 14 | 15 | static int binarySearch(int[] arr, int key) { 16 | int low = 0, high = arr.length - 1; 17 | while (low <= high) { 18 | int mid = low + (high - low) / 2; 19 | if (key == arr[mid]) 20 | return mid; 21 | if (key > arr[mid]) { 22 | low = mid + 1; 23 | } else 24 | high = mid - 1; 25 | } 26 | return -1; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/BubbleSort.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class BubbleSort { 4 | public static void main(String[] args) { 5 | int[] arr = {3,7,8,9,5,6,8,7,6}; 6 | System.out.println("Array before Sorting"); 7 | printArray(arr); 8 | bubblrSort(arr); 9 | System.out.println("Array after Sorting"); 10 | printArray(arr); 11 | } 12 | 13 | private static void printArray(int[] arr) { 14 | for (int i = 0; i < arr.length; i++) { 15 | System.out.print(arr[i] + " "); 16 | } 17 | System.out.println(); 18 | } 19 | 20 | static void bubblrSort(int[] arr) { 21 | 22 | for (int i = 0; i < arr.length; i++) { 23 | for (int j = 0; j < arr.length - 1 - i; j++) { 24 | if (arr[j] > arr[j + 1]) { 25 | int temp = arr[j]; 26 | arr[j] = arr[j + 1]; 27 | arr[j + 1] = temp; 28 | } 29 | } 30 | 31 | } 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/Lecture7LeetCodeProblems/DS_03_powerOfTwo.java: -------------------------------------------------------------------------------- 1 | package Lecture7LeetCodeProblems; 2 | 3 | public class DS_03_powerOfTwo { 4 | public static void main(String[] args) { 5 | int num = 1281; 6 | System.out.println(isPowerOf2two(num)); 7 | } 8 | 9 | static boolean isPowerOf2two(int num){ 10 | int count = 0; 11 | while(num != 0){ 12 | num = num & (num-1); 13 | count++; 14 | } 15 | return count == 1; 16 | } 17 | static boolean isPowerOfTwo(int num) { 18 | int count = 0; 19 | while (num != 0) { 20 | if ((num & 1) != 0) { 21 | count++; 22 | } 23 | num >>= 1; 24 | } 25 | if (count == 1) return true; 26 | return false; 27 | } 28 | 29 | static boolean isPowerOfTwo2(int num) { 30 | int res = 1; 31 | for (int i = 0; i < 31; i++) { 32 | if (num == res) return true; 33 | res = res * 2; 34 | } 35 | return false; 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/lecture10LeetCodeProblems/DS_05_twoSum.java: -------------------------------------------------------------------------------- 1 | package lecture10LeetCodeProblems; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class DS_05_twoSum { 6 | public static void main(String[] args) { 7 | int[] array = {12,1,12,3,14,16}; 8 | ArrayList arrayList = triplet(array, 40); 9 | System.out.println(arrayList); 10 | } 11 | 12 | // optimised code n^3 13 | static ArrayList triplet(int[] arr, int target){ 14 | ArrayList returningArr = new ArrayList<>(); 15 | for (int i = 0; i < arr.length-2; i++) { 16 | for (int j = i+1; j < arr.length-1; j++) { 17 | for (int k = j+1; k < arr.length; k++) { 18 | if (arr[i]+arr[j]+arr[k] == target){ 19 | returningArr.add(arr[i]); 20 | returningArr.add(arr[j]); 21 | returningArr.add(arr[k]); 22 | } 23 | } 24 | } 25 | } 26 | return returningArr; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /src/PracticeProblems/MergeTwoSortedArrays.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class MergeTwoSortedArrays { 4 | public static void main(String[] args) { 5 | int[] arr1 = {1, 3, 5, 6, 8}; 6 | int[] arr2 = {2, 4, 6, 7}; 7 | int[] arr3 = new int[arr1.length + arr2.length]; 8 | merge(arr1, arr2, arr3); 9 | print(arr1); 10 | print(arr2); 11 | print(arr3); 12 | } 13 | 14 | static void print(int[] arr) { 15 | for (int n : arr) 16 | System.out.print(n + " "); 17 | System.out.println(); 18 | } 19 | 20 | static void merge(int[] arr1, int[] arr2, int[] arr3) { 21 | int i = 0, j = 0, k = 0; 22 | int m = arr1.length, n = arr2.length, o = arr3.length; 23 | while (i < m && j < n) { 24 | if (arr1[i] < arr2[j]) 25 | arr3[k++] = arr1[i++]; 26 | else 27 | arr3[k++] = arr2[j++]; 28 | } 29 | while (i < m) arr3[k++] = arr1[i++]; 30 | while (j < n) arr3[k++] = arr2[j++]; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/SelectionSort.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class SelectionSort { 4 | public static void main(String[] args) { 5 | int[] arr = {3,7,8,9,5,6,8,7,6}; 6 | System.out.println("Array before Sorting"); 7 | printArray(arr); 8 | selectionSort(arr); 9 | System.out.println("Array after Sorting"); 10 | printArray(arr); 11 | } 12 | 13 | static void printArray(int[] arr){ 14 | for (int i = 0; i < arr.length; i++) { 15 | System.out.print(arr[i] +" "); 16 | } 17 | System.out.println(); 18 | } 19 | 20 | static void selectionSort(int[] arr){ 21 | 22 | for (int i = 0; i < arr.length; i++) { 23 | int indexOfMin = i; 24 | for (int j = i+1; j < arr.length; j++) { 25 | if (arr[indexOfMin] > arr[j]){ 26 | indexOfMin = j; 27 | } 28 | int temp = arr[i]; 29 | arr[i] = arr[indexOfMin]; 30 | arr[indexOfMin] = temp; 31 | } 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/BS_02_searchInSortedAndRotatedArray.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions; 2 | 3 | import java.util.Arrays; 4 | 5 | public class BS_02_searchInSortedAndRotatedArray { 6 | public static void main(String[] args) { 7 | int[] arr = {6, 7, 1, 2, 3, 4, 5}; 8 | int index = search(arr, 5); 9 | System.out.println(index); 10 | } 11 | 12 | static int search(int[] arr, int key) { 13 | int low = 0, high = arr.length - 1; 14 | while (low <= high) { 15 | int mid = low + (high - low) / 2; 16 | if (arr[mid] == key) return mid; 17 | if (arr[low] < arr[mid]) { 18 | if (key >= arr[low] && key < arr[mid]) 19 | high = mid - 1; 20 | else 21 | low = mid + 1; 22 | } else { 23 | if (key > arr[mid] && key <= arr[high]) 24 | low = mid + 1; 25 | else 26 | high = mid - 1; 27 | } 28 | } 29 | return -1; 30 | } 31 | 32 | } 33 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/SortedArrayIntersection.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public class SortedArrayIntersection { 7 | public static void main(String[] args) { 8 | ArrayList arr1 = new ArrayList<>(); 9 | ArrayList arr2 = new ArrayList<>(); 10 | // arr1.add(1,2,3,,); 11 | ArrayList duplicates= findIntersection(arr1, arr2); 12 | System.out.println(duplicates); 13 | } 14 | 15 | static ArrayList findIntersection(ArrayList arr1, ArrayList arr2) { 16 | List list = new ArrayList<>(); 17 | int i = 0, j = 0; 18 | 19 | while (i < arr1.size() && j < arr2.size()) { 20 | if (arr1.get(i) == arr2.get(j)) { 21 | list.add(arr1.get(i)); 22 | i++; 23 | j++; 24 | } else if (arr1.get(i) > arr2.get(j)) { 25 | j++; 26 | } else { 27 | i++; 28 | } 29 | } 30 | return (ArrayList) list; 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/Sort0And1.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class Sort0And1 { 4 | public static void main(String[] args) { 5 | int[] arr = {1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1}; 6 | displayArray(arr); 7 | sort0and1(arr); 8 | displayArray(arr); 9 | } 10 | 11 | static void displayArray(int[] arr) { 12 | for (int i = 0; i < arr.length; i++) { 13 | System.out.print(arr[i] + " "); 14 | } 15 | System.out.println(); 16 | } 17 | 18 | static void sort0and1(int[] arr) { 19 | int left = 0; 20 | int right = arr.length - 1; 21 | 22 | while (left < right) { 23 | while (arr[left] == 0/* && left < right*/) { 24 | left++; 25 | } 26 | while (arr[right] == 1 /*&& left < right*/) { 27 | right--; 28 | } 29 | if (left < right) { 30 | int temp = arr[left]; 31 | arr[left] = arr[right]; 32 | arr[right] = temp; 33 | left++; 34 | right--; 35 | } 36 | } 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/Lecture20_questions/MergeSortedArray.java: -------------------------------------------------------------------------------- 1 | package Lecture20_questions; 2 | 3 | public class MergeSortedArray { 4 | public static void main(String[] args) { 5 | int[] arr1 = {1, 3, 5, 7}; 6 | int[] arr2 = {0, 1, 2, 4, 6, 8}; 7 | int[] arr3 = new int[arr1.length + arr2.length]; 8 | merge(arr1, arr2, arr3); 9 | printArray(arr1); 10 | printArray(arr2); 11 | printArray(arr3); 12 | 13 | } 14 | 15 | static void printArray(int arr[]) { 16 | for (int i = 0; i < arr.length; i++) { 17 | System.out.print(arr[i] + " "); 18 | } 19 | System.out.println(); 20 | } 21 | 22 | static void merge(int[] arr1, int[] arr2, int[] arr3) { 23 | int i = 0, j = 0, k = 0; 24 | int n = arr1.length; 25 | int m = arr2.length; 26 | while (i < n && j < m) { 27 | if (arr1[i] < arr2[j]) 28 | arr3[k++] = arr1[i++]; 29 | else 30 | arr3[k++] = arr2[j++]; 31 | } 32 | while (i < n) 33 | arr3[k++] = arr1[i++]; 34 | 35 | while (j < m) 36 | arr3[k++] = arr2[j++]; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/AggressiveCows.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | import java.util.Arrays; 4 | 5 | public class AggressiveCows { 6 | public static void main(String[] args) { 7 | 8 | } 9 | 10 | static boolean isPossible(int[] arr, int cows, int mid) { 11 | int cowsCount = 1; 12 | int lastPos = arr[0]; 13 | 14 | for (int i = 0; i < arr.length; i++) { 15 | if (arr[i] - lastPos >= mid) { 16 | cowsCount++; 17 | if (cows == cowsCount) 18 | return true; 19 | } 20 | lastPos = arr[i]; 21 | } 22 | return false; 23 | } 24 | 25 | static int aggressiveCows(int[] arr, int cows) { 26 | int ans = -1; 27 | int low = 0; 28 | Arrays.sort(arr); 29 | int high = arr[arr.length - 1] - arr[0]; 30 | while (low <= high) { 31 | int mid = low + (high - low) / 2; 32 | 33 | if (isPossible(arr, cows, mid)) { 34 | ans = mid; 35 | low = mid + 1; 36 | } else 37 | high = mid - 1; 38 | } 39 | return ans; 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /src/PracticeProblems/Sort0_1_and_2.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class Sort0_1_and_2 { 4 | public static void main(String[] args) { 5 | int[] arr = {0, 1, 2, 2, 1, 0, 2, 2, 0, 1, 0, 1, 2, 1, 0, 1, 2, 0}; 6 | printArr(arr); 7 | sort1(arr); 8 | printArr(arr); 9 | } 10 | 11 | static void printArr(int[] arr) { 12 | for (int n : arr) { 13 | System.out.print(n + " "); 14 | } 15 | System.out.println(); 16 | } 17 | 18 | static void sort1(int[] arr) { 19 | int low = 0, mid = 0, high = arr.length - 1; 20 | while (mid <= high) { 21 | switch (arr[mid]) { 22 | case 0: 23 | int temp = arr[low]; 24 | arr[low++] = arr[mid]; 25 | arr[mid++] = temp; 26 | // low++; 27 | // mid++; 28 | break; 29 | case 1: 30 | mid++; 31 | break; 32 | case 2: 33 | temp = arr[high]; 34 | arr[high--] = arr[mid]; 35 | arr[mid] = temp; 36 | break; 37 | } 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/RainWaterTrapping.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class RainWaterTrapping { 4 | public static void main(String[] args) { 5 | int[] arr = {3, 1, 2, 4, 0, 1, 3, 2}; 6 | printArray(arr); 7 | int totalWater = rainWatertrapping(arr); 8 | System.out.println("The water is " + totalWater + " units."); 9 | 10 | } 11 | 12 | static void printArray(int[] arr) { 13 | for (int i = 0; i < arr.length; i++) { 14 | System.out.print(arr[i] + " "); 15 | } 16 | System.out.println(); 17 | } 18 | 19 | static int rainWatertrapping(int[] arr) { 20 | int n = arr.length; 21 | int left = 0, right = n - 1, water = 0; 22 | int maxLeft = arr[left]; 23 | int maxRight = arr[right]; 24 | 25 | while (left < right) { 26 | 27 | if (arr[left] < arr[right]) { 28 | left++; 29 | maxLeft = Math.max(maxLeft, arr[left]); 30 | water += (maxLeft - arr[left]); 31 | } else { 32 | right--; 33 | maxRight = Math.max(maxRight, arr[right]); 34 | water += (maxRight - arr[right]); 35 | } 36 | } 37 | return water; 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/MajorityElement.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class MajorityElement { 4 | public static void main(String[] args) { 5 | int[] arr = {3, 3, 4, 2, 4, 4, 2, 4, 4}; 6 | printMajority(arr); 7 | 8 | } 9 | 10 | 11 | // Using Moore’s Voting Algorithm 12 | 13 | static void printMajority(int[] arr) { 14 | int element = findElement(arr); 15 | System.out.println((isMajority(arr, element)) ? 16 | "Majority element is : " + element : 17 | "No majority Element"); 18 | } 19 | 20 | static int findElement(int[] arr) { 21 | int ansIndex = 0; 22 | int count = 1; 23 | for (int i = 0; i < arr.length; i++) { 24 | if (arr[i] == arr[ansIndex]) count++; 25 | else count--; 26 | 27 | if (count == 0) { 28 | ansIndex = i; 29 | count = 1; 30 | } 31 | } 32 | 33 | return arr[ansIndex]; 34 | } 35 | 36 | static boolean isMajority(int[] arr, int element) { 37 | int count = 0; 38 | for (int i = 0; i < arr.length; i++) { 39 | if (arr[i] == element) count++; 40 | } 41 | if (count > (arr.length / 2)) return true; 42 | return false; 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/SquareRoot.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class SquareRoot { 4 | public static void main(String[] args) { 5 | double num = 37; 6 | double tempSol = squareRoot((long) num); 7 | double squareroot = morePrecesion(num, 2, tempSol); 8 | System.out.println("The sqaure root of " + num + " is " + squareroot); 9 | } 10 | 11 | static long squareRoot(long num) { 12 | long low = 0, high = num; 13 | long ans = -1; 14 | while (low <= high) { 15 | long mid = low + (high - low) / 2; 16 | long square = mid * mid; 17 | if (square == num) { 18 | return mid; 19 | } 20 | if (square > num) { 21 | high = mid - 1; 22 | } else { 23 | ans = mid; 24 | low = mid + 1; 25 | } 26 | } 27 | return ans; 28 | } 29 | 30 | static double morePrecesion(double num, int precesion, double tempSol) { 31 | double factor = 1; 32 | double ans = tempSol; 33 | 34 | for (int i = 0; i < precesion; i++) { 35 | factor /= 10; 36 | for (double j = ans; j * j < num; j += factor) { 37 | ans = j; 38 | } 39 | } 40 | return ans; 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/InsertAndDeleteInArray/Insertion.java: -------------------------------------------------------------------------------- 1 | package InsertAndDeleteInArray; 2 | 3 | public class Insertion { 4 | 5 | public static void main(String[] args) { 6 | 7 | int[] arr = new int[100]; 8 | 9 | int size = 9; 10 | 11 | arr[0] = 11; 12 | arr[1] = 15; 13 | arr[2] = 18; 14 | arr[3] = 10; 15 | arr[4] = 11; 16 | arr[5] = 13; 17 | arr[6] = 21; 18 | arr[7] = 31; 19 | arr[8] = 41; 20 | // 11 15 18 10 100 11 13 21 31 41 21 | printArray(arr, size); 22 | insertAtIndex(arr, 9, 4,100); 23 | printArray(arr, 10); 24 | deletion(arr,size,2); 25 | printArray(arr, 10); 26 | } 27 | 28 | static void printArray(int[] arr, int size) { 29 | for (int i = 0; i < size; i++) { 30 | System.out.print(arr[i] + " "); 31 | } 32 | System.out.println(); 33 | } 34 | 35 | static void insertAtIndex(int[] arr, int size, int index, int element) { 36 | for (int i = size - 1; i >= index; i--) { 37 | arr[i + 1] = arr[i]; 38 | } 39 | arr[index] = element; 40 | } 41 | 42 | static void deletion(int[] arr,int size, int index) { 43 | for (int i = index; i < size; i++) { 44 | arr[i] = arr[i+1]; 45 | } 46 | arr[size] = 0; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/AdvanceBinarySearchQuestion/BS_05_Roti_Prata_SPOJ.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions.AdvanceBinarySearchQuestion; 2 | 3 | public class BS_05_Roti_Prata_SPOJ { 4 | public static void main(String[] args) { 5 | int[] arr = {1, 3, 2, 4}; 6 | int ans = rotiPrata(arr, 10); 7 | System.out.println(ans); 8 | } 9 | 10 | static int rotiPrata(int[] arr, int paratas) { 11 | int ans = -1; 12 | int low = 0; 13 | int high = 100000000; 14 | while (low <= high) { 15 | int mid = low + (high - low) / 2; 16 | if (isPossible(arr, paratas, mid)) { 17 | ans = mid; 18 | high = mid - 1; 19 | } else 20 | low = mid + 1; 21 | } 22 | return ans; 23 | } 24 | 25 | static boolean isPossible(int[] arr, int paratas, int mid) { 26 | int time = 0; 27 | int parCount = 0; 28 | for (int i = 0; i < arr.length; i++) { 29 | time = arr[i]; 30 | int j = 2; 31 | while (time <= mid) { 32 | parCount++; 33 | time += (arr[i] * j); 34 | j++; 35 | } 36 | if (parCount >= paratas) return true; 37 | } 38 | return false; 39 | } 40 | 41 | } 42 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/AdvanceBinarySearchQuestion/BS_04_EKO_EKO_SPOJ.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions.AdvanceBinarySearchQuestion; 2 | 3 | public class BS_04_EKO_EKO_SPOJ { 4 | public static void main(String[] args) { 5 | int[] arr = {20,15,10,17}; 6 | int ans = minWood(arr,7); 7 | System.out.println(ans); 8 | System.out.println(minWood(new int[]{16, 12, 8, 15},10)); 9 | } 10 | 11 | static int minWood(int[] arr, int wood) { 12 | int ans = -1; 13 | int maxi = 0; 14 | for (int i = 0; i < arr.length; i++) { 15 | maxi = Math.max(maxi, arr[i]); 16 | } 17 | int low = 0; 18 | int high = maxi; 19 | while (low <= high) { 20 | int mid = low + (high - low) / 2; 21 | if (isPossible(arr, wood, mid)) { 22 | ans = mid; 23 | low = mid + 1; 24 | } else { 25 | high = mid - 1; 26 | } 27 | } 28 | return ans; 29 | } 30 | 31 | static boolean isPossible(int[] arr, int wood, int mid) { 32 | int sum = 0; 33 | for (int i = 0; i < arr.length; i++) { 34 | if (arr[i] > mid) { 35 | sum = sum + arr[i] - mid; 36 | } 37 | } 38 | return sum >= wood; 39 | 40 | 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/BubbleSortAdaptive.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class BubbleSortAdaptive { 4 | public static void main(String[] args) { 5 | int[] arr = {1,2,3,4,5,6,7,8,9}; 6 | System.out.println("Array before Sorting"); 7 | printArray(arr); 8 | bubblrSort(arr); 9 | System.out.println("Array after Sorting"); 10 | printArray(arr); 11 | } 12 | 13 | private static void printArray(int[] arr) { 14 | for (int i = 0; i < arr.length; i++) { 15 | System.out.print(arr[i] + " "); 16 | } 17 | System.out.println(); 18 | } 19 | 20 | static void bubblrSort(int[] arr) { 21 | boolean isSorted = true; 22 | for (int i = 0; i < arr.length; i++) { 23 | isSorted = false; 24 | // System.out.println("Pass number -> " + i ); 25 | for (int j = 0; j < arr.length - 1 - i; j++) { 26 | // System.out.println("comparision no -> " + j); 27 | // printArray(arr); 28 | if (arr[j] > arr[j + 1]) { 29 | int temp = arr[j]; 30 | arr[j] = arr[j + 1]; 31 | arr[j + 1] = temp; 32 | isSorted = true; 33 | } 34 | } 35 | if (!isSorted) 36 | return; 37 | 38 | } 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/InsertionSort.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class InsertionSort { 4 | public static void main(String[] args) { 5 | int[] arr = {0,9,8,7,6,5,4,3,2,1}; 6 | printArray(arr); 7 | // insertionSort(arr); 8 | // printArray(arr); 9 | insertionSortByBabbar(arr); 10 | printArray(arr); 11 | } 12 | 13 | static void printArray(int[] arr) { 14 | for (int i = 0; i < arr.length; i++) { 15 | System.out.print(arr[i] + " "); 16 | } 17 | System.out.println(); 18 | } 19 | 20 | static void insertionSortByBabbar(int[] arr) { 21 | for (int i = 0; i < arr.length; i++) { 22 | int temp = arr[i]; 23 | int j; 24 | for (j = i - 1; j >= 0; j--) { 25 | if (arr[j] > temp) 26 | arr[j + 1] = arr[j]; 27 | else 28 | break; 29 | } 30 | arr[j+1] = temp; 31 | } 32 | 33 | 34 | } 35 | 36 | static void insertionSort(int[] arr) { 37 | int key, j; 38 | for (int i = 0; i < arr.length; i++) { 39 | key = arr[i]; 40 | j = i - 1; 41 | while (j >= 0 && arr[j] > key) { 42 | arr[j + 1] = arr[j]; 43 | j--; 44 | } 45 | arr[j + 1] = key; 46 | } 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/AdvanceBinarySearchQuestion/BS_03_aggressive_cows.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions.AdvanceBinarySearchQuestion; 2 | 3 | import java.util.Arrays; 4 | import java.util.concurrent.locks.StampedLock; 5 | 6 | public class BS_03_aggressive_cows { 7 | public static void main(String[] args) { 8 | int[] arr = {1, 2, 8, 9, 4}; 9 | int ans = aggressiveCows(arr, 3); 10 | System.out.println(ans); 11 | } 12 | 13 | static int aggressiveCows(int[] arr, int cows) { 14 | Arrays.sort(arr); 15 | int ans = -1; 16 | int low = 0, high = arr[arr.length - 1]; 17 | 18 | while (low <= high) { 19 | int mid = low + (high - low) / 2; 20 | if (isPossible(arr, cows, mid)) { 21 | ans = mid; 22 | low = mid + 1; 23 | } else 24 | high = mid - 1; 25 | } 26 | return ans; 27 | } 28 | 29 | static boolean isPossible(int[] stalls, int cows, int dist) { 30 | int cowCount = 1; 31 | int cowPos = stalls[0]; 32 | for (int i = 0; i < stalls.length; i++) { 33 | if (stalls[i] - cowPos >= dist) { 34 | cowCount++; 35 | if (cowCount == cows) 36 | return true; 37 | cowPos = stalls[i]; 38 | } 39 | } 40 | 41 | return false; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/Lecture22_charhacterArray/ValidPalindrome.java: -------------------------------------------------------------------------------- 1 | package Lecture22_charhacterArray; 2 | 3 | import java.util.Locale; 4 | 5 | public class ValidPalindrome { 6 | public static void main(String[] args) { 7 | String str = "A man, a plan, a canal: Panama"; 8 | boolean ans = validPalindrome(str); 9 | System.out.println(ans); 10 | } 11 | 12 | static boolean isAlphaNum(char ch) { 13 | if (ch >= 'A' && ch <= 'Z') 14 | return true; 15 | if (ch >= 'a' && ch <= 'z') 16 | return true; 17 | if (ch >= '0' && ch <= '9') 18 | return true; 19 | 20 | return false; 21 | } 22 | 23 | static boolean validPalindrome(String str) { 24 | String temp = ""; 25 | 26 | for (int i = 0; i < str.length(); i++) { 27 | if (isAlphaNum(str.charAt(i))) { 28 | temp = temp + str.charAt(i); 29 | System.out.println(temp); 30 | } 31 | } 32 | System.out.println(temp); 33 | 34 | temp = temp.toLowerCase(); 35 | System.out.println(temp); 36 | if (temp.isEmpty()) return true; 37 | int i = 0, j = temp.length() - 1; 38 | while (i < j) { 39 | if (temp.charAt(i) != temp.charAt(j)) 40 | return false; 41 | else { 42 | i++; 43 | j--; 44 | } 45 | } 46 | return true; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/BS_01_left_And_Right_Occurence.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions; 2 | 3 | public class BS_01_left_And_Right_Occurence { 4 | public static void main(String[] args) { 5 | int[] arr = {1, 2, 3, 3, 3, 3, 3, 4, 5, 6}; 6 | System.out.println(leftOccurence(arr, 3)); 7 | System.out.println(rightOcurence(arr, 3)); 8 | } 9 | 10 | static int leftOccurence(int[] arr, int key) { 11 | int low = 0; 12 | int high = arr.length - 1; 13 | int ans = 0; 14 | while (low <= high) { 15 | int mid = low + (high - low) / 2; 16 | if (key == arr[mid]) { 17 | ans = mid; 18 | high = mid - 1; 19 | } 20 | else if (key > arr[mid]) 21 | low = mid + 1; 22 | else 23 | high = mid - 1; 24 | } 25 | return ans; 26 | } 27 | 28 | static int rightOcurence(int[] arr, int key) { 29 | int low = 0; 30 | int high = arr.length - 1; 31 | int ans = 0; 32 | while (low <= high) { 33 | int mid = low + (high - low) / 2; 34 | if (key == arr[mid]) { 35 | ans = mid; 36 | low = mid + 1; 37 | } 38 | else if (key > arr[mid]) 39 | low = mid + 1; 40 | else 41 | high = mid - 1; 42 | } 43 | return ans; 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/EkoSpoj.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | import java.util.*; 4 | import java.lang.*; 5 | 6 | public class EkoSpoj { 7 | 8 | 9 | public static void main(String[] args) throws java.lang.Exception { 10 | Scanner input = new Scanner(System.in); 11 | int trees = input.nextInt(); 12 | int requirsWood = input.nextInt(); 13 | 14 | int[] arr = new int[trees]; 15 | for (int i = 0; i < arr.length; i++) { 16 | arr[i] = input.nextInt(); 17 | } 18 | 19 | System.out.println(eko(arr, requirsWood)); 20 | } 21 | 22 | static boolean isPossible(int[] arr, int m, int mid) { 23 | int sum = 0; 24 | for (int i = 0; i < arr.length; i++) { 25 | if (arr[i] > mid) { 26 | sum = sum + arr[i] - mid; 27 | } 28 | 29 | } 30 | if (sum >= m) return true; 31 | return false; 32 | } 33 | 34 | static int eko(int arr[], int m) { 35 | int low = 0, ans = -1, maxi = -1; 36 | for (int i = 0; i < arr.length; i++) { 37 | maxi = Math.max(arr[i], maxi); 38 | } 39 | int high = maxi; 40 | 41 | while(low <= high){ 42 | int mid = low + (high - low )/2; 43 | 44 | if (isPossible(arr,m,mid)){ 45 | ans = mid; 46 | low = mid + 1; 47 | }else 48 | high = mid - 1; 49 | } 50 | return ans; 51 | } 52 | } 53 | 54 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/BooksAllocation.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | import java.rmi.dgc.VMID; 4 | 5 | public class BooksAllocation { 6 | public static void main(String[] args) { 7 | int[] arr = {10,20,30,40}; 8 | // int[] arr = {12, 34, 67, 90, 123, 546, 1, 89}; 9 | System.out.println(booksAllocate(arr,2)); 10 | } 11 | 12 | static int booksAllocate(int[] arr, int student) { 13 | int ans = -1; 14 | int low = 0, sum = 0; 15 | for (int i = 0; i < arr.length; i++) { 16 | sum += arr[i]; 17 | } 18 | int high = sum; 19 | 20 | 21 | while (low <= high) { 22 | int mid = low + (high - low) / 2; 23 | if (isPossible(arr, student, mid)) { 24 | ans = mid; 25 | high = mid - 1; 26 | } else { 27 | low = mid + 1; 28 | } 29 | } 30 | return ans; 31 | } 32 | 33 | static boolean isPossible(int[] arr, int student, int mid) { 34 | int pageSum = 0; 35 | int studentCount = 1; 36 | for (int i = 0; i < arr.length; i++) { 37 | if (pageSum + arr[i] <= mid) 38 | pageSum += arr[i]; 39 | else { 40 | studentCount++; 41 | if (studentCount > student || arr[i] > mid) 42 | return false; 43 | pageSum = arr[i]; 44 | } 45 | } 46 | 47 | return true; 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/RotiPrata.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | import java.util.Scanner; 4 | 5 | public class RotiPrata { 6 | public static void main(String[] args) { 7 | Scanner sc = new Scanner(System.in); 8 | int paratha = sc.nextInt(); 9 | int cook = sc.nextInt(); 10 | int[] cooksRank = new int[cook]; 11 | for (int i = 0; i < cooksRank.length; i++) { 12 | cooksRank[i] = sc.nextInt(); 13 | } 14 | System.out.println(parathaSpoj(cooksRank,paratha)) ; 15 | } 16 | 17 | static boolean isPossible(int[] arr, int paratha, int mid) { 18 | int time = 0; 19 | int parCount = 0; 20 | for (int i = 0; i < arr.length; i++) { 21 | time = arr[i]; 22 | int j = 2; 23 | while (time <= mid) { 24 | parCount++; 25 | time = time + (arr[i] * j); 26 | j++; 27 | } 28 | if (parCount >= paratha) return true; 29 | } 30 | return false; 31 | } 32 | 33 | static int parathaSpoj(int[] arr, int paratha) { 34 | int ans = -1; 35 | int low = 0, high = Integer.MAX_VALUE; 36 | 37 | while (low <= high) { 38 | int mid = low + (high - low) / 2; 39 | if (isPossible(arr, paratha, mid)) { 40 | ans = mid; 41 | high = mid - 1; 42 | } else { 43 | low = mid + 1; 44 | } 45 | } 46 | return ans; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/AdvanceBinarySearchQuestion/BS_01_Books_Allocation.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions.AdvanceBinarySearchQuestion; 2 | 3 | public class BS_01_Books_Allocation { 4 | public static void main(String[] args) { 5 | int[] arr = {10, 20, 30, 40}; 6 | int ans = allocateBooks(arr, 2); 7 | System.out.println(ans); 8 | } 9 | 10 | static int allocateBooks(int[] arr, int students) { 11 | int sum = 0; 12 | for (int i = 0; i < arr.length; i++) { 13 | sum += arr[i]; 14 | } 15 | int ans = -1; 16 | int low = 0; 17 | int high = sum; 18 | while (low <= high) { 19 | int mid = low + (high - low) / 2; 20 | if (isPossible(arr, students, mid)) { 21 | ans = mid; 22 | high = mid - 1; 23 | } else 24 | low = mid + 1; 25 | } 26 | return ans; 27 | } 28 | 29 | static boolean isPossible(int[] arr, int students, int mid) { 30 | int pagesCount = 0; 31 | int stdCount = 1; 32 | for (int i = 0; i < arr.length; i++) { 33 | if (pagesCount + arr[i] <= mid) { 34 | pagesCount += arr[i]; 35 | } else { 36 | stdCount++; 37 | if (stdCount > students || arr[i] > mid) 38 | return false; 39 | pagesCount = arr[i]; 40 | } 41 | } 42 | return true; 43 | } 44 | 45 | } 46 | 47 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/PaintersPartition.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class PaintersPartition { 6 | public static void main(String[] args) { 7 | 8 | } 9 | 10 | 11 | static boolean isPossible(ArrayList boards, int painters, int mid){ 12 | int paintersCount = 1; 13 | int boardSum = 0; 14 | for(int i = 0 ; i < boards.size(); i++){ 15 | if(boardSum + boards.get(i) <= mid) 16 | boardSum += boards.get(i); 17 | else{ 18 | paintersCount++; 19 | if(paintersCount > painters || boards.get(i) > mid) 20 | return false; 21 | boardSum = boards.get(i); 22 | } 23 | } 24 | return true; 25 | } 26 | public static int findLargestMinDistance(ArrayList boards, int k) 27 | { 28 | int ans = -1; 29 | int low = 0, sum = 0; 30 | for(int i = 0 ; i < boards.size() ; i++){ 31 | sum += boards.get(i); 32 | } 33 | int high = sum; 34 | while(low <= high){ 35 | int mid = low + (high - low)/2; 36 | if(isPossible(boards, k, mid)){ 37 | ans = mid; 38 | high = mid - 1; 39 | }else 40 | low = mid + 1; 41 | } 42 | return ans; 43 | } 44 | 45 | } 46 | -------------------------------------------------------------------------------- /src/PracticeProblems/BinarySearchQuestions/AdvanceBinarySearchQuestion/BS_02_PaintersPArtition.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems.BinarySearchQuestions.AdvanceBinarySearchQuestion; 2 | 3 | 4 | public class BS_02_PaintersPArtition { 5 | public static void main(String[] args) { 6 | int[] arr = {1, 2, 3, 4}; 7 | int ans = paintersPartition(arr, 3); 8 | System.out.println(ans); 9 | } 10 | 11 | static int paintersPartition(int[] arr, int painter) { 12 | int low = 0; 13 | int sum = 0; 14 | for (int i = 0; i < arr.length; i++) { 15 | sum += arr[i]; 16 | } 17 | int ans = -1; 18 | int high = sum; 19 | while (low <= high) { 20 | int mid = low + (high - low) / 2; 21 | if (isPossible(arr, painter, mid)) { 22 | ans = mid; 23 | high = mid - 1; 24 | } else 25 | low = mid + 1; 26 | } 27 | return ans; 28 | } 29 | 30 | static boolean isPossible(int[] board, int painter, int mid) { 31 | int boardCount = 0; 32 | int paintersCount = 1; 33 | for (int i = 0; i < board.length; i++) { 34 | if (boardCount + board[i] <= mid) { 35 | boardCount += board[i]; 36 | } else { 37 | paintersCount++; 38 | if (paintersCount > painter || board[i] > mid) 39 | return false; 40 | boardCount = board[i]; 41 | 42 | } 43 | } 44 | return true; 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /src/PracticeProblems/MajorityElements.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class MajorityElements { 4 | public static void main(String[] args) { 5 | int[] arr = {3, 3, 4, 2, 4, 4, 2, 4, 4}; 6 | System.out.println(findElement(arr)); 7 | System.out.println(findMajor(arr)); 8 | } 9 | 10 | // brute - force solution 11 | static int findElement(int[] arr) { 12 | int maxCount = 0; 13 | int index = 0; 14 | for (int i = 0; i < arr.length; i++) { 15 | int count = 0; 16 | for (int j = 0; j < arr.length; j++) { 17 | if (arr[i] == arr[j]) 18 | count++; 19 | } 20 | if (count > maxCount) { 21 | maxCount = count; 22 | index = i; 23 | } 24 | } 25 | return (maxCount > (arr.length / 2)) ? arr[index] : -1; 26 | } 27 | 28 | // optimised Solution 29 | 30 | 31 | static int findMajor(int[] arr) { 32 | int count = 1; 33 | int majElement = 0; 34 | for (int i = 0; i < arr.length; i++) { 35 | if (arr[i] == arr[majElement]) count++; 36 | else count--; 37 | 38 | if (count == 0) { 39 | majElement = i; 40 | count = 1; 41 | } 42 | } 43 | int cnt = 0; 44 | for (int i = 0; i < arr.length; i++) { 45 | if (arr[i] == arr[majElement]) 46 | cnt++; 47 | } 48 | return (cnt > (arr.length / 2)) ? arr[majElement] : -1; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/lecture14_BinarySearchQuestions/BooksAllocation.java: -------------------------------------------------------------------------------- 1 | package lecture14_BinarySearchQuestions; 2 | 3 | public class BooksAllocation { 4 | public static void main(String[] args) { 5 | int[] arr = {12, 34, 67, 90, 123, 546, 1, 89}; 6 | int answer = allocateBooks(arr, 2); 7 | System.out.println(answer); 8 | } 9 | 10 | static int allocateBooks(int[] arr, int students) { 11 | int start = 0; 12 | int sum = 0; 13 | for (int i = 0; i < arr.length; i++) { 14 | sum += arr[i]; 15 | } 16 | int ans = Integer.MAX_VALUE; 17 | int end = sum; 18 | while (start <= end) { 19 | int mid = start + (end - start) / 2; 20 | if (isPossible(arr, students, mid)) { 21 | ans = mid; 22 | end = mid - 1; 23 | } else { 24 | start = mid + 1; 25 | } 26 | // mid = start + (end - start) / 2; 27 | } 28 | 29 | return ans; 30 | } 31 | 32 | static boolean isPossible(int[] arr, int student, int mid) { 33 | int studentCount = 1; 34 | int pagesCount = 0; 35 | 36 | for (int i = 0; i < arr.length; i++) { 37 | if (pagesCount + arr[i] <= mid) 38 | pagesCount += arr[i]; 39 | else { 40 | studentCount++; 41 | if (studentCount > student || arr[i] > mid) 42 | return false; 43 | pagesCount = arr[i]; 44 | } 45 | } 46 | return true; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/lecture14_BinarySearchQuestions/FirstOccurence.java: -------------------------------------------------------------------------------- 1 | package lecture14_BinarySearchQuestions; 2 | 3 | public class FirstOccurence { 4 | public static void main(String[] args) { 5 | int[] arr = {11, 12, 34, 34, 34, 34, 67, 98}; 6 | int startindex = firstOccurence(arr, 34); 7 | int lastIndex = lastOccurence(arr, 34); 8 | System.out.println(startindex + " " + lastIndex); 9 | System.out.println("Total number of occurence of 34 is " + (lastIndex - startindex + 1)); 10 | } 11 | 12 | static int lastOccurence(int[] arr, int key) { 13 | int ans = -1; 14 | int low = 0, high = arr.length - 1; 15 | int mid = low + (high - low) / 2; 16 | while (low <= high) { 17 | if (key == arr[mid]) { 18 | ans = mid; 19 | low = mid + 1; 20 | } 21 | if (key > arr[mid]) low = mid + 1; 22 | if (key < arr[mid]) high = mid - 1; 23 | mid = low + (high - low) / 2; 24 | } 25 | return ans; 26 | } 27 | 28 | static int firstOccurence(int[] arr, int key) { 29 | int start = 0, end = arr.length - 1; 30 | int mid = start + (end - start) / 2; 31 | int ans = -1; 32 | while (start <= end) { 33 | if (key == arr[mid]) { 34 | ans = mid; 35 | end = mid - 1; 36 | } 37 | if (key > arr[mid]) start = mid + 1; 38 | if (key < arr[mid]) end = mid - 1; 39 | mid = start + (end - start) / 2; 40 | } 41 | return ans; 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/Lecture22_charhacterArray/CheckAlphaNumericOrNot.java: -------------------------------------------------------------------------------- 1 | package Lecture22_charhacterArray; 2 | 3 | public class CheckAlphaNumericOrNot { 4 | public static void main(String[] args) { 5 | String str = "N2 i&nJA?a& jnI2n"; 6 | String str1 = "2 i&nJA?a& jnI2"; 7 | String str2 = " i&nJA?a& jnI"; 8 | String str3 = "&nJA?a& jn"; 9 | String str4 = "JA?a& j"; 10 | String str5 = "A?a& "; 11 | System.out.println(checkPalindrome(str)); 12 | System.out.println(checkPalindrome(str1)); 13 | System.out.println(checkPalindrome(str2)); 14 | System.out.println(checkPalindrome(str3)); 15 | System.out.println(checkPalindrome(str4)); 16 | System.out.println(checkPalindrome(str5)); 17 | } 18 | 19 | static boolean isAlphaNum(char ch) { 20 | if (ch >= 'A' && ch <= 'Z') 21 | return true; 22 | if (ch >= 'a' && ch <= 'z') 23 | return true; 24 | if (ch >= '0' && ch <= '9') 25 | return true; 26 | 27 | return false; 28 | } 29 | 30 | public static boolean checkPalindrome(String str) { 31 | 32 | int i = 0, j = str.length() - 1; 33 | while (i < j) { 34 | 35 | while (!isAlphaNum(str.charAt(i))) { 36 | i++; 37 | } 38 | while(!isAlphaNum(str.charAt(j))) { 39 | j--; 40 | } 41 | 42 | if (str.charAt(i) == str.charAt(j) || 43 | str.charAt(i) == (str.charAt(j) + 32) || 44 | str.charAt(i) == (str.charAt(j) - 32)) { 45 | i++; 46 | j--; 47 | 48 | } else return false; 49 | } 50 | return true; 51 | 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/PracticeProblems/StockBuySell_1.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class StockBuySell_1 { 4 | public static void main(String[] args) { 5 | int[] arr = {3, 2, 1, 8, 3, 4}; 6 | System.out.println(stockProfit(arr)); 7 | System.out.println(stockProfit2(arr)); 8 | System.out.println(stockProfit3(arr)); 9 | } 10 | 11 | static void print(int[] arr) { 12 | for (int i = 0; i < arr.length; i++) { 13 | System.out.print(arr[i] + " "); 14 | } 15 | System.out.println(); 16 | } 17 | // Brute - Force 18 | static int stockProfit(int[] arr) { 19 | int maxProfit = 0; 20 | for (int i = 0; i < arr.length; i++) { 21 | for (int j = i; j < arr.length; j++) { 22 | int profit = arr[j] - arr[i]; 23 | maxProfit = Math.max(maxProfit, profit); 24 | } 25 | } 26 | return maxProfit; 27 | } 28 | // approach 2 - using space 29 | static int stockProfit2(int[] arr) { 30 | int[] aux = new int[arr.length]; 31 | int maxProfit = 0; 32 | aux[0] = arr[0]; 33 | for (int i = 1; i < arr.length; i++) { 34 | aux[i] = Math.min(arr[i], aux[i - 1]); 35 | } 36 | for (int i = 0; i < arr.length; i++) { 37 | int profit = arr[i] - aux[i]; 38 | maxProfit = Math.max(profit, maxProfit); 39 | } 40 | return maxProfit; 41 | } 42 | // approach 3 - without using space 43 | static int stockProfit3(int[] arr) { 44 | int minSoFar = arr[0]; 45 | int maxProfit = 0; 46 | for (int i = 0; i < arr.length; i++) { 47 | minSoFar = Math.min(minSoFar, arr[i]); 48 | int profit = arr[i] - minSoFar; 49 | maxProfit = Math.max(maxProfit, profit); 50 | } 51 | return maxProfit; 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/Lecture21_questins/AddArrays.java: -------------------------------------------------------------------------------- 1 | package Lecture21_questins; 2 | 3 | import java.util.ArrayList; 4 | import java.util.Collections; 5 | 6 | public class AddArrays { 7 | public static void main(String[] args) { 8 | int[] arr1 = {1, 1}; 9 | int[] arr2 = {8, 9}; 10 | ArrayList ans; 11 | ans = addArray(arr1, arr2); 12 | System.out.println(ans); 13 | } 14 | 15 | // static ArrayList reverse(ArrayList ans){ 16 | // int i = 0, j = ans.size() - 1; 17 | // while(i < j){ 18 | // int temp = ans.get(i); 19 | // ans.get(i) = ans.get(j); 20 | // ans.get(j) = temp; 21 | // } 22 | // return ans; 23 | // } 24 | static ArrayList addArray(int[] arr1, int[] arr2) { 25 | 26 | int i = arr1.length - 1; 27 | int j = arr2.length - 1; 28 | int carry = 0; 29 | ArrayList ans = new ArrayList<>(); 30 | while (i >= 0 && j >= 0) { 31 | int sum = arr1[i] + arr2[j] + carry; 32 | carry = sum / 10; 33 | sum = sum % 10; 34 | ans.add(sum); 35 | i--; 36 | j--; 37 | } 38 | 39 | while (i >= 0) { 40 | int sum = arr1[i] + carry; 41 | carry = sum / 10; 42 | sum = sum % 10; 43 | ans.add(sum); 44 | i--; 45 | } 46 | while (j >= 0) { 47 | int sum = arr2[j] + carry; 48 | carry = sum / 10; 49 | sum = sum % 10; 50 | ans.add(sum); 51 | j--; 52 | 53 | } 54 | while (carry != 0) { 55 | int sum = carry; 56 | carry = sum / 10; 57 | sum = sum % 10; 58 | ans.add(sum); 59 | } 60 | 61 | 62 | Collections.reverse(ans); 63 | return ans; 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /src/PracticeProblems/RainWaterTrapping.java: -------------------------------------------------------------------------------- 1 | package PracticeProblems; 2 | 3 | public class RainWaterTrapping { 4 | public static void main(String[] args) { 5 | int[] arr = {3, 1, 2, 4, 0, 1, 3, 2}; 6 | System.out.println(water(arr)); 7 | System.out.println(water2(arr)); 8 | } 9 | 10 | static void print(int[] arr) { 11 | for (int n : arr) 12 | System.out.print(n + " "); 13 | System.out.println(); 14 | } 15 | 16 | // Using Extra Space 17 | static int water(int[] arr) { 18 | int[] left = new int[arr.length]; 19 | int[] right = new int[arr.length]; 20 | left[0] = arr[0]; 21 | for (int i = 1; i < arr.length; i++) { 22 | left[i] = Math.max(left[i - 1], arr[i]); 23 | } 24 | right[arr.length - 1] = arr[arr.length - 1]; 25 | for (int i = arr.length - 2; i >= 0; i--) { 26 | right[i] = Math.max(arr[i], right[i + 1]); 27 | } 28 | int ans = 0; 29 | for (int i = 0; i < arr.length; i++) { 30 | int trapWater = Math.min(left[i], right[i]); 31 | ans = ans + trapWater - arr[i]; 32 | } 33 | return ans; 34 | } 35 | 36 | // Without Using Space Optimized solution Two Pointer Approach 37 | 38 | static int water2(int[] arr) { 39 | int left = 0, right = arr.length - 1; 40 | int maxLeft = arr[left]; 41 | int maxRight = arr[right]; 42 | int water = 0; 43 | while(left < right) { 44 | if (arr[left] < arr[right]) { 45 | left++; 46 | maxLeft = Math.max(maxLeft, arr[left]); 47 | water += maxLeft - arr[left]; 48 | } else { 49 | right--; 50 | maxRight = Math.max(maxRight, arr[right]); 51 | water += maxRight - arr[right]; 52 | } 53 | } 54 | return water; 55 | } 56 | } 57 | -------------------------------------------------------------------------------- /src/QuestionsTillLec19/Sort0and1and2.java: -------------------------------------------------------------------------------- 1 | package QuestionsTillLec19; 2 | 3 | public class Sort0and1and2 { 4 | public static void main(String[] args) { 5 | int[] arr = {1, 2, 0, 2, 0, 1, 2, 0, 1, 2, 0, 1, 0}; 6 | printArray(arr); 7 | sort012(arr); 8 | printArray(arr); 9 | } 10 | 11 | static void printArray(int[] arr) { 12 | for (int i = 0; i < arr.length; i++) { 13 | System.out.print(arr[i] + " "); 14 | } 15 | System.out.println(); 16 | } 17 | 18 | static void sort012(int[] arr){ 19 | int i = 0, j = 0, k = arr.length - 1; 20 | 21 | while(j<=k){ 22 | if(arr[j] == 0){ 23 | int temp = arr[i]; 24 | arr[i] = arr[j]; 25 | arr[j] = temp; 26 | i++; j++; 27 | } 28 | else if (arr[j] == 1){ 29 | j++; 30 | } 31 | else{ 32 | int temp = arr[j]; 33 | arr[j] = arr[k]; 34 | arr[k] = temp; 35 | k--; 36 | } 37 | } 38 | 39 | 40 | 41 | } 42 | static void sort0and1and2(int[] arr) { 43 | int low = 0, mid = 0; 44 | int high = arr.length - 1; 45 | while (mid <= high) { 46 | switch (arr[mid]) { 47 | case 0: 48 | int temp = arr[low]; 49 | arr[low] = arr[mid]; 50 | arr[mid] = temp; 51 | low++; 52 | mid++; 53 | break; 54 | case 1: 55 | mid++; 56 | break; 57 | case 2: 58 | temp = arr[mid]; 59 | arr[mid] = arr[high]; 60 | arr[high] = temp; 61 | high--; 62 | break; 63 | } 64 | } 65 | } 66 | } -------------------------------------------------------------------------------- /src/lecture14_BinarySearchQuestions/BinarySearch.java: -------------------------------------------------------------------------------- 1 | package lecture14_BinarySearchQuestions; 2 | 3 | public class BinarySearch { 4 | public static void main(String[] args) { 5 | int[] arr = {11, 12, 23, 32, 34, 54, 67, 98, 100}; 6 | int key = 10, key1 = 12, key2 = 67, key3 = 98; 7 | System.out.println((binarySearch2(arr, key) != -1) ? 8 | key + " is present at index " + binarySearch2(arr, key) : 9 | "Element not present"); 10 | System.out.println((binarySearch2(arr, key1) != -1) ? 11 | key1 + " is present at index " + binarySearch2(arr, key1) : 12 | "Element not present"); 13 | System.out.println((binarySearch2(arr, key2) != -1) ? 14 | key2 + " is present at index " + binarySearch2(arr, key2) : 15 | "Element not present"); 16 | System.out.println((binarySearch2(arr, key3) != -1) ? 17 | key3 + " is present at index " + binarySearch2(arr, key3) : 18 | "Element not present"); 19 | 20 | } 21 | 22 | static int binarySearch(int[] arr, int key) { 23 | int i = 0, j = arr.length - 1; 24 | // int mid = (i + j) / 2; 25 | // abb karenge chalaki 26 | int mid = i + (j - 1) / 2; 27 | while (i <= j) { 28 | if (arr[mid] == key) return mid; 29 | if (key > arr[mid]) i = mid + 1; 30 | if (key < arr[mid]) j = mid - 1; 31 | mid = i + (j - 1) / 2; 32 | } 33 | return -1; 34 | } 35 | static int binarySearch2(int[] arr, int key) { 36 | int i = 0, j = arr.length - 1; 37 | // int mid = (i + j) / 2; 38 | // abb karenge chalaki 39 | int mid = i + (j - 1) / 2; 40 | while (i <= j) { 41 | if (arr[mid] == key) return mid; 42 | else if (key > arr[mid]) i = mid + 1; 43 | else if (key < arr[mid]) j = mid - 1; 44 | mid = i + (j - 1) / 2; 45 | } 46 | return -1; 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /src/lecture10LeetCodeProblems/DS_06_findTriplet.java: -------------------------------------------------------------------------------- 1 | package lecture10LeetCodeProblems; 2 | 3 | import java.lang.reflect.Array; 4 | import java.util.ArrayList; 5 | import java.util.Arrays; 6 | 7 | public class DS_06_findTriplet { 8 | public static void main(String[] args) { 9 | int[] arr = {1, 2, 3, 4, 5, 6, 7}; 10 | int sum = 12; 11 | ArrayList> tripleSum = findTriplets(arr,arr.length, sum); 12 | System.out.println(tripleSum); 13 | } 14 | 15 | static ArrayList> triplet(int[] arr, int target) { 16 | ArrayList> returningArr = new ArrayList<>(); 17 | for (int i = 0; i < arr.length - 2; i++) { 18 | for (int j = i + 1; j < arr.length - 1; j++) { 19 | for (int k = j + 1; k < arr.length; k++) { 20 | if (arr[i] + arr[j] + arr[k] == target) { 21 | ArrayList temp = new ArrayList<>(); 22 | temp.add(arr[i]); 23 | temp.add(arr[j]); 24 | temp.add(arr[k]); 25 | returningArr.add(temp); 26 | } 27 | } 28 | } 29 | } 30 | // Arrays.sort(returningArr.toArray()); 31 | return returningArr; 32 | } 33 | 34 | public static ArrayList> findTriplets(int[] arr, int n, int k) { 35 | ArrayList> ans = new ArrayList<>(); 36 | // Sorting the arraylist. 37 | Arrays.sort(arr); 38 | 39 | for (int i = 0; i < n; i++) { 40 | int target = k - arr[i]; 41 | int front = i + 1; 42 | int back = n - 1; 43 | 44 | while (front < back) { 45 | int sum = arr[front] + arr[back]; 46 | 47 | // Finding answer which starts from arr[i]. 48 | if (sum < target) { 49 | front++; 50 | } else if (sum > target) { 51 | back--; 52 | } else { 53 | int x = arr[front]; 54 | int y = arr[back]; 55 | 56 | ArrayList list = new ArrayList<>(); 57 | 58 | list.add(arr[i]); 59 | list.add(arr[front]); 60 | list.add(arr[back]); 61 | ans.add(list); 62 | 63 | // Incrementing front pointer until we reach a different number. 64 | while (front < back && arr[front] == x) { 65 | front++; 66 | } 67 | 68 | // Decrementing last pointer until we reach a different number. 69 | while (front < back && arr[back] == y) { 70 | back--; 71 | } 72 | } 73 | } 74 | // Ensuring that we don't encounter duplicate values for arr[i]. 75 | while (i + 1 < n && arr[i] == arr[i + 1]) { 76 | i++; 77 | } 78 | } 79 | return ans; 80 | } 81 | } 82 | -------------------------------------------------------------------------------- /src/Lecture22_charhacterArray/ParenthesisMatching.java: -------------------------------------------------------------------------------- 1 | package Lecture22_charhacterArray; 2 | 3 | import java.util.Scanner; 4 | 5 | public class ParenthesisMatching { 6 | public static void main(String[] args) { 7 | // Scanner sc = new Scanner(System.in); 8 | String str = "package Lecture22_charhacterArray;\n" + 9 | "\n" + 10 | "public class CheckAlphaNumericOrNot {\n" + 11 | " public static void main(String[] args) {\n" + 12 | " String str = \"N2 i&nJA?a& jnI2n\";\n" + 13 | " String str1 = \"2 i&nJA?a& jnI2\";\n" + 14 | " String str2 = \" i&nJA?a& jnI\";\n" + 15 | " String str3 = \"&nJA?a& jn\";\n" + 16 | " String str4 = \"JA?a& j\";\n" + 17 | " String str5 = \"A?a& \";\n" + 18 | " System.out.println(checkPalindrome(str));\n" + 19 | " System.out.println(checkPalindrome(str1));\n" + 20 | " System.out.println(checkPalindrome(str2));\n" + 21 | " System.out.println(checkPalindrome(str3));\n" + 22 | " System.out.println(checkPalindrome(str4));\n" + 23 | " System.out.println(checkPalindrome(str5));\n" + 24 | " }\n" + 25 | "\n" + 26 | " static boolean isAlphaNum(char ch) {\n" + 27 | " if (ch >= 'A' && ch <= 'Z')\n" + 28 | " return true;\n" + 29 | " if (ch >= 'a' && ch <= 'z')\n" + 30 | " return true;\n" + 31 | " if (ch >= '0' && ch <= '9')\n" + 32 | " return true;\n" + 33 | "\n" + 34 | " return false;\n" + 35 | " }\n" + 36 | "\n" + 37 | " public static boolean checkPalindrome(String str) {\n" + 38 | "\n" + 39 | " int i = 0, j = str.length() - 1;\n" + 40 | " while (i < j) {\n" + 41 | "\n" + 42 | " while (!isAlphaNum(str.charAt(i))) {\n" + 43 | " i++;\n" + 44 | " }\n" + 45 | " while(!isAlphaNum(str.charAt(j))) {\n" + 46 | " j--;\n" + 47 | " }\n" + 48 | "\n" + 49 | " if (str.charAt(i) == str.charAt(j) ||\n" + 50 | " str.charAt(i) == (str.charAt(j) + 32) ||\n" + 51 | " str.charAt(i) == (str.charAt(j) - 32)) {\n" + 52 | " i++;\n" + 53 | " j--;\n" + 54 | "\n" + 55 | " } else return false;\n" + 56 | " }\n" + 57 | " return true;\n" + 58 | "\n" + 59 | " }\n" + 60 | "}\n"; 61 | 62 | boolean ans = isBracketMatch(str); 63 | System.out.println(ans); 64 | } 65 | 66 | static boolean isBracketMatch(String str) { 67 | StringBuilder temp = new StringBuilder(); 68 | for (int i = 0; i < str.length(); i++) { 69 | char val = str.charAt(i); 70 | if (val == '(' || val == '{' || val == '[' 71 | || val == ')' || val == '}' || val == ']'){ 72 | temp.append(val); 73 | } 74 | } 75 | System.out.println(temp); 76 | int i = 0, j = temp.length() - 1; 77 | while(i < j){ 78 | if (temp.charAt(i) != temp.charAt(j)) 79 | return false; 80 | else{ 81 | i++; j--; 82 | } 83 | } 84 | return true; 85 | } 86 | } 87 | --------------------------------------------------------------------------------