Skip to content

Commit a7dfa7e

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.0041
No.0041.First Missing Positive
1 parent 0bdd794 commit a7dfa7e

File tree

6 files changed

+376
-4
lines changed

6 files changed

+376
-4
lines changed

Diff for: ‎solution/0000-0099/0041.First Missing Positive/README.md

+170-1
Original file line numberDiff line numberDiff line change
@@ -52,15 +52,184 @@
5252
<!-- 这里可写当前语言的特殊实现逻辑 -->
5353

5454
```python
55-
55+
class Solution:
56+
def firstMissingPositive(self, nums):
57+
"""
58+
:type nums: List[int]
59+
:rtype: int
60+
"""
61+
62+
i = 1
63+
while i in nums:
64+
i += 1
65+
return i
5666
```
5767

5868
### **Java**
5969

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

6272
```java
73+
public class Solution {
74+
public int firstMissingPositive(int[] num) {
75+
for (int i = 0; i < num.length; i++) {
76+
if (num[i] > 0 && num[i] < num.length && num[num[i] - 1] != num[i]) {
77+
swap(num, i, num[i] - 1);
78+
i--;
79+
}
80+
}
81+
82+
for (int i = 0; i < num.length; i++) {
83+
if (i + 1 != num[i]) {
84+
return i + 1;
85+
}
86+
}
87+
88+
return num.length + 1;
89+
}
90+
91+
private void swap(int[] num, int i, int j) {
92+
int temp = num[i];
93+
num[i] = num[j];
94+
num[j] = temp;
95+
}
96+
}
97+
```
98+
99+
### **C++**
100+
101+
```cpp
102+
class Solution {
103+
public:
104+
int firstMissingPositive(vector<int>& nums) {
105+
sort(nums.begin(),nums.end());
106+
int len = nums.size();
107+
if(len == 0)return 1;
108+
int i = 0;
109+
while(nums[i] <= 0 && i < len)i++;
110+
if(i == len)return 1;
111+
112+
int tmp = 1;
113+
while(i<len){
114+
if(nums[i] != tmp)return tmp;
115+
while(len>i+1 && nums[i] == nums[i+1])i++;//去重
116+
i++;
117+
tmp++;
118+
}
119+
return tmp;
120+
}
121+
};
122+
```
123+
124+
### **C**
125+
126+
```c
127+
int firstMissingPositive(int* nums, int numsSize) {
128+
129+
int Max = nums[0], i, *Count;
130+
131+
for(i = 1; i<numsSize; i++){
132+
Max = (Max < nums[i]) ? nums[i] : Max;
133+
}
134+
135+
Count = (int*)calloc(Max+1, sizeof(int));
136+
for(i = 0; i<numsSize; i++){
137+
if(nums[i] > 0){
138+
Count[nums[i]]++;
139+
}
140+
}
141+
142+
i = 1;
143+
while(Count[i] != 0){
144+
i++;
145+
}
146+
147+
return i;
148+
}
149+
```
150+
151+
### **C#**
152+
153+
```cs
154+
public class Solution {
155+
public int FirstMissingPositive(int[] nums) {
156+
var i = 0;
157+
while (i < nums.Length)
158+
{
159+
if (nums[i] > 0 && nums[i] <= nums.Length)
160+
{
161+
var index = nums[i] -1;
162+
if (index != i && nums[index] != nums[i])
163+
{
164+
var temp = nums[i];
165+
nums[i] = nums[index];
166+
nums[index] = temp;
167+
}
168+
else
169+
{
170+
++i;
171+
}
172+
}
173+
else
174+
{
175+
++i;
176+
}
177+
}
178+
179+
for (i = 0; i < nums.Length; ++i)
180+
{
181+
if (nums[i] != i + 1)
182+
{
183+
return i + 1;
184+
}
185+
}
186+
return nums.Length + 1;
187+
}
188+
}
189+
```
190+
191+
### **TypeScript**
192+
193+
```ts
194+
function firstMissingPositive(nums: number[]): number {
195+
const n = nums.length;
196+
let i = 0;
197+
while (i < n) {
198+
const j = nums[i] - 1;
199+
if (j === i || j < 0 || j >= n || nums[i] === nums[j]) {
200+
i++;
201+
} else {
202+
[nums[i], nums[j]] = [nums[j], nums[i]];
203+
}
204+
}
205+
206+
const res = nums.findIndex((v, i) => v !== i + 1);
207+
return (res === -1 ? n : res) + 1;
208+
}
209+
```
63210

211+
### **Rust**
212+
213+
```rust
214+
impl Solution {
215+
pub fn first_missing_positive(mut nums: Vec<i32>) -> i32 {
216+
let n = nums.len();
217+
let mut i = 0;
218+
while i < n {
219+
let j = nums[i] - 1;
220+
if i as i32 == j || j < 0 || j >= n as i32 || nums[i] == nums[j as usize] {
221+
i += 1;
222+
} else {
223+
nums.swap(i, j as usize);
224+
}
225+
}
226+
nums.iter()
227+
.enumerate()
228+
.position(|(i, &v)| v as usize != i + 1)
229+
.unwrap_or(n) as i32
230+
+ 1
231+
}
232+
}
64233
```
65234

66235
### **...**

Diff for: ‎solution/0000-0099/0041.First Missing Positive/README_EN.md

+170-1
Original file line numberDiff line numberDiff line change
@@ -34,13 +34,182 @@
3434
### **Python3**
3535

