Added task 556.

src/main/java/g0501_0600/s0514_freedom_trail/Solution.java

@@ -5,6 +5,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+@SuppressWarnings("unchecked")
 public class Solution {
  public int findRotateSteps(String ring, String key) {
  List<Integer>[] indexs = new List[26];

src/main/java/g0501_0600/s0556_next_greater_element_iii/Solution.java

@@ -0,0 +1,69 @@
+package g0501_0600.s0556_next_greater_element_iii;
+
+// #Medium #String #Math #Two_Pointers
+
+public class Solution {
+ /*
+ - What this problem wants is finding the next permutation of n
+ - Steps to find the next permuation:
+ find largest index k such that inp[k] < inp[k+1];
+ if k == -1: return -1
+ else:
+ look for largest index l such that inp[l] > inp[k]
+ swap the two index
+ reverse from k+1 to n.length
+ */
+ public int nextGreaterElement(int n) {
+ char[] inp = String.valueOf(n).toCharArray();
+ // Find k
+ int k = -1;
+ for (int i = inp.length - 2; i >= 0; i--) {
+ if (inp[i] < inp[i + 1]) {
+ k = i;
+ break;
+ }
+ }
+ if (k == -1) {
+ return -1;
+ }
+ // Find l
+ int largerIdx = inp.length - 1;
+ for (int i = inp.length - 1; i >= 0; i--) {
+ if (inp[i] > inp[k]) {
+ largerIdx = i;
+ break;
+ }
+ }
+ swap(inp, k, largerIdx);
+ reverse(inp, k + 1, inp.length - 1);
+ // Build result
+ int ret = 0;
+ for (int i = 0; i < inp.length; i++) {
+ int digit = inp[i] - '0';
+ // Handle the case if ret > Integer.MAX_VALUE - This idea is borrowed from problem 8.
+ // String to Integer (atoi)
+ if (ret > Integer.MAX_VALUE / 10
+ || (ret == Integer.MAX_VALUE / 10 && digit > Integer.MAX_VALUE % 10)) {
+ return -1;
+ }
+ ret = ret * 10 + (inp[i] - '0');
+ }
+ return ret;
+ }
+
+ private void swap(char[] inp, int i, int j) {
+ char temp = inp[i];
+ inp[i] = inp[j];
+ inp[j] = temp;
+ }
+
+ private void reverse(char[] inp, int start, int end) {
+ while (start < end) {
+ char temp = inp[start];
+ inp[start] = inp[end];
+ inp[end] = temp;
+ start++;
+ end--;
+ }
+ }
+}

src/main/java/g0501_0600/s0556_next_greater_element_iii/readme.md

@@ -0,0 +1,23 @@
+556\. Next Greater Element III
+
+Medium
+
+Given a positive integer `n`, find _the smallest integer which has exactly the same digits existing in the integer_ `n` _and is greater in value than_ `n`. If no such positive integer exists, return `-1`.
+
+**Note** that the returned integer should fit in **32-bit integer**, if there is a valid answer but it does not fit in **32-bit integer**, return `-1`.
+
+**Example 1:**
+
+**Input:** n = 12
+
+**Output:** 21 
+
+**Example 2:**
+
+**Input:** n = 21
+
+**Output:** -1 
+
+**Constraints:**
+
+* <code>1 <= n <= 2<sup>31</sup> - 1</code>

src/test/java/g0501_0600/s0556_next_greater_element_iii/SolutionTest.java

@@ -0,0 +1,18 @@
+package g0501_0600.s0556_next_greater_element_iii;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void nextGreaterElement() {
+ assertThat(new Solution().nextGreaterElement(12), equalTo(21));
+ }
+
+ @Test
+ void nextGreaterElement2() {
+ assertThat(new Solution().nextGreaterElement(21), equalTo(-1));
+ }
+}