彩色宝石项链

array = list(input())
N = len(array)
i = 0
result = []
while i < N:
    if array[i] in ['A','B','C','D','E']:
        newArray = array[i:N] + array[0:i]
        need = ['A','B','C','D','E']
        toKing = 0
        begin = False
        for item in newArray:
            if not need:
                break
            if item in need and len(need) > 0:
                need.remove(item)
                begin = True
            if begin:
                toKing += 1
        result.append(toKing)
    i += 1
result = N - min(result)
print(result)

s = input()
n = len(s)
s = s * 2
m = n

for i in range(n):
    a = s[i:i+n]
    x = []
    for j in "ABCDE":
        x.append(a.find(j))
    max_x = max(x)
    if m > max_x:
        m = max_x
print(n-(m+1))

分享一个简单粗暴的思路和解答。
1.将每次输入的数组直接乘2拼接起来（NN=N+N），然后每次初始化的判断区间是输入数组的长度(N),之后每次左边收一格（left+=1）,发现不能收了之后开始收右边（right-=1）
2.两边都不能收的时候返回此时剩余的宝石（len(N)-(r-l)），存入数组，循环输入字符串长度的次数
3.打印存入每次循环的值中的最大值即可

import sys
N=input()
NN=N+N
res=[]
for i in range(0,len(N)):
    l=i;r=i+len(N)-1
    left=0;right=0
    while((left==0)|(right==0)):
        while(('A'in NN[l:r])&('B'in NN[l:r])&('C'in NN[l:r])&('D'in NN[l:r])&('E'in NN[l:r])):
            l+=1
        left=1
        l-=1
        while(('A'in NN[l:r])&('B'in NN[l:r])&('C'in NN[l:r])&('D'in NN[l:r])&('E'in NN[l:r])):
            r-=1
        right=1
        r+=1
    res+=[len(N)-(r-l)]
print(max(res))

xl = input('')*2
bs = {'A', 'B', 'C', 'D', 'E'}
if bs & set(xl) == bs:
    lenth = 10000
    for i in range(len(xl)//2):
        for j in range(5, len(xl)//2+1):
            if j >= lenth:
                break
            if bs & set(xl[i: i+j]) == bs:
                lenth = j
                break
    print(len(xl)//2-lenth)
else:
    print(0)

#通过每位右移来找到最短子段
s=input()
l=len(s)
length=l#包含ABCDE的子段的长度为length,初始值为l
for i in range(l):#对s进行循环，使其首尾相连
    d=[]
    for j in 'ABCDE':#找出所有ABCDE的序号
        d.append(s.find(j))
    d.sort()#按顺序排列
    if length>d[-1]+1:#若当前子段长度大于最大序号，则更新长度
        length=d[-1]+1
    s=s[1:]+s[0]#最左的头部移到最右的尾部
print(l-length)#拿到的宝石数量为原始长度减去子段长度

算是暴力求解了吧：
遍历数组，直到出现ABCDE中一个，再以改字符位开头，找到第一次出现的ABCDE的索引，再求最大的距离。直到数组遍历结束，找出真正最大距离。

def ca_min(index_list):
    index_list.sort()
    ans = max(index_list[1]-index_list[0],
              index_list[2] - index_list[1],
              index_list[3] - index_list[2],
              index_list[4] - index_list[3],
              len_x-index_list[4])
    return ans-1
X = input()
len_x= len(X)
temp = ['A','B','C','D','E']
flag = True
max_ans = 0
for i in temp:
    if i not in X:
        print(0)
        flag = False
        break
if flag:
    for i in range(len_x):
        if X[i] in temp:
            temp_x = X[i:]+X[:i]
            index = []
            for char_x in temp:
                index.append(temp_x.index(char_x))
            temp_ans = ca_min(index)
            if temp_ans>max_ans:
                max_ans = temp_ans
    print(max_ans)