Hướng dẫn right shift string in python - chuỗi dịch chuyển phải trong python

Question

Xem thảo luận

Nội dung chính Show

Thời gian thi
Làm thế nào để bạn chuyển một chuỗi sang bên phải?
Làm thế nào để bạn xoay một chuỗi sang phải trong Python?
Làm thế nào để bạn thay đổi các từ trong Python?
Làm thế nào để bạn di chuyển một chuỗi trong Python?

Cải thiện bài viết

Lưu bài viết

Đọc

Bàn luận

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.

Có thể bạn quan tâm

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

2

The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek

3=

The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek

5

The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek

6=

The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek

8

The 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)

1

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

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

1
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)
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)
5
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)
6
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek
1
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek
3
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)
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]

4

def 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

2

The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek

3=

The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek

5

The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek

6=

The original string is : geeksforgeeks
The string after rotation is : sforgeeksgeek

8

The 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)

1

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

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

1
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)
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)
5
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)
6
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek
1
The original string is : geeksforgeeks The string after rotation is : sforgeeksgeek
3
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)
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]

4

def 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 print0, 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 :)

Làm thế nào để bạn chuyển một chuỗi sang bên phải?

Phương pháp số 1: Một giải pháp đơn giản là sử dụng chuỗi tạm thời để thực hiện xoay vòng. Đối với vòng quay bên trái, trước tiên, hãy sao chép các ký tự N-D cuối cùng, sau đó sao chép các ký tự D đầu tiên theo chuỗi tạm thời. Để xoay đúng, đầu tiên, sao chép các ký tự D cuối cùng, sau đó sao chép các ký tự N-D.first, copy last d characters, then copy n-d characters.

Làm thế nào để bạn xoay một chuỗi sang phải trong Python?

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 : ].

Làm thế nào để bạn thay đổi các từ trong Python?

strs [(strs.index (i) + shift) % 26]: dòng trên có nghĩa là tìm chỉ số của ký tự I trong strs và sau đó thêm giá trị dịch chuyển vào nó.Bây giờ, trên giá trị cuối cùng (INDEX+SHIFT) áp dụng %26 cho chỉ số nhận được.Chỉ số đã thay đổi này khi được chuyển cho STRS [new_index] mang lại ký tự thay đổi mong muốn. index(i) + shift) % 26] : line above means find the index of the character i in strs and then add the shift value to it. Now, on the final value(index+shift) apply %26 to the get the shifted index. This shifted index when passed to strs[new_index] yields the desired shifted character.

Làm thế nào để bạn di chuyển một chuỗi trong Python?

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.

programming python Reverse shift Python Python __lshift__

Hướng dẫn right shift string in python - chuỗi dịch chuyển phải trong python

Có thể bạn quan tâm

Python3

Python3

Thời gian thi

Làm thế nào để bạn chuyển một chuỗi sang bên phải?

Làm thế nào để bạn xoay một chuỗi sang phải trong Python?

Làm thế nào để bạn thay đổi các từ trong Python?

Làm thế nào để bạn di chuyển một chuỗi trong Python?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Token Data

Quảng Cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội