algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-28 06:55:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Formatted with Google Java Formatter

Browse Source
This commit is contained in:
github-actions
2021-01-04 15:20:36 +00:00
parent ecefcf3be3
commit 936861cafd
2 changed files with 170 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
Misc/RangeInSortedArray.java
View File

@ -4,79 +4,79 @@ import java.util.*;
public class RangeInSortedArray { public class RangeInSortedArray {
public static void main(String[] args) { public static void main(String[] args) {
// Testcases // Testcases
assert Arrays.equals(sortedRange(new int[] {1, 2, 3, 3, 3, 4, 5}, 3), new int[] {2, 4}); assert Arrays.equals(sortedRange(new int[] {1, 2, 3, 3, 3, 4, 5}, 3), new int[] {2, 4});
assert Arrays.equals(sortedRange(new int[] {1, 2, 3, 3, 3, 4, 5}, 4), new int[] {5, 5}); assert Arrays.equals(sortedRange(new int[] {1, 2, 3, 3, 3, 4, 5}, 4), new int[] {5, 5});
assert Arrays.equals(sortedRange(new int[] {0, 1, 2}, 3), new int[] {-1, -1}); assert Arrays.equals(sortedRange(new int[] {0, 1, 2}, 3), new int[] {-1, -1});
} }
// Get the 1st and last occurrence index of a number 'key' in a non-decreasing array 'nums' // Get the 1st and last occurrence index of a number 'key' in a non-decreasing array 'nums'
// Gives [-1, -1] in case element doesn't exist in array // Gives [-1, -1] in case element doesn't exist in array
public static int[] sortedRange(int[] nums, int key) { public static int[] sortedRange(int[] nums, int key) {
int[] range = new int[] {-1, -1}; int[] range = new int[] {-1, -1};
alteredBinSearchIter(nums, key, 0, nums.length - 1, range, true); alteredBinSearchIter(nums, key, 0, nums.length - 1, range, true);
alteredBinSearchIter(nums, key, 0, nums.length - 1, range, false); alteredBinSearchIter(nums, key, 0, nums.length - 1, range, false);
return range; return range;
} }
// Recursive altered binary search which searches for leftmost as well as rightmost occurrence of // Recursive altered binary search which searches for leftmost as well as rightmost occurrence of
// 'key' // 'key'
public static void alteredBinSearch( public static void alteredBinSearch(
int[] nums, int key, int left, int right, int[] range, boolean goLeft) { int[] nums, int key, int left, int right, int[] range, boolean goLeft) {
if (left > right) return; if (left > right) return;
int mid = (left + right) / 2; int mid = (left + right) / 2;
if (nums[mid] > key) alteredBinSearch(nums, key, left, mid - 1, range, goLeft); if (nums[mid] > key) alteredBinSearch(nums, key, left, mid - 1, range, goLeft);
else if (nums[mid] < key) alteredBinSearch(nums, key, mid + 1, right, range, goLeft); else if (nums[mid] < key) alteredBinSearch(nums, key, mid + 1, right, range, goLeft);
else { else {
if (goLeft) { if (goLeft) {
if (mid == 0 || nums[mid - 1] != key) range[0] = mid; if (mid == 0 || nums[mid - 1] != key) range[0] = mid;
else alteredBinSearch(nums, key, left, mid - 1, range, goLeft); else alteredBinSearch(nums, key, left, mid - 1, range, goLeft);
} else { } else {
if (mid == nums.length - 1 || nums[mid + 1] != key) range[1] = mid; if (mid == nums.length - 1 || nums[mid + 1] != key) range[1] = mid;
else alteredBinSearch(nums, key, mid + 1, right, range, goLeft); else alteredBinSearch(nums, key, mid + 1, right, range, goLeft);
} }
}
}
// Iterative altered binary search which searches for leftmost as well as rightmost occurrence of
// 'key'
public static void alteredBinSearchIter(
int[] nums, int key, int left, int right, int[] range, boolean goLeft) {
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] > key) right = mid - 1;
else if (nums[mid] < key) left = mid + 1;
else {
if (goLeft) {
if (mid == 0 || nums[mid - 1] != key) {
range[0] = mid;
return;
} else right = mid - 1;
} else {
if (mid == nums.length - 1 || nums[mid + 1] != key) {
range[1] = mid;
return;
} else left = mid + 1;
} }
}
} }
}
// Iterative altered binary search which searches for leftmost as well as rightmost occurrence of public static int getCountLessThan(int[] nums, int key) {
// 'key' return getLessThan(nums, key, 0, nums.length - 1);
public static void alteredBinSearchIter( }
int[] nums, int key, int left, int right, int[] range, boolean goLeft) {
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] > key) right = mid - 1;
else if (nums[mid] < key) left = mid + 1;
else {
if (goLeft) {
if (mid == 0 || nums[mid - 1] != key) {
range[0] = mid;
return;
} else right = mid - 1;
} else {
if (mid == nums.length - 1 || nums[mid + 1] != key) {
range[1] = mid;
return;
} else left = mid + 1;
}
}
}
}
public static int getCountLessThan(int[] nums, int key) { public static int getLessThan(int[] nums, int key, int left, int right) {
return getLessThan(nums, key, 0, nums.length - 1); int count = 0;
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] > key) right = mid - 1;
else if (nums[mid] <= key) {
count = mid + 1; // Atleast mid+1 elements exist which are <= key
left = mid + 1;
}
} }
return count;
public static int getLessThan(int[] nums, int key, int left, int right) { }
int count = 0; }
while (left <= right) {
int mid = (left + right) / 2;
if (nums[mid] > key) right = mid - 1;
else if (nums[mid] <= key) {
count = mid + 1; // Atleast mid+1 elements exist which are <= key
left = mid + 1;
}
}
return count;
}
}

