Xem thảo luận
Cải thiện bài viết
Lưu bài viết
Xem thảo luận
Cải thiện bài viết
Lưu bài viết
ĐọcMethod #1 : Using String multiplication + string slicing The combination of above functions can be used to perform this task. In this, we multiple string thrice, perform the concatenation and selectively slice string to get required result.
Python3
Bàn luận
Đôi khi, trong khi làm việc với các chuỗi Python, chúng ta có thể gặp vấn đề trong đó chúng ta có cả số lần xoay bên phải và bên trái trong chuỗi và muốn biết điều kiện kết quả của chuỗi. Loại vấn đề này xảy ra trong lập trình cạnh tranh. Hãy thảo luận về những cách nhất định trong đó nhiệm vụ này có thể được thực hiện. Phương pháp số 1: Sử dụng phép nhân chuỗi + Chuỗi cắt kết hợp các hàm trên có thể được sử dụng để thực hiện tác vụ này. Trong đó, chúng tôi nhiều chuỗi ba lần, thực hiện kết nối và cắt chuỗi chọn lọc để nhận kết quả cần thiết. & NBSP;
test_str
=
'geeksforgeeks'
print
[
____10
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek1
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek2
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek3
=
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek5
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek6
=
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek8
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek9
=
from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
1from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
2 The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek8__
1You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
######## USE: 'I Me You'
trivial ----> 0.1339518820000194
more_split ----> 0.1532761280000159
dq ----> 0.182199565000019
find_and_slice ----> 0.07563322400005745
rs_lazy ----> 0.23457759100006115
rs_smart ----> 0.1615759960000105
rpart ----> 0.06102836100001241
######## USE: 'a b c d e f '*100
trivial ----> 3.2239098259999537
more_split ----> 4.6946649449999995
dq ----> 3.991058845999987
find_and_slice ----> 0.15106809200005955
rs_lazy ----> 0.32278001499992115
rs_smart ----> 0.22939544400003342
rpart ----> 0.10590313199998036
2 You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
######## USE: 'I Me You'
trivial ----> 0.1339518820000194
more_split ----> 0.1532761280000159
dq ----> 0.182199565000019
find_and_slice ----> 0.07563322400005745
rs_lazy ----> 0.23457759100006115
rs_smart ----> 0.1615759960000105
rpart ----> 0.06102836100001241
######## USE: 'a b c d e f '*100
trivial ----> 3.2239098259999537
more_split ----> 4.6946649449999995
dq ----> 3.991058845999987
find_and_slice ----> 0.15106809200005955
rs_lazy ----> 0.32278001499992115
rs_smart ----> 0.22939544400003342
rpart ----> 0.10590313199998036
2 from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
5from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
6from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
1 The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
3
9 from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
9You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
######## USE: 'I Me You'
trivial ----> 0.1339518820000194
more_split ----> 0.1532761280000159
dq ----> 0.182199565000019
find_and_slice ----> 0.07563322400005745
rs_lazy ----> 0.23457759100006115
rs_smart ----> 0.1615759960000105
rpart ----> 0.06102836100001241
######## USE: 'a b c d e f '*100
trivial ----> 3.2239098259999537
more_split ----> 4.6946649449999995
dq ----> 3.991058845999987
find_and_slice ----> 0.15106809200005955
rs_lazy ----> 0.32278001499992115
rs_smart ----> 0.22939544400003342
rpart ----> 0.10590313199998036
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek
print
[
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
2 The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek1
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
4def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
5Method #2 : Using % operator and string
slicing The combination of above functionalities can also be used to perform this task. In this, we find the mod of rotation difference with length to compute the string position. Python3
Bàn luận
Đôi khi, trong khi làm việc với các chuỗi Python, chúng ta có thể gặp vấn đề trong đó chúng ta có cả số lần xoay bên phải và bên trái trong chuỗi và muốn biết điều kiện kết quả của chuỗi. Loại vấn đề này xảy ra trong lập trình cạnh tranh. Hãy thảo luận về những cách nhất định trong đó nhiệm vụ này có thể được thực hiện. Phương pháp số 1: Sử dụng phép nhân chuỗi + Chuỗi cắt kết hợp các hàm trên có thể được sử dụng để thực hiện tác vụ này. Trong đó, chúng tôi nhiều chuỗi ba lần, thực hiện kết nối và cắt chuỗi chọn lọc để nhận kết quả cần thiết. & NBSP;
test_str
=
'geeksforgeeks'
print
[
____10
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek1
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek2
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek3
=
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek5
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek6
=
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek8
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek9
=
from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
1from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
2 The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek8__
1You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
######## USE: 'I Me You'
trivial ----> 0.1339518820000194
more_split ----> 0.1532761280000159
dq ----> 0.182199565000019
find_and_slice ----> 0.07563322400005745
rs_lazy ----> 0.23457759100006115
rs_smart ----> 0.1615759960000105
rpart ----> 0.06102836100001241
######## USE: 'a b c d e f '*100
trivial ----> 3.2239098259999537
more_split ----> 4.6946649449999995
dq ----> 3.991058845999987
find_and_slice ----> 0.15106809200005955
rs_lazy ----> 0.32278001499992115
rs_smart ----> 0.22939544400003342
rpart ----> 0.10590313199998036
2 You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
######## USE: 'I Me You'
trivial ----> 0.1339518820000194
more_split ----> 0.1532761280000159
dq ----> 0.182199565000019
find_and_slice ----> 0.07563322400005745
rs_lazy ----> 0.23457759100006115
rs_smart ----> 0.1615759960000105
rpart ----> 0.06102836100001241
######## USE: 'a b c d e f '*100
trivial ----> 3.2239098259999537
more_split ----> 4.6946649449999995
dq ----> 3.991058845999987
find_and_slice ----> 0.15106809200005955
rs_lazy ----> 0.32278001499992115
rs_smart ----> 0.22939544400003342
rpart ----> 0.10590313199998036
2 from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
5from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
6from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
1 The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
3
9 from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
9You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
You I Me
######## USE: 'I Me You'
trivial ----> 0.1339518820000194
more_split ----> 0.1532761280000159
dq ----> 0.182199565000019
find_and_slice ----> 0.07563322400005745
rs_lazy ----> 0.23457759100006115
rs_smart ----> 0.1615759960000105
rpart ----> 0.06102836100001241
######## USE: 'a b c d e f '*100
trivial ----> 3.2239098259999537
more_split ----> 4.6946649449999995
dq ----> 3.991058845999987
find_and_slice ----> 0.15106809200005955
rs_lazy ----> 0.32278001499992115
rs_smart ----> 0.22939544400003342
rpart ----> 0.10590313199998036
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek
print
[
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
2 The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek1
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
4def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
5Đầu ra: & nbsp;O[n]
& nbsp; Phương pháp số 2: Sử dụng toán tử % và cắt chuỗi Kết hợp các chức năng trên cũng có thể được sử dụng để thực hiện nhiệm vụ này. Trong đó, chúng tôi tìm thấy sự khác biệt của Mod of Rotation với độ dài để tính toán vị trí chuỗi. & NBSP;O[n]
Và bây giờ ...
Thời gian thi
Có lẽ điều thú vị hơn là cách tiếp cận nhanh hơn là gì ?.
Thử nghiệm đầu tiên bằng chuỗi kiểm tra OP [chỉ 3 khối] và thử nghiệm thứ hai bằng chuỗi 600 một char.
from collections import deque
import timeit
def trivial[s]:
l = s.split[]
return ' '.join[l[-1:] + l[:-1]]
def more_split[s]:
return ' '.join[[s.split[][-1]] + s.split[][:-1]]
def dq[s]:
s_deq = deque[s.split[]]
s_deq.rotate[1]
return ' '.join[s_deq]
def find_and_slice[s]:
lsi = s.rfind[' ']
return s[lsi+1:] + ' ' + s[:lsi]
def rs_lazy[s]:
return ' '.join[reversed[s.rsplit[maxsplit=1]]]
def rs_smart[s]:
rs = s.rsplit[maxsplit=1]
return rs[1] + ' ' + rs[0]
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
def time_a_method[m, s]:
c_arg = "['{}']".format[s]
t = timeit.timeit[m + c_arg, setup="from __main__ import " + m , number=100000]
print[ m + " "*[15-len[m]] + "----> {}".format[t]]
if __name__ == '__main__':
print[trivial["I Me You"]]
print[more_split["I Me You"]]
print[dq["I Me You"]]
print[find_and_slice["I Me You"]]
print[rs_lazy["I Me You"]]
print[rs_smart["I Me You"]]
print[rpart["I Me You"]]
print["######## USE: 'I Me You'"]
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, "I Me You"]
print["######## USE: 'a b c d e f '*100"]
s = 'a b c d e f '*100
for m in ["trivial", "more_split", "dq", "find_and_slice", "rs_lazy", "rs_smart", "rpart"]:
time_a_method[m, s]
Cho kết quả theo dõi:
You I Me You I Me You I Me You I Me You I Me You I Me You I Me ######## USE: 'I Me You' trivial ----> 0.1339518820000194 more_split ----> 0.1532761280000159 dq ----> 0.182199565000019 find_and_slice ----> 0.07563322400005745 rs_lazy ----> 0.23457759100006115 rs_smart ----> 0.1615759960000105 rpart ----> 0.06102836100001241 ######## USE: 'a b c d e f '*100 trivial ----> 3.2239098259999537 more_split ----> 4.6946649449999995 dq ----> 3.991058845999987 find_and_slice ----> 0.15106809200005955 rs_lazy ----> 0.32278001499992115 rs_smart ----> 0.22939544400003342 rpart ----> 0.10590313199998036
Và người chiến thắng là.....
def rpart[s]:
part = s.rpartition[' ']
return part[-1] + part[1] + part[0]
Điều đó làm tôi ngạc nhiên [tôi cá là 'geeksforgeeks'
9 và tôi đã thua]. Có 2 lớp câu trả lời:
- Lực lượng vũ phu: Chia tất cả chuỗi
- Hãy quan tâm rằng chúng ta chỉ cần phần cuối cùng của chuỗi
Ngay cả trong trường hợp đơn giản nhất print
0, cách tiếp cận đầu tiên chậm hơn từ 2 đến 3 lần so với phương pháp tốt nhất. Rõ ràng khi chuỗi trở nên thú vị hơn, cách tiếp cận đầu tiên trở nên thực sự không hiệu quả.
Điều thú vị thực sự là câu trả lời được bình chọn nhiều nhất là chậm hơn :]