Skip to content

Commit c475a62

Browse files
SeanforfunSeanforfun
committed
[Function add]
1. Add leetcode solutions.
1 parent 8f0f41b commit c475a62

7 files changed

+211
-5
lines changed

‎leetcode/22. Generate Parentheses.md‎

Lines changed: 22 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -106,4 +106,25 @@ class Solution {
106106
}
107107
}
108108
}
109-
```
109+
```
110+
111+
### Fourth time
112+
* Method 1: recursion
113+
```Java
114+
class Solution {
115+
private List<String> result;
116+
public List<String> generateParenthesis(int n) {
117+
this.result = new ArrayList<>();
118+
if(n <= 0) return result;
119+
dfs("", n, n);
120+
return result;
121+
}
122+
private void dfs(String cur, int left, int right){
123+
if(left == 0 && right == 0) result.add(new String(cur));
124+
else{
125+
if(left > 0) dfs(cur + "(", left - 1, right);
126+
if(right > left) dfs(cur + ")", left, right - 1);
127+
}
128+
}
129+
}
130+
```

‎leetcode/268. Missing Number.md‎

Lines changed: 23 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -39,7 +39,7 @@ class Solution {
3939
}
4040
```
4141

42-
###Second time
42+
### Second time
4343
1. We first get the sum of the array and the missing value is the deduction between expect sum and sum.
4444
```Java
4545
class Solution {
@@ -52,4 +52,25 @@ class Solution {
5252
return expect - sum;
5353
}
5454
}
55-
```
55+
```
56+
57+
### Third Time
58+
* Method 1: Another method to find missing number in a sorted array.
59+
```Java
60+
class Solution {
61+
public int missingNumber(int[] nums) {
62+
Arrays.sort(nums);
63+
int low = 0, high = nums.length - 1;
64+
return binarySearch(nums, low, high);
65+
}
66+
private int binarySearch(int[] nums, int low, int high){
67+
int mid = low + (high - low) / 2;
68+
if(nums[mid] == mid && nums[mid + 1] != mid + 1) return mid + 1;
69+
else if(nums[mid] != mid){
70+
return binarySearch(nums, low, mid - 1);
71+
}else{
72+
return binarySearch(nums, mid + 1, high);
73+
}
74+
}
75+
}
76+
```

