Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 7276c22

Browse files
feat: add solutions to lc problem: No.3029 (doocs#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‎

Lines changed: 101 additions & 2 deletions
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‎

Lines changed: 101 additions & 2 deletions
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 -->
Lines changed: 24 additions & 0 deletions
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+
};
Lines changed: 21 additions & 0 deletions
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+
}
Lines changed: 23 additions & 0 deletions
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+
}
Lines changed: 10 additions & 0 deletions
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
Lines changed: 21 additions & 0 deletions
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)

AltStyle によって変換されたページ (->オリジナル) /