Skip to content

Commit 434b9f7

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems: No.1913,1914
1 parent c0c788b commit 434b9f7

File tree

8 files changed

+294
-8
lines changed

8 files changed

+294
-8
lines changed

‎solution/1900-1999/1913.Maximum Product Difference Between Two Pairs/README.md

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -55,15 +55,24 @@
5555
<!-- 这里可写当前语言的特殊实现逻辑 -->
5656

5757
```python
58-
58+
class Solution:
59+
def maxProductDifference(self, nums: List[int]) -> int:
60+
nums.sort()
61+
return nums[-1] * nums[-2] - nums[0] * nums[1]
5962
```
6063

6164
### **Java**
6265

6366
<!-- 这里可写当前语言的特殊实现逻辑 -->
6467

6568
```java
66-
69+
class Solution {
70+
public int maxProductDifference(int[] nums) {
71+
Arrays.sort(nums);
72+
int n = nums.length;
73+
return nums[n - 1] * nums[n - 2] - nums[0] * nums[1];
74+
}
75+
}
6776
```
6877

6978
### **...**

‎solution/1900-1999/1913.Maximum Product Difference Between Two Pairs/README_EN.md

Lines changed: 11 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -78,13 +78,22 @@ The product difference is (9 * 8) - (2 * 4) = 64.
7878
### **Python3**
7979

8080
```python
81-
81+
class Solution:
82+
def maxProductDifference(self, nums: List[int]) -> int:
83+
nums.sort()
84+
return nums[-1] * nums[-2] - nums[0] * nums[1]
8285
```
8386

8487
### **Java**
8588

8689
```java
87-
90+
class Solution {
91+
public int maxProductDifference(int[] nums) {
92+
Arrays.sort(nums);
93+
int n = nums.length;
94+
return nums[n - 1] * nums[n - 2] - nums[0] * nums[1];
95+
}
96+
}
8897
```
8998

9099
### **...**

‎solution/1900-1999/1913.Maximum Product Difference Between Two Pairs/Solution.java

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,7 @@
1+
class Solution {
2+
public int maxProductDifference(int[] nums) {
3+
Arrays.sort(nums);
4+
int n = nums.length;
5+
return nums[n - 1] * nums[n - 2] - nums[0] * nums[1];
6+
}
7+
}

‎solution/1900-1999/1913.Maximum Product Difference Between Two Pairs/Solution.py

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,4 @@
1+
class Solution:
2+
def maxProductDifference(self, nums: List[int]) -> int:
3+
nums.sort()
4+
return nums[-1] * nums[-2] - nums[0] * nums[1]

‎solution/1900-1999/1914.Cyclically Rotating a Grid/README.md

Lines changed: 87 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -57,15 +57,100 @@
5757
<!-- 这里可写当前语言的特殊实现逻辑 -->
5858

5959
```python
60-
60+
class Solution:
61+
def rotateGrid(self, grid: List[List[int]], k: int) -> List[List[int]]:
62+
def rotate(grid, s1, e1, s2, e2, k):
63+
t = []
64+
for j in range(e2, e1, -1):
65+
t.append(grid[s1][j])
66+
for i in range(s1, s2):
67+
t.append(grid[i][e1])
68+
for j in range(e1, e2):
69+
t.append(grid[s2][j])
70+
for i in range(s2, s1, -1):
71+
t.append(grid[i][e2])
72+
k %= len(t)
73+
t = t[-k:] +t[:-k]
74+
k = 0
75+
for j in range(e2, e1, -1):
76+
grid[s1][j] = t[k]
77+
k += 1
78+
for i in range(s1, s2):
79+
grid[i][e1] = t[k]
80+
k += 1
81+
for j in range(e1, e2):
82+
grid[s2][j] = t[k]
83+
k += 1
84+
for i in range(s2, s1, -1):
85+
grid[i][e2] = t[k]
86+
k += 1
87+
88+
m, n = len(grid), len(grid[0])
89+
s1 = e1 = 0
90+
s2, e2 = m - 1, n - 1
91+
while s1 <= s2 and e1 <= e2:
92+
rotate(grid, s1, e1, s2, e2, k)
93+
s1 += 1
94+
e1 += 1
95+
s2 -= 1
96+
e2 -= 1
97+
return grid
6198
```
6299

63100
### **Java**
64101

65102
<!-- 这里可写当前语言的特殊实现逻辑 -->
66103