‎leetcode/273. Integer to English Words.md‎

Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -117,4 +117,59 @@ Output: "One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Th
117117
return result;
118118
}
119119
}
120+
```
121+
122+
### Third Time
123+
* Method 1: String
124+
```Java
125+
class Solution {
126+
private static final String[] units = new String[]{"", "Thousand", "Million", "Billion"};
127+
private static final String[] ones = new String[]{"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine"};
128+
private static String[] tens = new String[]{"", "Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};
129+
private static String[] overTens = new String[]{"", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
130+
public String numberToWords(int num) {
131+
if(num == 0) return "Zero";
132+
String res = "";
133+
int bigUnitIndex = 0;
134+
while(num > 0){
135+
int cur = num % 1000;
136+
String curString = parse(cur);
137+
num /= 1000;
138+
if(bigUnitIndex == 0){
139+
res = curString;
140+
++bigUnitIndex;
141+
continue;
142+
}
143+
if(curString.length() != 0){
144+
res = curString + " " + units[bigUnitIndex] + (res.length() == 0 ? "": " ") + res;
145+
}
146+
bigUnitIndex++;
147+
}
148+
return res;
149+
}
150+
private String parse(int num){
151+
if(num < 10) return ones[num];
152+
else if(num > 10 && num < 20) return overTens[num - 10];
153+
else{
154+
String res = "";
155+
if(num % 100 > 10 && num % 100 < 20){
156+
res = overTens[num % 100 - 10];
157+
num /= 100;
158+
}else{
159+
if(num % 10 != 0){
160+
res = ones[num % 10];
161+
}
162+
num /= 10;
163+
if(num % 10 != 0){
164+
res = tens[num % 10] + (res.length() == 0 ? "": " " + res);
165+
}
166+
num /= 10;
167+
}
168+
if(num % 10 != 0){
169+
res = ones[num % 10] + " Hundred" + (res.length() == 0 ? "": " ") + res;
170+
}
171+
return res;
172+
}
173+
}
174+
}
120175
```

‎leetcode/344. Reverse String.md‎

Lines changed: 19 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -55,4 +55,22 @@ class Solution {
5555
arr[j] = temp;
5656
}
5757
}
58-
```
58+
```
59+
60+
### Second Time
61+
* Method 1: in-place, 2 pointers
62+
```Java
63+
class Solution {
64+
public void reverseString(char[] s) {
65+
int low = 0, high = s.length - 1;
66+
while(low < high){
67+
swap(s, low++, high--);
68+
}
69+
}
70+
private void swap(char[] s, int a, int b){
71+
char temp = s[a];
72+
s[a] = s[b];
73+
s[b] = temp;
74+
}
75+
}
76+
```

‎leetcode/93. Restore IP Addresses.md‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,3 +40,31 @@ Output: ["255.255.11.135", "255.255.111.35"]
4040
}
4141
}
4242
```
43+
44+
### Amazon Session
45+
* Method 1: recursion
46+
```Java
47+
class Solution {
48+
private List<String> result;
49+
private String s;
50+
public List<String> restoreIpAddresses(String s) {
51+
this.result = new ArrayList<>();
52+
this.s = s;
53+
dfs(0, 0, "");
54+
return this.result;
55+
}
56+
private void dfs(int index, int count, String temp){
57+
if(index == s.length() && count == 4) this.result.add(temp);
58+
else if(count < 4){
59+
for(int i = index + 1; i <= index + 3 && i <= s.length(); i++){
60+
String sub = s.substring(index, i);
61+
int cur = Integer.parseInt(sub);
62+
if(sub.charAt(0) == '0' && sub.length() != 1) return;
63+
if(cur >= 0 && cur <= 255){
64+
dfs(i, count + 1, temp + (temp.length() == 0 ? "": '.') + cur);
65+
}
66+
}
67+
}
68+
}
69+
}
70+
```

‎leetcode/94. Binary Tree Inorder Traversal.md‎

Lines changed: 29 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -28,4 +28,32 @@ class Solution {
2828
inorder(n.right, result);
2929
}
3030
}
31-
```
31+
```
32+
33+
### Second time
34+
* Method 1: Recursion
35+
```Java
36+
/**
37+
* Definition for a binary tree node.
38+
* public class TreeNode {
39+
* int val;
40+
* TreeNode left;
41+
* TreeNode right;
42+
* TreeNode(int x) { val = x; }
43+
* }
44+
*/
45+
class Solution {
46+
private List<Integer> result;
47+
public List<Integer> inorderTraversal(TreeNode root) {
48+
this.result = new ArrayList<>();
49+
dfs(root);
50+
return this.result;
51+
}
52+
private void dfs(TreeNode node){
53+
if(node == null) return;
54+
dfs(node.left);
55+
this.result.add(node.val);
56+
dfs(node.right);
57+
}
58+
}
59+
```

‎leetcode/97. Interleaving String.md‎

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -79,3 +79,38 @@ class Solution {
7979
}
8080
}
8181
```
82+
83+
### Third time
84+
* Method 1: dp
85+
```Java
86+
class Solution {
87+
public boolean isInterleave(String s1, String s2, String s3) {
88+
char[] arr1 = s1.toCharArray();
89+
char[] arr2 = s2.toCharArray();
90+
char[] arr3 = s3.toCharArray();
91+
if(arr1.length + arr2.length != arr3.length) return false;
92+
boolean[][] dp = new boolean[arr1.length + 1][arr2.length + 1];
93+
dp[0][0] = true;
94+
for(int i = 0; i < arr1.length; i++){
95+
if(arr1[i] == arr3[i])
96+
dp[i + 1][0] = dp[i][0];
97+
}
98+
for(int i = 0; i < arr2.length; i++){
99+
if(arr2[i] == arr3[i])
100+
dp[0][i + 1] = dp[0][i];
101+
}
102+
for(int i = 1; i <= arr1.length; i++){
103+
for(int j = 1; j <= arr2.length; j++){
104+
// dp[i][j] saves if i + j - 1 can be constructed by i && j
105+
if(arr3[i + j - 1] == arr1[i - 1]){
106+
dp[i][j] = dp[i - 1][j];
107+
}
108+
if(arr3[i + j - 1] == arr2[j - 1]){
109+
dp[i][j] |= dp[i][j - 1];
110+
}
111+
}
112+
}
113+
return dp[arr1.length][arr2.length];
114+
}
115+
}
116+
```

0 commit comments

Comments
 (0)