Skip to content

Commit 7276c22

Browse files
Nothing-avilNothing-avil
authored
feat: add solutions to lc problem: No.3029 (#2316)
1 parent 1ea50e0 commit 7276c22

File tree

7 files changed

+301
-4
lines changed

7 files changed

+301
-4
lines changed

‎solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README.md

+101-2
Original file line numberDiff line numberDiff line change
@@ -70,19 +70,118 @@
7070
<!-- tabs:start -->
7171

7272
```python
73+
class Solution:
74+
def minimumTimeToInitialState(self, word: str, k: int) -> int:
75+
n = len(word)
76+
for i in range(1, 10001):
77+
re = i * k
78+
if re >= n:
79+
return i
80+
if word[re:] == word[:n - re]:
81+
return i
82+
return 0
7383

7484
```
7585

7686
```java
77-
87+
class Solution {
88+
public int minimumTimeToInitialState(String word, int k) {
89+
int n = word.length();
90+
for (int i = 1; i <= 10000; i++) {
91+
int re = i * k;
92+
if (re >= n) {
93+
return i;
94+
}
95+
String str = word.substring(re);
96+
boolean flag = true;
97+
for (int j = 0; j < str.length(); j++) {
98+
if (str.charAt(j) != word.charAt(j)) {
99+
flag = false;
100+
break;
101+
}
102+
}
103+
if (flag) {
104+
return i;
105+
}
106+
}
107+
return 0;
108+
}
109+
}
78110
```
79111

80112
```cpp
81-
113+
class Solution {
114+
public:
115+
int minimumTimeToInitialState(string word, int k) {
116+
int n = word.length();
117+
for (int i = 1; i <= 10000; i++) {
118+
int re = i * k;
119+
if (re >= n) {
120+
return i;
121+
}
122+
string str = word.substr(re);
123+
bool flag = true;
124+
for (int j = 0; j < str.length(); j++) {
125+
if (str[j] != word[j]) {
126+
flag = false;
127+
break;
128+
}
129+
}
130+
if (flag) {
131+
return i;
132+
}
133+
}
134+
return 0;
135+
}
136+
};
82137
```
83138
84139
```go
140+
func minimumTimeToInitialState(word string, k int) int {
141+
n := len(word)
142+
for i := 1; i <= 10000; i++ {
143+
re := i * k
144+
if re >= n {
145+
return i
146+
}
147+
str := word[re:]
148+
flag := true
149+
for j := 0; j < len(str); j++ {
150+
if str[j] != word[j] {
151+
flag = false
152+
break
153+
}
154+
}
155+
if flag {
156+
return i
157+
}
158+
}
159+
return 0
160+
}
161+
```
85162

163+
```ts
164+
function minimumTimeToInitialState(word: string, k: number): number {
165+
const n = word.length;
166+
for (let i = 1; i <= 10000; i++) {
167+
const re = i * k;
168+
if (re >= n) {
169+
return i;
170+
}
171+
const str = word.substring(re);
172+
let flag = true;
173+
for (let j = 0; j < str.length; j++) {
174+
if (str[j] !== word[j]) {
175+
flag = false;
176+
break;
177+
}
178+
}
179+
if (flag) {
180+
return i;
181+
}
182+
}
183+
return 0;
184+
}
86185
```
87186

88187
<!-- tabs:end -->

‎solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/README_EN.md

+101-2
Original file line numberDiff line numberDiff line change
@@ -63,19 +63,118 @@ It can be shown that 4 seconds is the minimum time greater than zero required fo
6363
<!-- tabs:start -->
6464

6565
```python
66+
class Solution:
67+
def minimumTimeToInitialState(self, word: str, k: int) -> int:
68+
n = len(word)
69+
for i in range(1, 10001):
70+
re = i * k
71+
if re >= n:
72+
return i
73+
if word[re:] == word[:n - re]:
74+
return i
75+
return 0
6676

6777
```
6878

6979
```java
70-
80+
class Solution {
81+
public int minimumTimeToInitialState(String word, int k) {
82+
int n = word.length();
83+
for (int i = 1; i <= 10000; i++) {
84+
int re = i * k;
85+
if (re >= n) {
86+
return i;
87+
}
88+
String str = word.substring(re);
89+
boolean flag = true;
90+
for (int j = 0; j < str.length(); j++) {
91+
if (str.charAt(j) != word.charAt(j)) {
92+
flag = false;
93+
break;
94+
}
95+
}
96+
if (flag) {
97+
return i;
98+
}
99+
}
100+
return 0;
101+
}
102+
}
71103
```
72104

73105
```cpp
74-
106+
class Solution {
107+
public:
108+
int minimumTimeToInitialState(string word, int k) {
109+
int n = word.length();
110+
for (int i = 1; i <= 10000; i++) {
111+
int re = i * k;
112+
if (re >= n) {
113+
return i;
114+
}
115+
string str = word.substr(re);
116+
bool flag = true;
117+
for (int j = 0; j < str.length(); j++) {
118+
if (str[j] != word[j]) {
119+
flag = false;
120+
break;
121+
}
122+
}
123+
if (flag) {
124+
return i;
125+
}
126+
}
127+
return 0;
128+
}
129+
};
75130
```
76131
77132
```go
133+
func minimumTimeToInitialState(word string, k int) int {
134+
n := len(word)
135+
for i := 1; i <= 10000; i++ {
136+
re := i * k
137+
if re >= n {
138+
return i
139+
}
140+
str := word[re:]
141+
flag := true
142+
for j := 0; j < len(str); j++ {
143+
if str[j] != word[j] {
144+
flag = false
145+
break
146+
}
147+
}
148+
if flag {
149+
return i
150+
}
151+
}
152+
return 0
153+
}
154+
```
78155

156+
```ts
157+
function minimumTimeToInitialState(word: string, k: number): number {
158+
const n = word.length;
159+
for (let i = 1; i <= 10000; i++) {
160+
const re = i * k;
161+
if (re >= n) {
162+
return i;
163+
}
164+
const str = word.substring(re);
165+
let flag = true;
166+
for (let j = 0; j < str.length; j++) {
167+
if (str[j] !== word[j]) {
168+
flag = false;
169+
break;
170+
}
171+
}
172+
if (flag) {
173+
return i;
174+
}
175+
}
176+
return 0;
177+
}
79178
```
80179

81180
<!-- tabs:end -->

‎solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.cpp

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
int minimumTimeToInitialState(string word, int k) {
4+
int n = word.length();
5+
for (int i = 1; i <= 10000; i++) {
6+
int re = i * k;
7+
if (re >= n) {
8+
return i;
9+
}
10+
string str = word.substr(re);
11+
bool flag = true;
12+
for (int j = 0; j < str.length(); j++) {
13+
if (str[j] != word[j]) {
14+
flag = false;
15+
break;
16+
}
17+
}
18+
if (flag) {
19+
return i;
20+
}
21+
}
22+
return 0;
23+
}
24+
};

