Xem thảo luận
Cải thiện bài viết
Lưu bài viết
ĐọcBàn luậnXem 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 : sforgeeksgeek
1 The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
2The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
3=
The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
5The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
6=
The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
8The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
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)
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 : sforgeeksgeek
8__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
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 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)
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)
6The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
1 The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
3from 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)
9 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
9
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 : sforgeeksgeek
1 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 : sforgeeksgeek
1 The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
2The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
3=
The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
5The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
6=
The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
8The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
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)
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 : sforgeeksgeek
8__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
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 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)
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)
6The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
1 The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek
3from 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)
9 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
9
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 : sforgeeksgeek
1 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ờ ...
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.
Và người chiến thắng là.....
Bước 1: Nhập chuỗi. Bước 2: Chuỗi riêng biệt trong hai phần thứ nhất và thứ hai, cho xoay bên trái lfirst = str [0: d] và lsecond = str [d:]. Đối với vòng quay bên phải rfirst = str [0: len (str) -d] và rsecond = str [len (str) -d:].Rfirst = str[0 : len(str)-d] and Rsecond = str[len(str)-d : ].
Đưa ra một chuỗi kích thước n, viết các chức năng để thực hiện các hoạt động sau trên chuỗi.Trái (hoặc ngược chiều kim đồng hồ) xoay chuỗi đã cho bằng các phần tử d (trong đó dLeft (Or anticlockwise) rotate the given string by d elements (where d <= n). Right (Or clockwise) rotate the given string by d elements (where d <= n).
Bạn có thể đi qua một chuỗi như một chuỗi con bằng cách sử dụng toán tử lát python ([]).Nó cắt bỏ một chuỗi con từ chuỗi ban đầu và do đó cho phép lặp lại một phần.Để sử dụng phương pháp này, cung cấp các chỉ số bắt đầu và kết thúc cùng với giá trị bước và sau đó đi qua chuỗi.using the Python slice operator ([]). It cuts off a substring from the original string and thus allows to iterate over it partially. To use this method, provide the starting and ending indices along with a step value and then traverse the string.