67104
```java
68-
105+
class Solution {
106+
public int[][] rotateGrid(int[][] grid, int k) {
107+
int m = grid.length, n = grid[0].length;
108+
int s1 = 0, e1 = 0;
109+
int s2 = m - 1, e2 = n - 1;
110+
while (s1 <= s2 && e1 <= e2) {
111+
rotate(grid, s1++, e1++, s2--, e2--, k);
112+
}
113+
return grid;
114+
}
115+
116+
private void rotate(int[][] grid, int s1, int e1, int s2, int e2, int k) {
117+
List<Integer> t = new ArrayList<>();
118+
for (int j = e2; j > e1; --j) {
119+
t.add(grid[s1][j]);
120+
}
121+
for (int i = s1; i < s2; ++i) {
122+
t.add(grid[i][e1]);
123+
}
124+
for (int j = e1; j < e2; ++j) {
125+
t.add(grid[s2][j]);
126+
}
127+
for (int i = s2; i > s1; --i) {
128+
t.add(grid[i][e2]);
129+
}
130+
int n = t.size();
131+
k %= n;
132+
if (k == 0) {
133+
return;
134+
}
135+
k = n - k;
136+
for (int j = e2; j > e1; --j) {
137+
grid[s1][j] = t.get(k);
138+
k = (k + 1) % n;
139+
}
140+
for (int i = s1; i < s2; ++i) {
141+
grid[i][e1] = t.get(k);
142+
k = (k + 1) % n;
143+
}
144+
for (int j = e1; j < e2; ++j) {
145+
grid[s2][j] = t.get(k);
146+
k = (k + 1) % n;
147+
}
148+
for (int i = s2; i > s1; --i) {
149+
grid[i][e2] = t.get(k);
150+
k = (k + 1) % n;
151+
}
152+
}
153+
}
69154
```
70155

71156
### **...**

‎solution/1900-1999/1914.Cyclically Rotating a Grid/README_EN.md

Lines changed: 87 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -52,13 +52,98 @@
5252
### **Python3**
5353

5454
```python
55-
55+
class Solution:
56+
def rotateGrid(self, grid: List[List[int]], k: int) -> List[List[int]]:
57+
def rotate(grid, s1, e1, s2, e2, k):
58+
t = []
59+
for j in range(e2, e1, -1):
60+
t.append(grid[s1][j])
61+
for i in range(s1, s2):
62+
t.append(grid[i][e1])
63+
for j in range(e1, e2):
64+
t.append(grid[s2][j])
65+
for i in range(s2, s1, -1):
66+
t.append(grid[i][e2])
67+
k %= len(t)
68+
t = t[-k:] +t[:-k]
69+
k = 0
70+
for j in range(e2, e1, -1):
71+
grid[s1][j] = t[k]
72+
k += 1
73+
for i in range(s1, s2):
74+
grid[i][e1] = t[k]
75+
k += 1
76+
for j in range(e1, e2):
77+
grid[s2][j] = t[k]
78+
k += 1
79+
for i in range(s2, s1, -1):
80+
grid[i][e2] = t[k]
81+
k += 1
82+
83+
m, n = len(grid), len(grid[0])
84+
s1 = e1 = 0
85+
s2, e2 = m - 1, n - 1
86+
while s1 <= s2 and e1 <= e2:
87+
rotate(grid, s1, e1, s2, e2, k)
88+
s1 += 1
89+
e1 += 1
90+
s2 -= 1
91+
e2 -= 1
92+
return grid
5693
```
5794

5895
### **Java**
5996