‎solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.go

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
func minimumTimeToInitialState(word string, k int) int {
2+
n := len(word)
3+
for i := 1; i <= 10000; i++ {
4+
re := i * k
5+
if re >= n {
6+
return i
7+
}
8+
str := word[re:]
9+
flag := true
10+
for j := 0; j < len(str); j++ {
11+
if str[j] != word[j] {
12+
flag = false
13+
break
14+
}
15+
}
16+
if flag {
17+
return i
18+
}
19+
}
20+
return 0
21+
}

‎solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.java

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
class Solution {
2+
public int minimumTimeToInitialState(String word, int k) {
3+
int n = word.length();
4+
for (int i = 1; i <= 10000; i++) {
5+
int re = i * k;
6+
if (re >= n) {
7+
return i;
8+
}
9+
String str = word.substring(re);
10+
boolean flag = true;
11+
for (int j = 0; j < str.length(); j++) {
12+
if (str.charAt(j) != word.charAt(j)) {
13+
flag = false;
14+
break;
15+
}
16+
}
17+
if (flag) {
18+
return i;
19+
}
20+
}
21+
return 0;
22+
}
23+
}

‎solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.py

+10
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
class Solution:
2+
def minimumTimeToInitialState(self, word: str, k: int) -> int:
3+
n = len(word)
4+
for i in range(1, 10001):
5+
re = i * k
6+
if re >= n:
7+
return i
8+
if word[re:] == word[: n - re]:
9+
return i
10+
return 0

‎solution/3000-3099/3029.Minimum Time to Revert Word to Initial State I/Solution.ts

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
function minimumTimeToInitialState(word: string, k: number): number {
2+
const n = word.length;
3+
for (let i = 1; i <= 10000; i++) {
4+
const re = i * k;
5+
if (re >= n) {
6+
return i;
7+
}
8+
const str = word.substring(re);
9+
let flag = true;
10+
for (let j = 0; j < str.length; j++) {
11+
if (str[j] !== word[j]) {
12+
flag = false;
13+
break;
14+
}
15+
}
16+
if (flag) {
17+
return i;
18+
}
19+
}
20+
return 0;
21+
}

0 commit comments

Comments
 (0)