Solved leetcode: strings

Author: zacscoding

leetcode/src/algorithm/easy/p125/Solution.java

@@ -0,0 +1,66 @@
+package algorithm.easy.p125;
+
+/**
+ * https://leetcode.com/problems/valid-palindrome/
+ * 2 ms	/ 39 MB
+ */
+public class Solution {
+ public boolean isPalindrome(String s) {
+ s = extractAlphaNumeric(s);
+ if (s.isEmpty()) {
+ return true;
+ }
+ return checkPalindrome(s);
+ }
+
+ public static String extractAlphaNumeric(String s) {
+ StringBuilder result = new StringBuilder(s.length());
+ int upperLowerGap = 'a' - 'A';
+ for (int i = 0; i < s.length(); i++) {
+ char ch = s.charAt(i);
+ if (ch >= 'A' && ch <= 'Z') {
+ result.append((char) (ch + upperLowerGap));
+ continue;
+ }
+ if ((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) {
+ result.append(ch);
+ }
+ }
+ return result.toString();
+ }
+
+// public static String extractAlphaNumeric(String s) {
+// StringBuilder result = new StringBuilder(s.length());
+// for (int i = 0; i < s.length(); i++) {
+// char ch = s.charAt(i);
+// if (Character.isAlphabetic(ch) || Character.isDigit(ch)) {
+// result.append(Character.toLowerCase(ch));
+// }
+// }
+// return result.toString();
+// }
+
+ public static boolean checkPalindrome(String s) {
+ int half = s.length() / 2;
+ for (int i = 0; i < half; i++) {
+ char cur = s.charAt(i);
+ char comp = s.charAt(s.length() - i - 1);
+ if (cur != comp) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static void main(String[] args) {
+ String[] examples = {
+ "A man, a plan, a canal: Panama",
+ "race a car",
+ " "
+ };
+
+ for (String example : examples) {
+ System.out.println("Check: " + example + " >> " + new Solution().isPalindrome(example));
+ }
+ }
+}

leetcode/src/algorithm/easy/p125/SolutionByDequeue.java

@@ -0,0 +1,56 @@
+package algorithm.easy.p125;
+
+import java.util.*;
+
+/**
+ * https://leetcode.com/problems/valid-palindrome/
+ * 3 ms	/ 38.9 MB
+ */
+public class SolutionByDequeue {
+
+ public boolean isPalindrome(String s) {
+ Deque<Character> deque = new ArrayDeque<>(s.length());
+
+ for (int i = 0; i < s.length(); i++) {
+ char ch = s.charAt(i);
+ if (!isAlphaNumeric(ch)) {
+ continue;
+ }
+ deque.addLast(Character.toLowerCase(ch));
+ }
+
+ if (deque.isEmpty()) {
+ return true;
+ }
+
+ while (!deque.isEmpty()) {
+ Character left = deque.pollFirst();
+ Character right = deque.pollLast();
+ if (right == null) {
+ return true;
+ }
+ if (!left.equals(right)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static boolean isAlphaNumeric(char ch) {
+ return (ch >= 'A' && ch <= 'Z')
+ || (ch >= 'a' && ch <= 'z')
+ || (ch >= '0' && ch <= '9');
+ }
+
+ public static void main(String[] args) {
+ String[] examples = {
+ "A man, a plan, a canal: Panama",
+ "race a car",
+ " "
+ };
+
+ for (String example : examples) {
+ System.out.println("Check: " + example + " >> " + new SolutionByDequeue().isPalindrome(example));
+ }
+ }
+}

leetcode/src/algorithm/easy/p125/SolutionByReverse.java

@@ -0,0 +1,26 @@
+package algorithm.easy.p125;
+
+/**
+ * https://leetcode.com/problems/valid-palindrome/
+ * 3 ms	/ 39.1 MB
+ */
+public class SolutionByReverse {
+ public boolean isPalindrome(String s) {
+ StringBuilder result = new StringBuilder(s.length());
+ for (int i = 0; i < s.length(); i++) {
+ char ch = s.charAt(i);
+ if (ch >= 'A' && ch <= 'Z') {
+ result.append(Character.toLowerCase(ch));
+ continue;
+ }
+ if ((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')) {
+ result.append(ch);
+ }
+ }
+
+ String origin = result.toString();
+ String reverse = result.reverse().toString();
+
+ return origin.isEmpty() || origin.equals(reverse);
+ }
+}

leetcode/src/algorithm/easy/p344/Solution.java

@@ -0,0 +1,24 @@
+package algorithm.easy.p344;
+
+/**
+ * https://leetcode.com/problems/reverse-string/
+ * 1 ms	/ 46 MB
+ */
+public class Solution {
+
+ public void reverseString(char[] s) {
+ int len = s.length / 2;
+ for (int i = 0; i < len; i++) {
+ int ridx = s.length - i - 1;
+ char t = s[i];
+ s[i] = s[ridx];
+ s[ridx] = t;
+ }
+ }
+
+ public static void main(String[] args) {
+ char[] s = { 'h', 'e', 'l', 'l', 'o' };
+ new Solution().reverseString(s);
+ System.out.println(s);
+ }
+}

leetcode/src/algorithm/easy/p344/SolutionByTwoPoint.java

@@ -0,0 +1,24 @@
+package algorithm.easy.p344;
+
+/**
+ * https://leetcode.com/problems/reverse-string/
+ * 1 ms	/ 46 MB
+ */
+public class SolutionByTwoPoint {
+ public void reverseString(char[] s) {
+ int left = 0, right = s.length - 1;
+ while (left < right) {
+ char t = s[left];
+ s[left] = s[right];
+ s[right] = t;
+ left++;
+ right--;
+ }
+ }
+
+ public static void main(String[] args) {
+ char[] s = { 'h', 'e', 'l', 'l', 'o' };
+ new SolutionByTwoPoint().reverseString(s);
+ System.out.println(s);
+ }
+}

leetcode/src/algorithm/easy/p937/Solution.java

@@ -0,0 +1,78 @@
+package algorithm.easy.p937;
+
+import java.util.*;
+
+/**
+ * https://leetcode.com/problems/reorder-data-in-log-files/
+ * 2 ms	/ 38.9 MB
+ */
+public class Solution {
+ public String[] reorderLogFiles(String[] logs) {
+ PriorityQueue<LettersLog> lettersQueue = new PriorityQueue<>(logs.length);
+ List<String> digitLogs = new ArrayList<>(logs.length);
+
+ for (String log : logs) {
+ // split to identifier, contents
+ int idx = log.indexOf(' ');
+ String identifier = log.substring(0, idx);
+ String contents = log.substring(idx + 1);
+
+ // check letters-logs or digit-logs
+ if (isDigitLogs(contents)) {
+ digitLogs.add(log);
+ continue;
+ }
+ lettersQueue.offer(new LettersLog(log, identifier, contents));
+ }
+
+ String[] ret = new String[logs.length];
+ int idx = 0;
+ while (!lettersQueue.isEmpty()) {
+ LettersLog log = lettersQueue.poll();
+ ret[idx++] = log.origin;
+ }
+
+ for (String log : digitLogs) {
+ ret[idx++] = log;
+ }
+ return ret;
+ }
+
+ static boolean isDigitLogs(String log) {
+ for (int i = 0; i < log.length(); i++) {
+ char ch = log.charAt(i);
+ if (ch != ' ' && !Character.isDigit(ch)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ static class LettersLog implements Comparable<LettersLog> {
+ String origin;
+ String identifier;
+ String contents;
+
+ public LettersLog(String origin, String identifier, String contents) {
+ this.origin = origin;
+ this.identifier = identifier;
+ this.contents = contents;
+ }
+
+ @Override
+ public int compareTo(LettersLog o) {
+ int cmp = contents.compareTo(o.contents);
+ if (cmp != 0) {
+ return cmp;
+ }
+ return identifier.compareTo(o.identifier);
+ }
+ }
+
+ public static void main(String[] args) {
+ // String[] logs = { "dig1 8 1 5 1", "let1 art can", "dig2 3 6", "let2 own kit dig", "let3 art zero" };
+ String[] logs = { "a1 9 2 3 1", "g1 act car", "zo4 4 7", "ab1 off key dog", "a8 act zoo" };
+ String[] results = new Solution().reorderLogFiles(logs);
+ System.out.println(Arrays.toString(results));
+ }
+}