From f0cdb67ac1cdc91327f4df0cbe97f3a897ef90a8 Mon Sep 17 00:00:00 2001 From: Matej Focko Date: Sat, 2 Mar 2024 21:01:53 +0100 Subject: [PATCH] chore(java): format Signed-off-by: Matej Focko --- java/binary-search-tree-iterator.java | 109 ++++++------- java/buy-two-chocolates.java | 34 ++--- ...k-if-two-string-arrays-are-equivalent.java | 40 ++--- java/combination-sum-iv.java | 54 +++---- ...rt-sorted-array-to-binary-search-tree.java | 41 ++--- java/decode-ways.java | 84 +++++----- java/equal-row-and-column-pairs.java | 40 ++--- ...ords-that-can-be-formed-by-characters.java | 40 ++--- java/flatten-nested-list-iterator.java | 143 +++++++++--------- java/maximum-number-of-moves-in-a-grid.java | 40 ++--- ...aximum-score-after-splitting-a-string.java | 50 +++--- java/merge-strings-alternately.java | 32 ++-- ...ges-to-make-alternating-binary-string.java | 28 ++-- java/minimum-time-to-make-rope-colorful.java | 34 ++--- java/n-ary-tree-level-order-traversal.java | 34 ++--- java/number-of-1-bits.java | 18 +-- .../number-of-dice-rolls-with-target-sum.java | 44 +++--- java/peeking-iterator.java | 50 +++--- ...-characters-to-make-all-strings-equal.java | 32 ++-- ...ions-to-make-the-array-elements-equal.java | 20 +-- java/rle-iterator.java | 85 +++++------ 21 files changed, 520 insertions(+), 532 deletions(-) diff --git a/java/binary-search-tree-iterator.java b/java/binary-search-tree-iterator.java index 9b945f5..48ac8a7 100644 --- a/java/binary-search-tree-iterator.java +++ b/java/binary-search-tree-iterator.java @@ -17,72 +17,75 @@ import java.util.ArrayDeque; */ class TreeNode { - int val; - TreeNode left; - TreeNode right; - TreeNode() {} - TreeNode(int val) { this.val = val; } - TreeNode(int val, TreeNode left, TreeNode right) { - this.val = val; - this.left = left; - this.right = right; - } + int val; + TreeNode left; + TreeNode right; + + TreeNode() {} + + TreeNode(int val) { + this.val = val; + } + + TreeNode(int val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } } class BSTIterator { - private enum Position { - Todo, Done + private enum Position { + Todo, + Done + } + + private class Entry { + public TreeNode node; + public Position position; + + public Entry(TreeNode node, Position position) { + this.node = node; + this.position = position; } - private class Entry { - public TreeNode node; - public Position position; + public void expand(ArrayDeque stack) { + if (node.right != null) { + stack.addLast(new Entry(node.right, Position.Todo)); + } - public Entry(TreeNode node, Position position) { - this.node = node; - this.position = position; - } + this.position = Position.Done; + stack.addLast(this); - public void expand(ArrayDeque stack) { - if (node.right != null) { - stack.addLast(new Entry(node.right, Position.Todo)); - } + if (node.left != null) { + stack.addLast(new Entry(node.left, Position.Todo)); + } + } + } - this.position = Position.Done; - stack.addLast(this); + private ArrayDeque stack = new ArrayDeque<>(); - if (node.left != null) { - stack.addLast(new Entry(node.left, Position.Todo)); - } - } + public BSTIterator(TreeNode root) { + stack.addLast(new Entry(root, Position.Todo)); + } + + public int next() { + for (Entry last = stack.getLast(); + last != null && last.position == Position.Todo; + last = stack.getLast()) { + stack.removeLast().expand(stack); } - private ArrayDeque stack = new ArrayDeque<>(); - public BSTIterator(TreeNode root) { - stack.addLast(new Entry(root, Position.Todo)); - } + return stack.removeLast().node.val; + } - public int next() { - for ( - Entry last = stack.getLast(); - last != null && last.position == Position.Todo; - last = stack.getLast() - ) { - stack.removeLast().expand(stack); - } - - return stack.removeLast().node.val; - } - - public boolean hasNext() { - Entry last = stack.peekLast(); - return last != null && (last.position != Position.Todo || last.node != null); - } + public boolean hasNext() { + Entry last = stack.peekLast(); + return last != null && (last.position != Position.Todo || last.node != null); + } } /** - * Your BSTIterator object will be instantiated and called as such: - * BSTIterator obj = new BSTIterator(root); - * int param_1 = obj.next(); - * boolean param_2 = obj.hasNext(); + * Your BSTIterator object will be instantiated and called as such: BSTIterator obj = new + * BSTIterator(root); int param_1 = obj.next(); boolean param_2 = obj.hasNext(); */ diff --git a/java/buy-two-chocolates.java b/java/buy-two-chocolates.java index 5994607..2a592ef 100644 --- a/java/buy-two-chocolates.java +++ b/java/buy-two-chocolates.java @@ -1,21 +1,21 @@ class Solution { - public int buyChoco(int[] prices, int money) { - int[] mins = new int[2]; - mins[0] = mins[1] = Integer.MAX_VALUE; + public int buyChoco(int[] prices, int money) { + int[] mins = new int[2]; + mins[0] = mins[1] = Integer.MAX_VALUE; - for (int p : prices) { - if (p < mins[0]) { - mins[1] = mins[0]; - mins[0] = p; - } else if (p < mins[1]) { - mins[1] = p; - } - } - - int leftover = money - mins[0] - mins[1]; - if (leftover < 0) { - return money; - } - return leftover; + for (int p : prices) { + if (p < mins[0]) { + mins[1] = mins[0]; + mins[0] = p; + } else if (p < mins[1]) { + mins[1] = p; + } } + + int leftover = money - mins[0] - mins[1]; + if (leftover < 0) { + return money; + } + return leftover; + } } diff --git a/java/check-if-two-string-arrays-are-equivalent.java b/java/check-if-two-string-arrays-are-equivalent.java index fc49fbd..ab6b3de 100644 --- a/java/check-if-two-string-arrays-are-equivalent.java +++ b/java/check-if-two-string-arrays-are-equivalent.java @@ -1,27 +1,27 @@ class Solution { - public boolean arrayStringsAreEqual(String[] word1, String[] word2) { - int i = 0, ii = 0; - int j = 0, jj = 0; + public boolean arrayStringsAreEqual(String[] word1, String[] word2) { + int i = 0, ii = 0; + int j = 0, jj = 0; - while (i < word1.length && j < word2.length) { - if (word1[i].charAt(ii) != word2[j].charAt(jj)) { - return false; - } + while (i < word1.length && j < word2.length) { + if (word1[i].charAt(ii) != word2[j].charAt(jj)) { + return false; + } - ++ii; - ++jj; + ++ii; + ++jj; - if (ii >= word1[i].length()) { - ++i; - ii = 0; - } + if (ii >= word1[i].length()) { + ++i; + ii = 0; + } - if (jj >= word2[j].length()) { - ++j; - jj = 0; - } - } - - return i == word1.length && j == word2.length && ii == 0 && jj == 0; + if (jj >= word2[j].length()) { + ++j; + jj = 0; + } } + + return i == word1.length && j == word2.length && ii == 0 && jj == 0; + } } diff --git a/java/combination-sum-iv.java b/java/combination-sum-iv.java index fc4de1e..3117609 100644 --- a/java/combination-sum-iv.java +++ b/java/combination-sum-iv.java @@ -1,35 +1,35 @@ import java.util.TreeMap; class Solution { - private TreeMap cache; + private TreeMap cache; - private int combinationSumRec(int[] nums, int target) { - if (target < 0) { - // Base: Target is below zero - return 0; - } - - if (target == 0) { - // Base: We have found a possible combination - return 1; - } - - if (cache.containsKey(target)) { - // Base: Target is already precomputed - return cache.get(target); - } - - int combinations = 0; - for (int num : nums) { - combinations += combinationSumRec(nums, target - num); - } - - cache.put(target, combinations); - return combinations; + private int combinationSumRec(int[] nums, int target) { + if (target < 0) { + // Base: Target is below zero + return 0; } - public int combinationSum4(int[] nums, int target) { - cache = new TreeMap<>(); - return combinationSumRec(nums, target); + if (target == 0) { + // Base: We have found a possible combination + return 1; } + + if (cache.containsKey(target)) { + // Base: Target is already precomputed + return cache.get(target); + } + + int combinations = 0; + for (int num : nums) { + combinations += combinationSumRec(nums, target - num); + } + + cache.put(target, combinations); + return combinations; + } + + public int combinationSum4(int[] nums, int target) { + cache = new TreeMap<>(); + return combinationSumRec(nums, target); + } } diff --git a/java/convert-sorted-array-to-binary-search-tree.java b/java/convert-sorted-array-to-binary-search-tree.java index f24851c..33dd96a 100644 --- a/java/convert-sorted-array-to-binary-search-tree.java +++ b/java/convert-sorted-array-to-binary-search-tree.java @@ -1,33 +1,20 @@ /** - * Definition for a binary tree node. - * public class TreeNode { - * int val; - * TreeNode left; - * TreeNode right; - * TreeNode() {} - * TreeNode(int val) { this.val = val; } - * TreeNode(int val, TreeNode left, TreeNode right) { - * this.val = val; - * this.left = left; - * this.right = right; - * } - * } + * Definition for a binary tree node. public class TreeNode { int val; TreeNode left; TreeNode + * right; TreeNode() {} TreeNode(int val) { this.val = val; } TreeNode(int val, TreeNode left, + * TreeNode right) { this.val = val; this.left = left; this.right = right; } } */ class Solution { - private TreeNode sortedArrayToBST(int[] nums, int min, int max) { - if (min > max) { - return null; - } - - int mid = (min + max) / 2; - return new TreeNode( - nums[mid], - sortedArrayToBST(nums, min, mid - 1), - sortedArrayToBST(nums, mid + 1, max) - ); + private TreeNode sortedArrayToBST(int[] nums, int min, int max) { + if (min > max) { + return null; } - public TreeNode sortedArrayToBST(int[] nums) { - return sortedArrayToBST(nums, 0, nums.length - 1); - } + int mid = (min + max) / 2; + return new TreeNode( + nums[mid], sortedArrayToBST(nums, min, mid - 1), sortedArrayToBST(nums, mid + 1, max)); + } + + public TreeNode sortedArrayToBST(int[] nums) { + return sortedArrayToBST(nums, 0, nums.length - 1); + } } diff --git a/java/decode-ways.java b/java/decode-ways.java index 86782c4..d405445 100644 --- a/java/decode-ways.java +++ b/java/decode-ways.java @@ -1,50 +1,50 @@ class Solution { - private static final int EMPTY = -1; + private static final int EMPTY = -1; - private static int charToDigit(String s, int i) { - return s.charAt(i) - '0'; + private static int charToDigit(String s, int i) { + return s.charAt(i) - '0'; + } + + private int numDecodings(String s, int[] dp, int i) { + // out of bounds + if (i < 0 || i > s.length()) { + return 0; } - private int numDecodings(String s, int[] dp, int i) { - // out of bounds - if (i < 0 || i > s.length()) { - return 0; - } - - // final digit - if (i == s.length()) { - return 1; - } - - // starting with 0, not allowed - if (s.charAt(i) == '0') { - return 0; - } - - // solution has been already precomputed - if (dp[i] != EMPTY) { - return dp[i]; - } - - // taking just one digit - int result = numDecodings(s, dp, i + 1); - - // taking two digits - if (i + 1 < s.length() && charToDigit(s, i) * 10 + charToDigit(s, i + 1) <= 26) { - result += numDecodings(s, dp, i + 2); - } - - // save and return - dp[i] = result; - return result; + // final digit + if (i == s.length()) { + return 1; } - public int numDecodings(String s) { - int[] dp = new int[s.length()]; - for (int i = 0; i < dp.length; ++i) { - dp[i] = EMPTY; - } - - return numDecodings(s, dp, 0); + // starting with 0, not allowed + if (s.charAt(i) == '0') { + return 0; } + + // solution has been already precomputed + if (dp[i] != EMPTY) { + return dp[i]; + } + + // taking just one digit + int result = numDecodings(s, dp, i + 1); + + // taking two digits + if (i + 1 < s.length() && charToDigit(s, i) * 10 + charToDigit(s, i + 1) <= 26) { + result += numDecodings(s, dp, i + 2); + } + + // save and return + dp[i] = result; + return result; + } + + public int numDecodings(String s) { + int[] dp = new int[s.length()]; + for (int i = 0; i < dp.length; ++i) { + dp[i] = EMPTY; + } + + return numDecodings(s, dp, 0); + } } diff --git a/java/equal-row-and-column-pairs.java b/java/equal-row-and-column-pairs.java index 08571ee..39d94bb 100644 --- a/java/equal-row-and-column-pairs.java +++ b/java/equal-row-and-column-pairs.java @@ -1,27 +1,27 @@ class Solution { - public int equalPairs(int[][] grid) { - int count = 0, n = grid.length; + public int equalPairs(int[][] grid) { + int count = 0, n = grid.length; - // Check each row r against each column c. - for (int r = 0; r < n; ++r) { - for (int c = 0; c < n; ++c) { - boolean match = true; + // Check each row r against each column c. + for (int r = 0; r < n; ++r) { + for (int c = 0; c < n; ++c) { + boolean match = true; - // Iterate over row r and column c. - for (int i = 0; i < n; ++i) { - if (grid[r][i] != grid[i][c]) { - match = false; - break; - } - } - - // If row r equals column c, increment count by 1. - if (match) { - count++; - } - } + // Iterate over row r and column c. + for (int i = 0; i < n; ++i) { + if (grid[r][i] != grid[i][c]) { + match = false; + break; + } } - return count; + // If row r equals column c, increment count by 1. + if (match) { + count++; + } + } } + + return count; + } } diff --git a/java/find-words-that-can-be-formed-by-characters.java b/java/find-words-that-can-be-formed-by-characters.java index fc49fbd..ab6b3de 100644 --- a/java/find-words-that-can-be-formed-by-characters.java +++ b/java/find-words-that-can-be-formed-by-characters.java @@ -1,27 +1,27 @@ class Solution { - public boolean arrayStringsAreEqual(String[] word1, String[] word2) { - int i = 0, ii = 0; - int j = 0, jj = 0; + public boolean arrayStringsAreEqual(String[] word1, String[] word2) { + int i = 0, ii = 0; + int j = 0, jj = 0; - while (i < word1.length && j < word2.length) { - if (word1[i].charAt(ii) != word2[j].charAt(jj)) { - return false; - } + while (i < word1.length && j < word2.length) { + if (word1[i].charAt(ii) != word2[j].charAt(jj)) { + return false; + } - ++ii; - ++jj; + ++ii; + ++jj; - if (ii >= word1[i].length()) { - ++i; - ii = 0; - } + if (ii >= word1[i].length()) { + ++i; + ii = 0; + } - if (jj >= word2[j].length()) { - ++j; - jj = 0; - } - } - - return i == word1.length && j == word2.length && ii == 0 && jj == 0; + if (jj >= word2[j].length()) { + ++j; + jj = 0; + } } + + return i == word1.length && j == word2.length && ii == 0 && jj == 0; + } } diff --git a/java/flatten-nested-list-iterator.java b/java/flatten-nested-list-iterator.java index e3cf218..8491f3e 100644 --- a/java/flatten-nested-list-iterator.java +++ b/java/flatten-nested-list-iterator.java @@ -5,99 +5,100 @@ import java.util.List; // This is the interface that allows for creating nested lists. // You should not implement it, or speculate about its implementation interface NestedInteger { - // @return true if this NestedInteger holds a single integer, rather than a nested list. - public boolean isInteger(); - // @return the single integer that this NestedInteger holds, if it holds a single integer - // Return null if this NestedInteger holds a nested list - public Integer getInteger(); - // @return the nested list that this NestedInteger holds, if it holds a nested list - // Return empty list if this NestedInteger holds a single integer - public List getList(); + // @return true if this NestedInteger holds a single integer, rather than a nested list. + public boolean isInteger(); + + // @return the single integer that this NestedInteger holds, if it holds a single integer + // Return null if this NestedInteger holds a nested list + public Integer getInteger(); + + // @return the nested list that this NestedInteger holds, if it holds a nested list + // Return empty list if this NestedInteger holds a single integer + public List getList(); } class NestedIterator implements Iterator { - private class DFSEntry { - private List it; - private int i = 0; + private class DFSEntry { + private List it; + private int i = 0; - public DFSEntry(List it) { - this.it = it; - } - - private int size() { - return it.size(); - } - - public boolean isEmpty() { - return i >= size(); - } - - public NestedInteger at() { - return it.get(i); - } - - public void advance() { - i++; - } + public DFSEntry(List it) { + this.it = it; } - ArrayDeque stack = new ArrayDeque<>(); - - public NestedIterator(List nestedList) { - stack.addLast(new DFSEntry(nestedList)); - findNext(); + private int size() { + return it.size(); } - private DFSEntry top() { - return stack.peekLast(); + public boolean isEmpty() { + return i >= size(); } - // Performs one „iteration“ of the DFS algorithm - private void findNext() { - while (!stack.isEmpty()) { - // We ran out of successors - if (top().isEmpty()) { - stack.removeLast(); + public NestedInteger at() { + return it.get(i); + } - // Advance the parent of the removed list - if (top() != null) { - top().advance(); - } + public void advance() { + i++; + } + } - continue; - } + ArrayDeque stack = new ArrayDeque<>(); - // Base: we have found an integer - if (top().at().isInteger()) { - return; - } + public NestedIterator(List nestedList) { + stack.addLast(new DFSEntry(nestedList)); + findNext(); + } - stack.addLast(new DFSEntry(top().at().getList())); + private DFSEntry top() { + return stack.peekLast(); + } + + // Performs one „iteration“ of the DFS algorithm + private void findNext() { + while (!stack.isEmpty()) { + // We ran out of successors + if (top().isEmpty()) { + stack.removeLast(); + + // Advance the parent of the removed list + if (top() != null) { + top().advance(); } + + continue; + } + + // Base: we have found an integer + if (top().at().isInteger()) { + return; + } + + stack.addLast(new DFSEntry(top().at().getList())); } + } - @Override - public Integer next() { - DFSEntry top = stack.getLast(); - Integer e = top.at().getInteger(); + @Override + public Integer next() { + DFSEntry top = stack.getLast(); + Integer e = top.at().getInteger(); - // Find next integer in the nested list - top.advance(); - findNext(); + // Find next integer in the nested list + top.advance(); + findNext(); - // Return the popped element - return e; - } + // Return the popped element + return e; + } - @Override - public boolean hasNext() { - return !stack.isEmpty(); - } + @Override + public boolean hasNext() { + return !stack.isEmpty(); + } } /** - * Your NestedIterator object will be instantiated and called as such: - * NestedIterator i = new NestedIterator(nestedList); - * while (i.hasNext()) v[f()] = i.next(); + * Your NestedIterator object will be instantiated and called as such: NestedIterator i = new + * NestedIterator(nestedList); while (i.hasNext()) v[f()] = i.next(); */ diff --git a/java/maximum-number-of-moves-in-a-grid.java b/java/maximum-number-of-moves-in-a-grid.java index caa4619..a989842 100644 --- a/java/maximum-number-of-moves-in-a-grid.java +++ b/java/maximum-number-of-moves-in-a-grid.java @@ -1,26 +1,26 @@ class Solution { - public int maxMoves(int[][] grid) { - int[][] dp = new int[grid.length][grid[0].length]; + public int maxMoves(int[][] grid) { + int[][] dp = new int[grid.length][grid[0].length]; - for (int x = grid[0].length - 2; x >= 0; --x) { - for (int y = 0; y < dp.length; ++y) { - // check neighbours for moves - for (int dy = -1; dy <= 1; ++dy) { - int ny = y + dy; - if (ny < 0 || ny >= dp.length || grid[y][x] >= grid[ny][x + 1]) { - continue; - } + for (int x = grid[0].length - 2; x >= 0; --x) { + for (int y = 0; y < dp.length; ++y) { + // check neighbours for moves + for (int dy = -1; dy <= 1; ++dy) { + int ny = y + dy; + if (ny < 0 || ny >= dp.length || grid[y][x] >= grid[ny][x + 1]) { + continue; + } - dp[y][x] = Math.max(dp[y][x], 1 + dp[ny][x + 1]); - } - } + dp[y][x] = Math.max(dp[y][x], 1 + dp[ny][x + 1]); } - - int m = 0; - for (int y = 0; y < grid.length; ++y) { - m = Math.max(m, dp[y][0]); - } - - return m; + } } + + int m = 0; + for (int y = 0; y < grid.length; ++y) { + m = Math.max(m, dp[y][0]); + } + + return m; + } } diff --git a/java/maximum-score-after-splitting-a-string.java b/java/maximum-score-after-splitting-a-string.java index 9d27a31..0b2346d 100644 --- a/java/maximum-score-after-splitting-a-string.java +++ b/java/maximum-score-after-splitting-a-string.java @@ -1,28 +1,28 @@ class Solution { - public int maxScore(String s) { - // count the ones - int ones = 0; - for (int i = 1; i < s.length(); ++i) { - if (s.charAt(i) == '1') { - ++ones; - } - } - int zeros = s.charAt(0) == '0' ? 1 : 0; - - int foundScore = ones + zeros; - for (int i = 1; i < s.length() - 1; ++i) { - switch (s.charAt(i)) { - case '0': - ++zeros; - break; - case '1': - --ones; - break; - } - - foundScore = Math.max(foundScore, ones + zeros); - } - - return foundScore; + public int maxScore(String s) { + // count the ones + int ones = 0; + for (int i = 1; i < s.length(); ++i) { + if (s.charAt(i) == '1') { + ++ones; + } } + int zeros = s.charAt(0) == '0' ? 1 : 0; + + int foundScore = ones + zeros; + for (int i = 1; i < s.length() - 1; ++i) { + switch (s.charAt(i)) { + case '0': + ++zeros; + break; + case '1': + --ones; + break; + } + + foundScore = Math.max(foundScore, ones + zeros); + } + + return foundScore; + } } diff --git a/java/merge-strings-alternately.java b/java/merge-strings-alternately.java index 3f91cb8..d3147e8 100644 --- a/java/merge-strings-alternately.java +++ b/java/merge-strings-alternately.java @@ -1,20 +1,20 @@ class Solution { - public String mergeAlternately(String word1, String word2) { - StringBuilder sb = new StringBuilder(word1.length() + word2.length()); + public String mergeAlternately(String word1, String word2) { + StringBuilder sb = new StringBuilder(word1.length() + word2.length()); - int i, j; - for (i = 0, j = 0; i < word1.length() && j < word2.length(); ++i, ++j) { - sb.append(word1.charAt(i)); - sb.append(word2.charAt(j)); - } - - if (i < word1.length()) { - sb.append(word1.substring(i)); - } - if (j < word2.length()) { - sb.append(word2.substring(j)); - } - - return sb.toString(); + int i, j; + for (i = 0, j = 0; i < word1.length() && j < word2.length(); ++i, ++j) { + sb.append(word1.charAt(i)); + sb.append(word2.charAt(j)); } + + if (i < word1.length()) { + sb.append(word1.substring(i)); + } + if (j < word2.length()) { + sb.append(word2.substring(j)); + } + + return sb.toString(); + } } diff --git a/java/minimum-changes-to-make-alternating-binary-string.java b/java/minimum-changes-to-make-alternating-binary-string.java index c5d0691..1897ac2 100644 --- a/java/minimum-changes-to-make-alternating-binary-string.java +++ b/java/minimum-changes-to-make-alternating-binary-string.java @@ -1,20 +1,20 @@ class Solution { - public int minOperations(String s) { - int startingZero = 0; - int startingOne = 0; + public int minOperations(String s) { + int startingZero = 0; + int startingOne = 0; - for (int i = 0; i < s.length(); ++i) { - char c = s.charAt(i); + for (int i = 0; i < s.length(); ++i) { + char c = s.charAt(i); - if (c != '0' + i % 2) { - ++startingZero; - } + if (c != '0' + i % 2) { + ++startingZero; + } - if (c != '0' + (i + 1) % 2) { - ++startingOne; - } - } - - return Math.min(startingZero, startingOne); + if (c != '0' + (i + 1) % 2) { + ++startingOne; + } } + + return Math.min(startingZero, startingOne); + } } diff --git a/java/minimum-time-to-make-rope-colorful.java b/java/minimum-time-to-make-rope-colorful.java index 32eedf3..2b6fe87 100644 --- a/java/minimum-time-to-make-rope-colorful.java +++ b/java/minimum-time-to-make-rope-colorful.java @@ -1,21 +1,21 @@ class Solution { - public int minCost(String colors, int[] neededTime) { - int[] dp = new int[colors.length() + 1]; - Arrays.fill(dp, 0); - char previousColor = 0; - int previousTime = 0; + public int minCost(String colors, int[] neededTime) { + int[] dp = new int[colors.length() + 1]; + Arrays.fill(dp, 0); + char previousColor = 0; + int previousTime = 0; - for (int i = 1; i <= colors.length(); ++i) { - if (colors.charAt(i - 1) == previousColor) { - dp[i] = dp[i - 1] + Math.min(previousTime, neededTime[i - 1]); - previousTime = Math.max(previousTime, neededTime[i - 1]); - } else { - dp[i] = dp[i - 1]; - previousColor = colors.charAt(i - 1); - previousTime = neededTime[i - 1]; - } - } - - return dp[colors.length()]; + for (int i = 1; i <= colors.length(); ++i) { + if (colors.charAt(i - 1) == previousColor) { + dp[i] = dp[i - 1] + Math.min(previousTime, neededTime[i - 1]); + previousTime = Math.max(previousTime, neededTime[i - 1]); + } else { + dp[i] = dp[i - 1]; + previousColor = colors.charAt(i - 1); + previousTime = neededTime[i - 1]; + } } + + return dp[colors.length()]; + } } diff --git a/java/n-ary-tree-level-order-traversal.java b/java/n-ary-tree-level-order-traversal.java index b6711d0..44f7322 100644 --- a/java/n-ary-tree-level-order-traversal.java +++ b/java/n-ary-tree-level-order-traversal.java @@ -18,24 +18,24 @@ class Node { */ class Solution { - private void levelOrder(ArrayList> traversal, Node root, int level) { - if (root == null) { - return; - } - - if (level >= traversal.size()) { - traversal.add(new ArrayList()); - } - traversal.get(level).add(root.val); - - for (var child : root.children) { - levelOrder(traversal, child, level + 1); - } + private void levelOrder(ArrayList> traversal, Node root, int level) { + if (root == null) { + return; } - public List> levelOrder(Node root) { - ArrayList> result = new ArrayList<>(); - levelOrder(result, root, 0); - return result; + if (level >= traversal.size()) { + traversal.add(new ArrayList()); } + traversal.get(level).add(root.val); + + for (var child : root.children) { + levelOrder(traversal, child, level + 1); + } + } + + public List> levelOrder(Node root) { + ArrayList> result = new ArrayList<>(); + levelOrder(result, root, 0); + return result; + } } diff --git a/java/number-of-1-bits.java b/java/number-of-1-bits.java index 57862d9..06adf64 100644 --- a/java/number-of-1-bits.java +++ b/java/number-of-1-bits.java @@ -1,13 +1,13 @@ public class Solution { - public int hammingWeight(int n) { - int bits = 0; + public int hammingWeight(int n) { + int bits = 0; - for (int i = 0; i < 32; ++i) { - if ((n & (1 << i)) != 0) { - ++bits; - } - } - - return bits; + for (int i = 0; i < 32; ++i) { + if ((n & (1 << i)) != 0) { + ++bits; + } } + + return bits; + } } diff --git a/java/number-of-dice-rolls-with-target-sum.java b/java/number-of-dice-rolls-with-target-sum.java index 2b24e67..896728a 100644 --- a/java/number-of-dice-rolls-with-target-sum.java +++ b/java/number-of-dice-rolls-with-target-sum.java @@ -1,27 +1,25 @@ class Solution { - private static final long MOD = 1000000007; + private static final long MOD = 1000000007; - public int numRollsToTarget(int n, int k, int target) { - // out of bounds - if (n > target || target > n * k) { - return 0; - } - - long[][] dp = new long[n + 1][target + 1]; - dp[0][0] = 1; - - for (int toss = 1; toss <= n; ++toss) { - for ( - int sumIdx = toss, maxSumIdx = Math.min(target, toss * k); - sumIdx <= maxSumIdx; - ++sumIdx - ) { - for (int f = 1; f <= Math.min(k, sumIdx); ++f) { - dp[toss][sumIdx] = (dp[toss][sumIdx] + dp[toss - 1][sumIdx - f]) % MOD; - } - } - } - - return (int) dp[n][target]; + public int numRollsToTarget(int n, int k, int target) { + // out of bounds + if (n > target || target > n * k) { + return 0; } + + long[][] dp = new long[n + 1][target + 1]; + dp[0][0] = 1; + + for (int toss = 1; toss <= n; ++toss) { + for (int sumIdx = toss, maxSumIdx = Math.min(target, toss * k); + sumIdx <= maxSumIdx; + ++sumIdx) { + for (int f = 1; f <= Math.min(k, sumIdx); ++f) { + dp[toss][sumIdx] = (dp[toss][sumIdx] + dp[toss - 1][sumIdx - f]) % MOD; + } + } + } + + return (int) dp[n][target]; + } } diff --git a/java/peeking-iterator.java b/java/peeking-iterator.java index 98440f7..ab8b422 100644 --- a/java/peeking-iterator.java +++ b/java/peeking-iterator.java @@ -1,32 +1,32 @@ class PeekingIterator implements Iterator { - private Iterator it; + private Iterator it; - private Integer pVal; - private boolean pHasNext; + private Integer pVal; + private boolean pHasNext; - public PeekingIterator(Iterator iterator) { - it = iterator; - next(); + public PeekingIterator(Iterator iterator) { + it = iterator; + next(); + } + + public Integer peek() { + return pVal; + } + + @Override + public Integer next() { + pHasNext = it.hasNext(); + + Integer oldValue = pVal; + if (pHasNext) { + pVal = it.next(); } - public Integer peek() { - return pVal; - } + return oldValue; + } - @Override - public Integer next() { - pHasNext = it.hasNext(); - - Integer oldValue = pVal; - if (pHasNext) { - pVal = it.next(); - } - - return oldValue; - } - - @Override - public boolean hasNext() { - return pHasNext; - } + @Override + public boolean hasNext() { + return pHasNext; + } } diff --git a/java/redistribute-characters-to-make-all-strings-equal.java b/java/redistribute-characters-to-make-all-strings-equal.java index ebb1ed5..de07a41 100644 --- a/java/redistribute-characters-to-make-all-strings-equal.java +++ b/java/redistribute-characters-to-make-all-strings-equal.java @@ -1,20 +1,20 @@ class Solution { - public boolean makeEqual(String[] words) { - int[] counters = new int[26]; + public boolean makeEqual(String[] words) { + int[] counters = new int[26]; - for (String w : words) { - for (int i = 0; i < w.length(); ++i) { - ++counters[w.charAt(i) - 'a']; - } - } - - int N = words.length; - for (int count : counters) { - if (count % N != 0) { - return false; - } - } - - return true; + for (String w : words) { + for (int i = 0; i < w.length(); ++i) { + ++counters[w.charAt(i) - 'a']; + } } + + int N = words.length; + for (int count : counters) { + if (count % N != 0) { + return false; + } + } + + return true; + } } diff --git a/java/reduction-operations-to-make-the-array-elements-equal.java b/java/reduction-operations-to-make-the-array-elements-equal.java index 8ad947d..1d28b13 100644 --- a/java/reduction-operations-to-make-the-array-elements-equal.java +++ b/java/reduction-operations-to-make-the-array-elements-equal.java @@ -1,15 +1,15 @@ class Solution { - public int reductionOperations(int[] nums) { - Arrays.sort(nums); + public int reductionOperations(int[] nums) { + Arrays.sort(nums); - int counter = 0; + int counter = 0; - for (int i = nums.length - 1; i > 0; --i) { - if (nums[i - 1] != nums[i]) { - counter += nums.length - i; - } - } - - return counter; + for (int i = nums.length - 1; i > 0; --i) { + if (nums[i - 1] != nums[i]) { + counter += nums.length - i; + } } + + return counter; + } } diff --git a/java/rle-iterator.java b/java/rle-iterator.java index 3103214..cfc83a0 100644 --- a/java/rle-iterator.java +++ b/java/rle-iterator.java @@ -1,55 +1,54 @@ class RLEIterator { - private int[] encoding; - private int major = 0; - private int minor = 0; + private int[] encoding; + private int major = 0; + private int minor = 0; - public RLEIterator(int[] encoding) { - this.encoding = encoding; + public RLEIterator(int[] encoding) { + this.encoding = encoding; + } + + private void nextSegment() { + major += 2; + minor = 0; + } + + private int lastConsumed() { + if (major == 0 && minor == 0) { + // Haven't consumed anything + return -1; + } else if (major <= encoding.length && minor == 0) { + // Consumed last element of a previous segment + return encoding[major - 1]; + } else if (major >= encoding.length) { + // Everything was consumed + return -1; } - private void nextSegment() { - major += 2; - minor = 0; + // Last consumed from the current segment + return encoding[major + 1]; + } + + public int next(int n) { + while (n > 0 && major < encoding.length) { + int consumed = Math.min(n, encoding[major] - minor); + + n -= consumed; + minor += consumed; + + if (minor == encoding[major]) { + nextSegment(); + } } - private int lastConsumed() { - if (major == 0 && minor == 0) { - // Haven't consumed anything - return -1; - } else if (major <= encoding.length && minor == 0) { - // Consumed last element of a previous segment - return encoding[major - 1]; - } else if (major >= encoding.length) { - // Everything was consumed - return -1; - } - - // Last consumed from the current segment - return encoding[major + 1]; + if (n > 0) { + return -1; } - public int next(int n) { - while (n > 0 && major < encoding.length) { - int consumed = Math.min(n, encoding[major] - minor); - - n -= consumed; - minor += consumed; - - if (minor == encoding[major]) { - nextSegment(); - } - } - - if (n > 0) { - return -1; - } - - return lastConsumed(); - } + return lastConsumed(); + } } /** - * Your RLEIterator object will be instantiated and called as such: - * RLEIterator obj = new RLEIterator(encoding); - * int param_1 = obj.next(n); + * Your RLEIterator object will be instantiated and called as such: RLEIterator obj = new + * RLEIterator(encoding); int param_1 = obj.next(n); */