字符串ABCD，可以由字符串BCDA或者CDAB通过循环移位

java 最简单
建立一个stringbuffer 以s2为基础  然后append一个s2
然后判断tostring 判断 contains s1即可

def areAnagram(s1,s2):    

        if(len(s1)!=len(s2)):

            return False

        else:

            for _ in range(len(s1)):

                temp=s1[1:]

                temp+=s1[0]

                if temp==s2:

                    return True

            return False

if __name__ == "__main__":

    s1=input("Enter first string: ")

    s2=input("Enter second string: ")

    if areAnagram(s1,s2):

        print("Strings are anagram of each other")

    else:

        print("Strings are not anagram of each other")

package 字符串循环位移;

public class StrMoveAround {
    public static void main(String[] args) {
        StrMoveAround strMoveAround = new StrMoveAround();
        System.out.println(strMoveAround.fun1("ABCD", "CDAB"));

        System.out.println(strMoveAround.fun2("ABCDEFG", "BCDEFGA"));
    }

    public boolean fun1(String s1, String s2) {
        int length = s2.length();
        for (int i = 0; i < length; i++) {
            char[] chars = s2.toCharArray();
            char temp = chars[0];
            for (int j = 0; j < length - 1; j++) {
                chars[j] = chars[j + 1];
            }
            chars[length - 1] = temp;
            String s = String.valueOf(chars);        //输出一次循环位移的结果
            System.out.println(s);
            if (s1.equals(s))
                return true;
            s2 = s;
        }
        return false;
    }

    public boolean fun2(String s1, String s2) {
        return (s2 + s2).indexOf(s1) < s2.length() && s2.length() == s1.length() ? true : false;
    }
}

class Solution{
    public static boolean isTrue(String s1, String s2){
        int len = s1.length();
        int len2 = s2.length();
        if(len!=len2){
            return false;
        }
        LinkedList<Character> list = new LinkedList<>(); 
        for(int i=0;i<len;i++){
            list.add(s2.charAt(i));
        }
        for(int i=0;i<len;i++){
            list.insert(0,list.get(len-1));
            StringBuilder s=new StringBuilder();
            for(int j=0;j<len;){
                s.append(list.get(j));
                                j++;
            }
            if(s.toString().equals(s1)){
                return true;
            }
        }
        return false;
    }
}

import java.util.Scanner;

/**
 * 字符串ABCD，可以由字符串BCDA或者CDAB通过循环移位而得到。
 * 请编程实现以下检测：字符串S1是否可以由字符串S2通 过循环移位而得到 -- 美团
 *
 * @author Jian Shen
 * @version V1.0
 * @date 2018/11/27
 */
public class CyclicShift {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String s1 = scanner.next();
            String s2 = scanner.next();
            System.out.println(isContained(s1, s2));
        }
    }

    private static boolean isContained(String s1, String s2) {
        if (s1 == null || s2 == null) {
            return false;
        }
        StringBuilder builder = new StringBuilder();
        builder.append(s2).append(s2);

        if (builder.toString().contains(s1)) {
            return true;
        }
        return false;
    }
}

bool IsRotate(char* strA, const int& lenA, char* strB)
{
	bool isContain = false;
	if (strA==NULL || strB==NULL)
	{
		return isContain;
	}

	//每次步长为1，循环lenA次
	for (int i=0; i<lenA; i++)
	{
		//Rotate利用三步反转法完成字符串的反转，即YX= (X^T*Y^T)^T
		Rotate(strA, lenA, 1);
		if (strcmp(strA, strB))//比较strB是否和strA相等，若是相等，则不用再比较了
		{
			isContain = true;
			break;			
		}
		
	}
	return isContain;
}

void Rotate(char* s, int length, int selctNum)
{
	Invert(s, s + (selctNum-1));
	Invert(s+selctNum, s+(length-1));
	Invert(s, s+(length-1));
}

void Invert(char* start, char* end)
{
	if (start == NULL || end == NULL)
	{
		return;
	}

	
	while (start < end)
	{
		char temp = *start;
		*start = *end;
		*end = temp;

		start++;
		end--;
	}
} 

bool cmpstr(const char* s1,const char* s2)
{
	if(!s1||!s2)
		return false;
	int len1=strlen(s1);
	int len2=strlen(s2);
	if(len1!=len2)
		return false;
	if(len1==0)
		return true;
	char *s3=(char *)malloc(2*len1+1);
	memset(s3,0,2*len1+1);
	strcat(s3,s2);
	strcat(s3,s2);
	for(int i=0;i<len1;i++)
		if(strncmp(s1,s3+i,len1)==0)
			return true;
	return false;
}

}

public class Question2 {
    private static void reverseCharArr(char[] arr, int left, int right) {
        if (arr == null || left > right) return;

        while (left < right) {
            char tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;

            left++;
            right--;
        }
    }

    public static void main(String[] args) {
        System.out.println(isRotate("ABCD", "DABC"));
    }

    private static String rotate(String str, int i) {
        if (str == null || i > str.length()) return null;

        char arr[] = str.toCharArray();
        reverseCharArr(arr, 0, i-1);
        reverseCharArr(arr, i, arr.length-1);
        reverseCharArr(arr, 0, arr.length-1);

        return new String(arr);
    }

    public static boolean isRotate(String s1, String s2) {
        if (s1 == null || s2 == null || s2.length() != s1.length()) return false;

        int indexOfFirst = s2.indexOf(s1.charAt(0));

        if (indexOfFirst == -1) return false;

        System.out.println(indexOfFirst);

        String tmp = rotate(s2, indexOfFirst);
        System.out.println(tmp);

        if (tmp.equals(s1)) {
            return true;
        }
        return  false;
    }


}