6097
```java
61-
98+
class Solution {
99+
public int[][] rotateGrid(int[][] grid, int k) {
100+
int m = grid.length, n = grid[0].length;
101+
int s1 = 0, e1 = 0;
102+
int s2 = m - 1, e2 = n - 1;
103+
while (s1 <= s2 && e1 <= e2) {
104+
rotate(grid, s1++, e1++, s2--, e2--, k);
105+
}
106+
return grid;
107+
}
108+
109+
private void rotate(int[][] grid, int s1, int e1, int s2, int e2, int k) {
110+
List<Integer> t = new ArrayList<>();
111+
for (int j = e2; j > e1; --j) {
112+
t.add(grid[s1][j]);
113+
}
114+
for (int i = s1; i < s2; ++i) {
115+
t.add(grid[i][e1]);
116+
}
117+
for (int j = e1; j < e2; ++j) {
118+
t.add(grid[s2][j]);
119+
}
120+
for (int i = s2; i > s1; --i) {
121+
t.add(grid[i][e2]);
122+
}
123+
int n = t.size();
124+
k %= n;
125+
if (k == 0) {
126+
return;
127+
}
128+
k = n - k;
129+
for (int j = e2; j > e1; --j) {
130+
grid[s1][j] = t.get(k);
131+
k = (k + 1) % n;
132+
}
133+
for (int i = s1; i < s2; ++i) {
134+
grid[i][e1] = t.get(k);
135+
k = (k + 1) % n;
136+
}
137+
for (int j = e1; j < e2; ++j) {
138+
grid[s2][j] = t.get(k);
139+
k = (k + 1) % n;
140+
}
141+
for (int i = s2; i > s1; --i) {
142+
grid[i][e2] = t.get(k);
143+
k = (k + 1) % n;
144+
}
145+
}
146+
}
62147
```
63148

64149
### **...**

‎solution/1900-1999/1914.Cyclically Rotating a Grid/Solution.java

Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
class Solution {
2+
public int[][] rotateGrid(int[][] grid, int k) {
3+
int m = grid.length, n = grid[0].length;
4+
int s1 = 0, e1 = 0;
5+
int s2 = m - 1, e2 = n - 1;
6+
while (s1 <= s2 && e1 <= e2) {
7+
rotate(grid, s1++, e1++, s2--, e2--, k);
8+
}
9+
return grid;
10+
}
11+
12+
private void rotate(int[][] grid, int s1, int e1, int s2, int e2, int k) {
13+
List<Integer> t = new ArrayList<>();
14+
for (int j = e2; j > e1; --j) {
15+
t.add(grid[s1][j]);
16+
}
17+
for (int i = s1; i < s2; ++i) {
18+
t.add(grid[i][e1]);
19+
}
20+
for (int j = e1; j < e2; ++j) {
21+
t.add(grid[s2][j]);
22+
}
23+
for (int i = s2; i > s1; --i) {
24+
t.add(grid[i][e2]);
25+
}
26+
int n = t.size();
27+
k %= n;
28+
if (k == 0) {
29+
return;
30+
}
31+
k = n - k;
32+
for (int j = e2; j > e1; --j) {
33+
grid[s1][j] = t.get(k);
34+
k = (k + 1) % n;
35+
}
36+
for (int i = s1; i < s2; ++i) {
37+
grid[i][e1] = t.get(k);
38+
k = (k + 1) % n;
39+
}
40+
for (int j = e1; j < e2; ++j) {
41+
grid[s2][j] = t.get(k);
42+
k = (k + 1) % n;
43+
}
44+
for (int i = s2; i > s1; --i) {
45+
grid[i][e2] = t.get(k);
46+
k = (k + 1) % n;
47+
}
48+
}
49+
}

‎solution/1900-1999/1914.Cyclically Rotating a Grid/Solution.py

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
class Solution:
2+
def rotateGrid(self, grid: List[List[int]], k: int) -> List[List[int]]:
3+
def rotate(grid, s1, e1, s2, e2, k):
4+
t = []
5+
for j in range(e2, e1, -1):
6+
t.append(grid[s1][j])
7+
for i in range(s1, s2):
8+
t.append(grid[i][e1])
9+
for j in range(e1, e2):
10+
t.append(grid[s2][j])
11+
for i in range(s2, s1, -1):
12+
t.append(grid[i][e2])
13+
k %= len(t)
14+
t = t[-k:] +t[:-k]
15+
k = 0
16+
for j in range(e2, e1, -1):
17+
grid[s1][j] = t[k]
18+
k += 1
19+
for i in range(s1, s2):
20+
grid[i][e1] = t[k]
21+
k += 1
22+
for j in range(e1, e2):
23+
grid[s2][j] = t[k]
24+
k += 1
25+
for i in range(s2, s1, -1):
26+
grid[i][e2] = t[k]
27+
k += 1
28+
29+
m, n = len(grid), len(grid[0])
30+
s1 = e1 = 0
31+
s2, e2 = m - 1, n - 1
32+
while s1 <= s2 and e1 <= e2:
33+
rotate(grid, s1, e1, s2, e2, k)
34+
s1 += 1
35+
e1 += 1
36+
s2 -= 1
37+
e2 -= 1
38+
return grid

0 commit comments

Comments
 (0)