Dev

src/array/SumContinueListOfS.java

@@ -0,0 +1,38 @@
+package array;
+
+import java.util.ArrayList;
+
+public class SumContinueListOfS {
+
+    public ArrayList<ArrayList<Integer>> FindContinuousSequence(int sum) {
+        ArrayList<ArrayList<Integer>> ret = new ArrayList<ArrayList<Integer>>();
+        if (sum < 3) return ret;
+        int l = 1, r = 2;
+        int cur = 3;
+        int mid = sum / 2;
+        while (r < mid || l < r) {
+            if (cur == sum)
+                ret.add(saveList(l, r));
+
+            r++;
+            cur += r;
+            while (cur > sum) {
+                cur -= l;
+                l++;
+            }
+        }
+
+        return ret;
+    }
+
+    private ArrayList<Integer> saveList(int l, int r) {
+        ArrayList<Integer> ret = new ArrayList<>();
+        for (int i = l; i < r; i++) {
+            ret.add(i);
+        }
+
+        return ret;
+    }
+
+
+}

src/array/SumOfS.java

@@ -0,0 +1,31 @@
+package array;
+
+import java.util.ArrayList;
+
+public class SumOfS {
+
+    public ArrayList<Integer> FindNumbersWithSum(int [] array, int sum) {
+        ArrayList<Integer> ret = new ArrayList<>();
+        if (array.length == 0) return ret;
+        int l = 0, r = array.length-1;
+        while (l < r){
+            int total = array[l] + array[r];
+            if (total == sum){
+                ret.add(array[l]);
+                ret.add(array[r]);
+                return ret;
+            }else if (total > sum){
+                r--;
+            }else{
+                l++;
+            }
+        }
+        return ret;
+    }
+
+    public static void main(String[] args) {
+        ArrayList<Integer> val;
+        val = new SumOfS().FindNumbersWithSum(new int[]{1,2,4,7,11,15}, 15);
+        val.forEach(System.out::println);
+    }
+}

src/stringAndChar/AddZeros.java

@@ -0,0 +1,43 @@
+package stringAndChar;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Scanner;
+
+public class AddZeros {
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        ArrayList<String> ret = new ArrayList<>();
+        while (scanner.hasNext()){
+            int n = scanner.nextInt();
+            for (int i = 0; i < n; i++) {
+                String str = scanner.next();
+                if ("".equals(str)) ret.add("");
+                if (str.length() <= 8) {
+                    for (int j = str.length(); j < 8; j++) {
+                        str += "0";
+                    }
+                    ret.add(str);
+                }else {
+                    for (int j = 0; j < str.length(); j+=8) {
+                        int remain = str.length() - j;
+                        if (remain <= 8) {
+                            String remain_str = str.substring(j, str.length());
+                            for (int k = remain; k < 8; k++) {
+                                remain_str += "0";
+                            }
+                            ret.add(remain_str);
+                        }else {
+                            ret.add(str.substring(j,j+8));
+                        }
+                    }
+                }
+
+            }
+            Collections.sort(ret);
+            ret.stream().forEach(System.out::println);
+        }
+    }
+
+}

src/stringAndChar/MutationString.java

@@ -0,0 +1,51 @@
+package stringAndChar;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class MutationString {
+    private ArrayList<String> ret = new ArrayList<>();
+
+    public ArrayList<String> Permutation(String str) {
+        if (str.length() == 0)
+            return ret;
+        char[] s = str.toCharArray();
+        rank(s, 0);
+        Collections.sort(ret);
+        return ret;
+    }
+
+    private void rank(char[] s, int start) {
+        if (start == s.length) {
+            ret.add(new String(s));
+        }else {
+            for (int i = start; i < s.length; i++) {
+                if (i == start)
+                    rank(s, start+1);
+                if (s[i] != s[start]){
+                    char[] temp = swap(s, start, i);
+                    rank(temp, start+1);
+                }
+            }
+        }
+    }
+
+    private char[] swap(char[] s, int start, int i) {
+        char[] v = s.clone();
+        char temp = v[start];
+        v[start] = v[i];
+        v[i] = temp;
+        return v;
+    }
+
+
+    public static void main(String[] args) {
+//        ArrayList<String> result = new MutationString().Permutation("aabc");
+//        System.out.println(result);
+        // [aabc, aacb, abac, abca, acab, acba, baac, baca, bcaa, caab, caba, cbaa]
+        ArrayList<String> result;
+        result = new MutationString().Permutation("abc");
+        System.out.println(result); // [aab, aba, baa]
+    }
+
+}

