Array_And_Hashing Questions Finish

Author: Vinay Patel

NeetCode_150_DSA/Arrays_And_Hashing/Encode_and_Decode_Strings_8.java

@@ -0,0 +1,47 @@
+package Arrays_And_Hashing;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Encode_and_Decode_Strings_8 {
+ public static void main(String[] args) {
+ Encode_and_Decode_Strings_8 solution = new Encode_and_Decode_Strings_8();
+
+ // Example usage:
+ List<String> inputList = new ArrayList<>();
+ inputList.add("Hello");
+ inputList.add("World");
+ inputList.add("Java");
+
+ // Encoding
+ String encodedString = solution.encode(inputList);
+ System.out.println("Encoded String: " + encodedString);
+
+ // Decoding
+ List<String> decodedList = solution.decode(encodedString);
+ System.out.println("Decoded List: " + decodedList);
+ }
+
+ public String encode(List<String> strs) {
+ StringBuilder encodedString = new StringBuilder();
+ for (String str : strs) {
+ encodedString.append(str.length()).append("#").append(str);
+ }
+ return encodedString.toString();
+ }
+
+ public List<String> decode(String str) {
+ List<String> list = new ArrayList<>();
+ int i = 0;
+ while (i < str.length()) {
+ int j = i;
+ while (str.charAt(j) != '#')
+ j++;
+
+ int length = Integer.valueOf(str.substring(i, j));
+ i = j + 1 + length;
+ list.add(str.substring(j + 1, i));
+ }
+ return list;
+ }
+}

NeetCode_150_DSA/Arrays_And_Hashing/Longest_Consecutive_Sequence_9.java

@@ -0,0 +1,74 @@
+package Arrays_And_Hashing;
+
+import java.util.HashSet;
+
+public class Longest_Consecutive_Sequence_9 {
+ public static void main(String[] args) {
+ Longest_Consecutive_Sequence_9 solution = new Longest_Consecutive_Sequence_9();
+
+ // Example 1:
+ int[] nums1 = { 100, 4, 200, 1, 3, 2 };
+ int result1 = solution.longestConsecutive(nums1);
+ System.out.println("Example 1 Output: " + result1);
+
+ // Example 2:
+ int[] nums2 = { 0, 3, 7, 2, 5, 8, 4, 6, 0, 1 };
+ int result2 = solution.longestConsecutive(nums2);
+ System.out.println("Example 2 Output: " + result2);
+ }
+
+ public int longestConsecutive(int[] nums) {
+
+ if (nums == null || nums.length == 0)
+ return 0;
+
+ HashSet<Integer> numSet = new HashSet<>();
+ for (int num : nums) {
+ numSet.add(num);
+ }
+
+ int maxLength = 0;
+
+ for (int num : numSet) {
+ // If the current number is the start of a sequence
+ if (!numSet.contains(num - 1)) {
+ int currentLength = 1;
+ while (numSet.contains(num + 1)) {
+ num++;
+ currentLength++;
+ }
+ maxLength = Math.max(maxLength, currentLength);
+ }
+ }
+
+ return maxLength;
+
+ // Below Is Using Hash Map
+
+ /*
+ * if (nums.length == 0)
+ * return 0;
+ * HashSet<Integer> hs = new HashSet<>();
+ * for (int num : nums)
+ * hs.add(num);
+ * int longest = 1;
+ * for (int num : nums) {
+ * // check if the num is the start of a sequence by checking if left exists
+ * if (!hs.contains(num - 1)) { // start of a sequence
+ * int count = 1;
+ * while (hs.contains(num + 1)) { // check if hs contains next no.
+ * num++;
+ * count++;
+ * }
+ * longest = Math.max(longest, count);
+ * 
+ * }
+ * if (longest > nums.length / 2)
+ * break;
+ * 
+ * }
+ * return longest;
+ * 
+ */
+ }
+}

NeetCode_150_DSA/Arrays_And_Hashing/Product_of_Array_Except_Self_6.java

@@ -0,0 +1,44 @@
+package Arrays_And_Hashing;
+
+public class Product_of_Array_Except_Self_6 {
+ public static void main(String[] args) {
+
+ }
+
+ public int[] productExceptSelf(int[] nums) {
+
+ // Brute Force Give TLE :)
+
+ // int[] result = new int[nums.length];
+ // for (int i = 0; i < nums.length; i++) {
+ // // int temp = nums[i];
+ // int temp = 1;
+ // for (int j = 0; j < nums.length; j++) {
+ // // int ans = temp*nums[j];
+ // // return new int[]{ans};
+ // if (i != j) {
+ // temp *= nums[j];
+ // }
+ // }
+ // result[i] = temp;
+ // }
+ // // return null;
+ // return result;
+
+ int n = nums.length;
+ int[] result = new int[n];
+
+ // int prefixProduct = 1;
+ int Prefixtemp = 1;
+ for (int i = 0; i < n; i++) {
+ result[i] = Prefixtemp;
+ Prefixtemp *= nums[i];
+ }
+ int Suffixtemp = 1;
+ for (int i = n - 1; i >= 0; i--) {
+ result[i] *= Suffixtemp;
+ Suffixtemp *= nums[i];
+ }
+ return result;
+ }
+}

NeetCode_150_DSA/Arrays_And_Hashing/Valid_Sudoku_7.java

@@ -0,0 +1,38 @@
+package Arrays_And_Hashing;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class Valid_Sudoku_7 {
+ public static void main(String[] args) {
+
+ }
+
+ public boolean isValidSudoku(char[][] board) {
+ Map<Integer, Set<Character>> cols = new HashMap<>();
+ Map<Integer, Set<Character>> rows = new HashMap<>();
+ Map<Integer, Set<Character>> squares = new HashMap<>();
+
+ for (int r = 0; r < 9; r++) {
+ for (int c = 0; c < 9; c++) {
+ if (board[r][c] == '.') {
+ continue;
+ }
+ char num = board[r][c];
+ if (rows.containsKey(r) && rows.get(r).contains(num) ||
+ cols.containsKey(c) && cols.get(c).contains(num) ||
+ squares.containsKey((r / 3) * 3 + c / 3) && squares.get((r / 3) * 3 + c / 3).contains(num)) {
+ return false;
+ }
+
+ rows.computeIfAbsent(r, k -> new HashSet<>()).add(num);
+ cols.computeIfAbsent(c, k -> new HashSet<>()).add(num);
+ squares.computeIfAbsent((r / 3) * 3 + c / 3, k -> new HashSet<>()).add(num);
+ }
+ }
+
+ return true;
+ }
+}