3636
```python
37-
37+
class Solution:
38+
def firstMissingPositive(self, nums):
39+
"""
40+
:type nums: List[int]
41+
:rtype: int
42+
"""
43+
44+
i = 1
45+
while i in nums:
46+
i += 1
47+
return i
3848
```
3949

4050
### **Java**
4151

4252
```java
53+
public class Solution {
54+
public int firstMissingPositive(int[] num) {
55+
for (int i = 0; i < num.length; i++) {
56+
if (num[i] > 0 && num[i] < num.length && num[num[i] - 1] != num[i]) {
57+
swap(num, i, num[i] - 1);
58+
i--;
59+
}
60+
}
61+
62+
for (int i = 0; i < num.length; i++) {
63+
if (i + 1 != num[i]) {
64+
return i + 1;
65+
}
66+
}
67+
68+
return num.length + 1;
69+
}
70+
71+
private void swap(int[] num, int i, int j) {
72+
int temp = num[i];
73+
num[i] = num[j];
74+
num[j] = temp;
75+
}
76+
}
77+
```
78+
79+
### **C++**
80+
81+
```cpp
82+
class Solution {
83+
public:
84+
int firstMissingPositive(vector<int>& nums) {
85+
sort(nums.begin(),nums.end());
86+
int len = nums.size();
87+
if(len == 0)return 1;
88+
int i = 0;
89+
while(nums[i] <= 0 && i < len)i++;
90+
if(i == len)return 1;
91+
92+
int tmp = 1;
93+
while(i<len){
94+
if(nums[i] != tmp)return tmp;
95+
while(len>i+1 && nums[i] == nums[i+1])i++;//去重
96+
i++;
97+
tmp++;
98+
}
99+
return tmp;
100+
}
101+
};
102+
```
103+
104+
### **C**
105+
106+
```c
107+
int firstMissingPositive(int* nums, int numsSize) {
108+
109+
int Max = nums[0], i, *Count;
110+
111+
for(i = 1; i<numsSize; i++){
112+
Max = (Max < nums[i]) ? nums[i] : Max;
113+
}
114+
115+
Count = (int*)calloc(Max+1, sizeof(int));
116+
for(i = 0; i<numsSize; i++){
117+
if(nums[i] > 0){
118+
Count[nums[i]]++;
119+
}
120+
}
121+
122+
i = 1;
123+
while(Count[i] != 0){
124+
i++;
125+
}
126+
127+
return i;
128+
}
129+
```
130+
131+
### **C#**
132+
133+
```cs
134+
public class Solution {
135+
public int FirstMissingPositive(int[] nums) {
136+
var i = 0;
137+
while (i < nums.Length)
138+
{
139+
if (nums[i] > 0 && nums[i] <= nums.Length)
140+
{
141+
var index = nums[i] -1;
142+
if (index != i && nums[index] != nums[i])
143+
{
144+
var temp = nums[i];
145+
nums[i] = nums[index];
146+
nums[index] = temp;
147+
}
148+
else
149+
{
150+
++i;
151+
}
152+
}
153+
else
154+
{
155+
++i;
156+
}
157+
}
158+
159+
for (i = 0; i < nums.Length; ++i)
160+
{
161+
if (nums[i] != i + 1)
162+
{
163+
return i + 1;
164+
}
165+
}
166+
return nums.Length + 1;
167+
}
168+
}
169+
```
170+
171+
### **TypeScript**
172+
173+
```ts
174+
function firstMissingPositive(nums: number[]): number {
175+
const n = nums.length;
176+
let i = 0;
177+
while (i < n) {
178+
const j = nums[i] - 1;
179+
if (j === i || j < 0 || j >= n || nums[i] === nums[j]) {
180+
i++;
181+
} else {
182+
[nums[i], nums[j]] = [nums[j], nums[i]];
183+
}
184+
}
185+
186+
const res = nums.findIndex((v, i) => v !== i + 1);
187+
return (res === -1 ? n : res) + 1;
188+
}
189+
```
43190

191+
### **Rust**
192+
193+
```rust
194+
impl Solution {
195+
pub fn first_missing_positive(mut nums: Vec<i32>) -> i32 {
196+
let n = nums.len();
197+
let mut i = 0;
198+
while i < n {
199+
let j = nums[i] - 1;
200+
if i as i32 == j || j < 0 || j >= n as i32 || nums[i] == nums[j as usize] {
201+
i += 1;
202+
} else {
203+
nums.swap(i, j as usize);
204+
}
205+
}
206+
nums.iter()
207+
.enumerate()
208+
.position(|(i, &v)| v as usize != i + 1)
209+
.unwrap_or(n) as i32
210+
+ 1
211+
}
212+
}
44213
```
45214

46215
### **...**

Diff for: ‎solution/0000-0099/0041.First Missing Positive/Solution.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ class Solution {
77
int i = 0;
88
while(nums[i] <= 0 && i < len)i++;
99
if(i == len)return 1;
10-
10+
1111
int tmp = 1;
1212
while(i<len){
1313
if(nums[i] != tmp)return tmp;

Diff for: ‎solution/0000-0099/0041.First Missing Positive/Solution.java

+1-1
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ public int firstMissingPositive(int[] num) {
1212
return i + 1;
1313
}
1414
}
15-
15+
1616
return num.length + 1;
1717
}
1818

0 commit comments

Comments
 (0)