src/stringAndChar/StringConcat.java

@@ -0,0 +1,55 @@
+package stringAndChar;
+
+import java.util.*;
+
+public class StringConcat {
+
+    public static void main(String[] args) {
+        HashMap<Character, Character> map = new HashMap<>();
+        map.put('(',')');
+        map.put('{','}');
+        map.put('[',']');
+
+        Scanner scanner = new Scanner(System.in);
+        String inp = scanner.next();
+        String ret = openStr(inp, map);
+        System.out.println(ret);
+    }
+
+    private static String openStr(String inp, HashMap map) {
+        String ret = "";
+        int repNumber = 0;
+        int i = 0;
+        while (i < inp.length()) {
+            Character temp = inp.charAt(i++);
+            if (!Character.isDigit(temp)){
+                ret += temp;
+            }else {
+                repNumber = temp - '0';
+                Character right = (Character) map.get(inp.charAt(i));
+                String rep = "";
+                Stack<Character> stack = new Stack<>();
+                for (int j = i+1; j < inp.length(); j++) {
+
+                    Character c = inp.charAt(j);
+                    if (map.containsKey(c)){
+                        stack.push(c);
+
+                    }else if (!stack.empty() && c == map.get(stack.peek())){
+                        stack.pop();
+                    }else if (inp.charAt(j) == right && stack.empty()) {
+                        rep = openStr(inp.substring(i+1, j), map);
+                        i = j + 1;
+                    }
+                }
+                for (int j = 0; j < repNumber; j++) {
+                    ret += rep;
+                }
+                ;
+            }
+
+        }
+        return ret;
+    }
+
+}

src/tree/FindAllPath.java

@@ -0,0 +1,27 @@
+package tree;
+
+import java.util.ArrayList;
+
+public class FindAllPath {
+
+    private ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
+
+    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root, int target) {
+
+        backtracking(root, target, new ArrayList<>());
+        return ret;
+    }
+
+    private void backtracking(TreeNode node, int target, ArrayList<Integer> path) {
+        if (node == null) return;
+        path.add(node.val);
+        target -= node.val;
+        if (target == 0 && node.left == null && node.right == null) {
+            ret.add(new ArrayList<>(path));
+        }else {
+            backtracking(node.left, target , path);
+            backtracking(node.right, target , path);
+        }
+        path.remove(path.size() - 1);
+    }
+}

src/tree/RebuildByInOrderAndPostOrder.java

@@ -27,7 +27,7 @@ private TreeNode reBuild(int[] postOrder, int postL, int postR, int inL){
 
     private void printNode(TreeNode root){
         if (root != null){
-            System.out.println(root.value);
+            System.out.println(root.val);
             printNode(root.left);
             printNode(root.right);
         }

src/tree/RebuildTree.java

@@ -31,7 +31,7 @@ private TreeNode reBuild(int[] pre, int preL, int preR, int inL){
 
     private void printNode(TreeNode root){
         if (root != null){
-            System.out.println(root.value);
+            System.out.println(root.val);
             printNode(root.left);
             printNode(root.right);
         }

src/tree/TreeNode.java

@@ -1,12 +1,12 @@
 package tree;
 
 public class TreeNode {
-    final int value;
+    final int val;
     TreeNode left;
     TreeNode right;
 
     public TreeNode(int value) {
-        this.value = value;
+        this.val = value;
         this.left = null;
         this.right = null;
     }