202
Misc/WordBoggle.java
View File

@ -2,129 +2,129 @@ import java.util.*;
public class WordBoggle { public class WordBoggle {
/** /**
* O(nm * 8^s + ws) time where n=width of boggle board, m=height of boggle board, s=length of * O(nm * 8^s + ws) time where n=width of boggle board, m=height of boggle board, s=length of
* longest word in string array, w= length of string array, 8 is due to 8 explorable neighbours * longest word in string array, w= length of string array, 8 is due to 8 explorable neighbours
* O(nm + ws) space. * O(nm + ws) space.
*/ */
public static List<String> boggleBoard(char[][] board, String[] words) { public static List<String> boggleBoard(char[][] board, String[] words) {
Trie trie = new Trie(); Trie trie = new Trie();
for (String word : words) trie.add(word); for (String word : words) trie.add(word);
Set<String> finalWords = new HashSet<>(); Set<String> finalWords = new HashSet<>();
boolean[][] visited = new boolean[board.length][board.length]; boolean[][] visited = new boolean[board.length][board.length];
for (int i = 0; i < board.length; i++) for (int i = 0; i < board.length; i++)
for (int j = 0; j < board[i].length; j++) for (int j = 0; j < board[i].length; j++)
explore(i, j, board, trie.root, visited, finalWords); explore(i, j, board, trie.root, visited, finalWords);
return new ArrayList<>(finalWords); return new ArrayList<>(finalWords);
}
public static void main(String[] args) {
// Testcase
List<String> ans =
new ArrayList<>(
Arrays.asList("a", "boggle", "this", "NOTRE_PEATED", "is", "simple", "board"));
assert (boggleBoard(
new char[][] {
{'t', 'h', 'i', 's', 'i', 's', 'a'},
{'s', 'i', 'm', 'p', 'l', 'e', 'x'},
{'b', 'x', 'x', 'x', 'x', 'e', 'b'},
{'x', 'o', 'g', 'g', 'l', 'x', 'o'},
{'x', 'x', 'x', 'D', 'T', 'r', 'a'},
{'R', 'E', 'P', 'E', 'A', 'd', 'x'},
{'x', 'x', 'x', 'x', 'x', 'x', 'x'},
{'N', 'O', 'T', 'R', 'E', '_', 'P'},
{'x', 'x', 'D', 'E', 'T', 'A', 'E'},
},
new String[] {
"this",
"is",
"not",
"a",
"simple",
"test",
"boggle",
"board",
"REPEATED",
"NOTRE_PEATED",
})
.equals(ans));
}
public static void explore(
int i,
int j,
char[][] board,
TrieNode trieNode,
boolean[][] visited,
Set<String> finalWords) {
if (visited[i][j]) return;
char letter = board[i][j];
if (!trieNode.children.containsKey(letter)) {
return;
} }
visited[i][j] = true;
trieNode = trieNode.children.get(letter);
if (trieNode.children.containsKey('*')) finalWords.add(trieNode.word);
public static void main(String[] args) { List<Integer[]> neighbors = getNeighbors(i, j, board);
// Testcase for (Integer[] neighbor : neighbors)
List<String> ans = explore(neighbor[0], neighbor[1], board, trieNode, visited, finalWords);
new ArrayList<>(
Arrays.asList("a", "boggle", "this", "NOTRE_PEATED", "is", "simple", "board"));
assert (boggleBoard(
new char[][] {
{'t', 'h', 'i', 's', 'i', 's', 'a'},
{'s', 'i', 'm', 'p', 'l', 'e', 'x'},
{'b', 'x', 'x', 'x', 'x', 'e', 'b'},
{'x', 'o', 'g', 'g', 'l', 'x', 'o'},
{'x', 'x', 'x', 'D', 'T', 'r', 'a'},
{'R', 'E', 'P', 'E', 'A', 'd', 'x'},
{'x', 'x', 'x', 'x', 'x', 'x', 'x'},
{'N', 'O', 'T', 'R', 'E', '_', 'P'},
{'x', 'x', 'D', 'E', 'T', 'A', 'E'},
},
new String[] {
"this",
"is",
"not",
"a",
"simple",
"test",
"boggle",
"board",
"REPEATED",
"NOTRE_PEATED",
})
.equals(ans));
}
public static void explore( visited[i][j] = false;
int i, }
int j,
char[][] board,
TrieNode trieNode,
boolean[][] visited,
Set<String> finalWords) {
if (visited[i][j]) return;
char letter = board[i][j]; public static List<Integer[]> getNeighbors(int i, int j, char[][] board) {
if (!trieNode.children.containsKey(letter)) { List<Integer[]> neighbors = new ArrayList<>();
return; if (i > 0 && j > 0) neighbors.add(new Integer[] {i - 1, j - 1});
}
visited[i][j] = true;
trieNode = trieNode.children.get(letter);
if (trieNode.children.containsKey('*')) finalWords.add(trieNode.word);
List<Integer[]> neighbors = getNeighbors(i, j, board); if (i > 0 && j < board[0].length - 1) neighbors.add(new Integer[] {i - 1, j + 1});
for (Integer[] neighbor : neighbors)
explore(neighbor[0], neighbor[1], board, trieNode, visited, finalWords);
visited[i][j] = false; if (i < board.length - 1 && j < board[0].length - 1)
} neighbors.add(new Integer[] {i + 1, j + 1});
public static List<Integer[]> getNeighbors(int i, int j, char[][] board) { if (i < board.length - 1 && j > 0) neighbors.add(new Integer[] {i + 1, j - 1});
List<Integer[]> neighbors = new ArrayList<>();
if (i > 0 && j > 0) neighbors.add(new Integer[] {i - 1, j - 1});
if (i > 0 && j < board[0].length - 1) neighbors.add(new Integer[] {i - 1, j + 1}); if (i > 0) neighbors.add(new Integer[] {i - 1, j});
if (i < board.length - 1 && j < board[0].length - 1) if (i < board.length - 1) neighbors.add(new Integer[] {i + 1, j});
neighbors.add(new Integer[] {i + 1, j + 1});
if (i < board.length - 1 && j > 0) neighbors.add(new Integer[] {i + 1, j - 1}); if (j > 0) neighbors.add(new Integer[] {i, j - 1});
if (i > 0) neighbors.add(new Integer[] {i - 1, j}); if (j < board[0].length - 1) neighbors.add(new Integer[] {i, j + 1});
if (i < board.length - 1) neighbors.add(new Integer[] {i + 1, j}); return neighbors;
}
if (j > 0) neighbors.add(new Integer[] {i, j - 1});
if (j < board[0].length - 1) neighbors.add(new Integer[] {i, j + 1});
return neighbors;
}
} }
// Trie used to optimize string search // Trie used to optimize string search
class TrieNode { class TrieNode {
Map<Character, TrieNode> children = new HashMap<>(); Map<Character, TrieNode> children = new HashMap<>();
String word = ""; String word = "";
} }
class Trie { class Trie {
TrieNode root; TrieNode root;
char endSymbol; char endSymbol;
public Trie() { public Trie() {
this.root = new TrieNode(); this.root = new TrieNode();
this.endSymbol = '*'; this.endSymbol = '*';
} }
public void add(String str) { public void add(String str) {
TrieNode node = this.root; TrieNode node = this.root;
for (int i = 0; i < str.length(); i++) { for (int i = 0; i < str.length(); i++) {
char letter = str.charAt(i); char letter = str.charAt(i);
if (!node.children.containsKey(letter)) { if (!node.children.containsKey(letter)) {
TrieNode newNode = new TrieNode(); TrieNode newNode = new TrieNode();
node.children.put(letter, newNode); node.children.put(letter, newNode);
} }
node = node.children.get(letter); node = node.children.get(letter);
}
node.children.put(this.endSymbol, null);
node.word = str;
} }
node.children.put(this.endSymbol, null);
node.word = str;
}
} }