インタビューの質問：1つの文字列が他の文字列の回転であるかどうかを確認します[終了]

私の友人は本日、ソフトウェア開発者の立場についてのインタビューで次の質問をされました：

2つの文字列を考えるs1とs2、どのようにかどうかをチェックしますs1で、回転のバージョンs2？

例：

場合はs1 = "stackoverflow"、その後、次はその回転バージョンの一部です：

"tackoverflows"
"ackoverflowst"
"overflowstack"

ここで、as "stackoverflwo"はローテーションバージョンではありません。

彼が出した答えは：

のs2サブストリングである最長の接頭辞を取得して見つけますs1。これにより、回転のポイントが得られます。そのポイントを見つけたら、そのポイントで中断s2してとを取得s2aしs2b、次にconcatenate(s2a,s2b) == s1

それは私と私の友人にとって良い解決策のように見えます。しかし、インタビュアーはそうではないと考えました。彼はもっと簡単な解決策を求めました。これをどのように行うのか教えてくださいJava/C/C++。

前もって感謝します。

まず、同じ長さであることを確認s1しs2てください。次にs2、とs1連結された部分文字列であるかどうかを確認しますs1。

algorithm checkRotation(string s1, string s2) 
  if( len(s1) != len(s2))
    return false
  if( substring(s2,concat(s1,s1))
    return true
  return false
end

Javaの場合：

boolean isRotation(String s1,String s2) {
    return (s1.length() == s2.length()) && ((s1+s1).indexOf(s2) != -1);
}

確かに、より良い答えは、「まあ、私はstackoverflowコミュニティに質問し、おそらく5分以内に少なくとも4つの本当に良い答えがあるだろう」でしょう。脳はすべて良いですが、私は解決策を得るために他の人と協力する方法を知っている人を高く評価します。

別のpythonの例（答えに基づく）：

def isrotation(s1,s2):
     return len(s1)==len(s2) and s1 in 2*s2

他の人が2次の最悪の場合の時間の複雑さのソリューションを提出したので、線形のソリューションを追加します（KMPアルゴリズムに基づく）：

bool is_rotation(const string& str1, const string& str2)
{
  if(str1.size()!=str2.size())
    return false;

  vector<size_t> prefixes(str1.size(), 0);
  for(size_t i=1, j=0; i<str1.size(); i++) {
    while(j>0 && str1[i]!=str1[j])
      j=prefixes[j-1];
    if(str1[i]==str1[j]) j++;
    prefixes[i]=j;
  }

  size_t i=0, j=0;
  for(; i<str2.size(); i++) {
    while(j>0 && str2[i]!=str1[j])
      j=prefixes[j-1];
    if(str2[i]==str1[j]) j++;
  }
  for(i=0; i<str2.size(); i++) {
    if(j>=str1.size()) return true;
    while(j>0 && str2[i]!=str1[j])
      j=prefixes[j-1];
    if(str2[i]==str1[j]) j++;
  }

  return false;
}

実例

編集：あなたがそれを見つければ、受け入れられた答えはこれよりも明らかにエレガントで効率的です。この答えは、元の文字列を2倍にすることを考えていなかった場合の対処法として残しました。

私はそれを総当たりするだろう。最初に長さを確認してから、考えられるすべての回転オフセットを試してください。どれもうまくいかない場合はfalseを返します-うまくいかない場合はすぐにtrueを返します。

特に連結する必要はありません-ポインター（C）またはインデックス（Java）を使用して、各文字列に1つずつ両方をたどります。 。文字列の各ポイントで文字が等しいかどうかを確認します。最初の文字列の終わりに到達したら、完了です。

それはおそらく連結するのと同じくらい簡単でしょう-少なくともJavaではおそらくそれほど効率的ではありません。

楽しみのために正規表現を使用しているものは次のとおりです。

boolean isRotation(String s1, String s2) {
   return (s1.length() == s2.length()) && (s1 + s2).matches("(.*)(.*)\\2\\1");
}

どちらの文字列にも含まれないことが保証されている特殊な区切り文字を使用できる場合は、少し単純にすることができます。

boolean isRotation(String s1, String s2) {
   // neither string can contain "="
   return (s1 + "=" + s2).matches("(.*)(.*)=\\2\\1");
}

代わりに、有限繰り返しで後読みを使用することもできます。

boolean isRotation(String s1, String s2) {
   return (s1 + s2).matches(
      String.format("(.*)(.*)(?<=^.{%d})\\2\\1", s1.length())
   );
}

おっと、おっと...なぜ誰もがそんなにO(n^2)答えにわくわくするのですか？私たちはここでもっと上手くできると確信しています。上記の答えには、ループ内のO(n)操作O(n)（substring / indexOf呼び出し）が含まれています。より効率的な検索アルゴリズムを使用しても、Boyer-Mooreまたはと言ってもKMP、最悪のケースはまだO(n^2)重複しています。

O(n)無作為化答えは簡単です。O(1)スライディングウィンドウをサポートする（Rabinフィンガープリントのような）ハッシュを取得します。ハッシュ文字列1、次にハッシュ文字列2、ハッシュ1のウィンドウを文字列の周りに移動し、ハッシュ関数が衝突するかどうかを確認します。

最悪のケースが「DNAの2つのストランドをスキャンする」ようなものだと想像すると、衝突の確率が高くなり、これはおそらくO(n^(1+e))何か（ここで推測）に悪化します。

最後に、O(nlogn)非常に大きな定数が外部にある確定的な解決策があります。基本的に、アイデアは2つの文字列の畳み込みを取ることです。畳み込みの最大値は回転の差になります（回転されている場合）。O(n)チェック確認します。良いことは、2つの等しい最大値がある場合、どちらも有効なソリューションであることです。2つのFFTとドット積、およびiFFTで畳み込みを行うことができますnlogn + nlogn + n + nlogn + n == O(nlogn)。

ゼロを埋め込むことはできず、文字列の長さが2 ^ nであることを保証できないため、FFTは高速ではありません。それらは遅いものO(nlogn)ですが、CTアルゴリズムよりもはるかに大きな定数です。

そうは言っても、私はO(n)断固として、ここには確定的な解決策があることを100％肯定していますが、それを見つけることができるかどうかは気の毒です。

まず、2つの弦の長さが同じであることを確認します。その後、Cでは、単純なポインター反復でこれを行うことができます。

int is_rotation(char* s1, char* s2)
{
  char *tmp1;
  char *tmp2;
  char *ref2;

  assert(s1 && s2);
  if ((s1 == s2) || (strcmp(s1, s2) == 0))
    return (1);
  if (strlen(s1) != strlen(s2))
    return (0);

  while (*s2)
    {
      tmp1 = s1;
      if ((ref2 = strchr(s2, *s1)) == NULL)
        return (0);
      tmp2 = ref2;
      while (*tmp1 && (*tmp1 == *tmp2))
        {
          ++tmp1;
          ++tmp2;
          if (*tmp2 == '\0')
            tmp2 = s2;
        }
      if (*tmp1 == '\0')
        return (1);
      else
        ++s2;
    }
  return (0);
}

ここに、O(n)その場でのalghoritmがあります。<文字列の要素に演算子を使用します。もちろん、私のものではありません。私はここからそれを取りました（このサイトは洗練されています。過去に一度偶然見つけましたが、今はそのようなものを英語で見つけることができなかったので、私が持っているものを示します:)）。

bool equiv_cyc(const string &u, const string &v)
{
    int n = u.length(), i = -1, j = -1, k;
    if (n != v.length()) return false;

    while( i<n-1 && j<n-1 )
    {
        k = 1;
        while(k<=n && u[(i+k)%n]==v[(j+k)%n]) k++;
        if (k>n) return true;
        if (u[(i+k)%n] > v[(j+k)%n]) i += k; else j += k;
    }
    return false;
}

私はこれをJava次のように行う方が良いと思います：

boolean isRotation(String s1,String s2) {
    return (s1.length() == s2.length()) && (s1+s1).contains(s2);
}

Perlでは、次のようにします。

sub isRotation {
 my($string1,$string2) = @_;
 return length($string1) == length($string2) && ($string1.$string1)=~/$string2/;
}

正規表現の代わりにインデックス関数を使用することもできます：

sub isRotation {
 my($string1,$string2) = @_;
 return length($string1) == length($string2) && index($string2,$string1.$string1) != -1;
}

これが最も効率的な方法であるかどうかはわかりませんが、比較的興味深い方法かもしれません。Burrows-Wheeler変換です。WP記事によると、入力のすべてのローテーションは同じ出力を生成します。圧縮などのアプリケーションでは、これは望ましくないため、元の回転が示されます（たとえば、インデックスによって示されます。記事を参照してください）。しかし、回転に依存しない単純な比較には、理想的に聞こえます。もちろん、それは必ずしも理想的に効率的ではありません！

各文字を振幅として取り、それらに対して離散フーリエ変換を実行します。回転だけが異なる場合、周波数スペクトルは丸め誤差内と同じになります。もちろん、これは長さが2の累乗でない限り非効率で、FFTを実行できます:-)

まだモジュロアプローチを提供していないので、ここに1つあります。

static void Main(string[] args)
{
    Console.WriteLine("Rotation : {0}",
        IsRotation("stackoverflow", "ztackoverflow"));
    Console.WriteLine("Rotation : {0}",
        IsRotation("stackoverflow", "ackoverflowst"));
    Console.WriteLine("Rotation : {0}",
        IsRotation("stackoverflow", "overflowstack"));
    Console.WriteLine("Rotation : {0}",
        IsRotation("stackoverflow", "stackoverflwo"));
    Console.WriteLine("Rotation : {0}",
        IsRotation("stackoverflow", "tackoverflwos"));
    Console.ReadLine();
}

public static bool IsRotation(string a, string b)
{
    Console.WriteLine("\nA: {0} B: {1}", a, b);

    if (b.Length != a.Length)
        return false;

    int ndx = a.IndexOf(b[0]);
    bool isRotation = true;
    Console.WriteLine("Ndx: {0}", ndx);
    if (ndx == -1) return false;
    for (int i = 0; i < b.Length; ++i)
    {
        int rotatedNdx = (i + ndx) % b.Length;
        char rotatedA = a[rotatedNdx];

        Console.WriteLine( "B: {0} A[{1}]: {2}", b[i], rotatedNdx, rotatedA );

        if (b[i] != rotatedA)
        {
            isRotation = false;
            // break; uncomment this when you remove the Console.WriteLine
        }
    }
    return isRotation;
}

出力：

A: stackoverflow B: ztackoverflow
Ndx: -1
Rotation : False

A: stackoverflow B: ackoverflowst
Ndx: 2
B: a A[2]: a
B: c A[3]: c
B: k A[4]: k
B: o A[5]: o
B: v A[6]: v
B: e A[7]: e
B: r A[8]: r
B: f A[9]: f
B: l A[10]: l
B: o A[11]: o
B: w A[12]: w
B: s A[0]: s
B: t A[1]: t
Rotation : True

A: stackoverflow B: overflowstack
Ndx: 5
B: o A[5]: o
B: v A[6]: v
B: e A[7]: e
B: r A[8]: r
B: f A[9]: f
B: l A[10]: l
B: o A[11]: o
B: w A[12]: w
B: s A[0]: s
B: t A[1]: t
B: a A[2]: a
B: c A[3]: c
B: k A[4]: k
Rotation : True

A: stackoverflow B: stackoverflwo
Ndx: 0
B: s A[0]: s
B: t A[1]: t
B: a A[2]: a
B: c A[3]: c
B: k A[4]: k
B: o A[5]: o
B: v A[6]: v
B: e A[7]: e
B: r A[8]: r
B: f A[9]: f
B: l A[10]: l
B: w A[11]: o
B: o A[12]: w
Rotation : False

A: stackoverflow B: tackoverflwos
Ndx: 1
B: t A[1]: t
B: a A[2]: a
B: c A[3]: c
B: k A[4]: k
B: o A[5]: o
B: v A[6]: v
B: e A[7]: e
B: r A[8]: r
B: f A[9]: f
B: l A[10]: l
B: w A[11]: o
B: o A[12]: w
B: s A[0]: s
Rotation : False

[編集：2010-04-12]

piotrは上記の私のコードの欠陥に気づきました。文字列の最初の文字が2回以上出現するとエラーになります。たとえば、stackoverflowテストを実行するowstackoverflowと、trueであるはずのfalseが返されます。

エラーを発見してくれたpiotrに感謝します。

さて、これが修正されたコードです：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace TestRotate
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "ztackoverflow"));
            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "ackoverflowst"));
            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "overflowstack"));
            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "stackoverflwo"));
            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "tackoverflwos"));

            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "owstackoverfl"));

            Console.ReadLine();
        }

        public static bool IsRotation(string a, string b)
        {
            Console.WriteLine("\nA: {0} B: {1}", a, b);

            if (b.Length != a.Length)
                return false;

            if (a.IndexOf(b[0]) == -1 )
                return false;

            foreach (int ndx in IndexList(a, b[0]))
            {
                bool isRotation = true;

                Console.WriteLine("Ndx: {0}", ndx);

                for (int i = 0; i < b.Length; ++i)
                {
                    int rotatedNdx = (i + ndx) % b.Length;
                    char rotatedA = a[rotatedNdx];

                    Console.WriteLine("B: {0} A[{1}]: {2}", b[i], rotatedNdx, rotatedA);

                    if (b[i] != rotatedA)
                    {
                        isRotation = false;
                        break;
                    }
                }
                if (isRotation)
                    return true;
            }
            return false;
        }

        public static IEnumerable<int> IndexList(string src, char c)
        {
            for (int i = 0; i < src.Length; ++i)
                if (src[i] == c)
                    yield return i;
        }

    }//class Program
}//namespace TestRotate

出力は次のとおりです。

A: stackoverflow B: ztackoverflow
Rotation : False

A: stackoverflow B: ackoverflowst
Ndx: 2
B: a A[2]: a
B: c A[3]: c
B: k A[4]: k
B: o A[5]: o
B: v A[6]: v
B: e A[7]: e
B: r A[8]: r
B: f A[9]: f
B: l A[10]: l
B: o A[11]: o
B: w A[12]: w
B: s A[0]: s
B: t A[1]: t
Rotation : True

A: stackoverflow B: overflowstack
Ndx: 5
B: o A[5]: o
B: v A[6]: v
B: e A[7]: e
B: r A[8]: r
B: f A[9]: f
B: l A[10]: l
B: o A[11]: o
B: w A[12]: w
B: s A[0]: s
B: t A[1]: t
B: a A[2]: a
B: c A[3]: c
B: k A[4]: k
Rotation : True

A: stackoverflow B: stackoverflwo
Ndx: 0
B: s A[0]: s
B: t A[1]: t
B: a A[2]: a
B: c A[3]: c
B: k A[4]: k
B: o A[5]: o
B: v A[6]: v
B: e A[7]: e
B: r A[8]: r
B: f A[9]: f
B: l A[10]: l
B: w A[11]: o
Rotation : False

A: stackoverflow B: tackoverflwos
Ndx: 1
B: t A[1]: t
B: a A[2]: a
B: c A[3]: c
B: k A[4]: k
B: o A[5]: o
B: v A[6]: v
B: e A[7]: e
B: r A[8]: r
B: f A[9]: f
B: l A[10]: l
B: w A[11]: o
Rotation : False

A: stackoverflow B: owstackoverfl
Ndx: 5
B: o A[5]: o
B: w A[6]: v
Ndx: 11
B: o A[11]: o
B: w A[12]: w
B: s A[0]: s
B: t A[1]: t
B: a A[2]: a
B: c A[3]: c
B: k A[4]: k
B: o A[5]: o
B: v A[6]: v
B: e A[7]: e
B: r A[8]: r
B: f A[9]: f
B: l A[10]: l
Rotation : True

ラムダアプローチは次のとおりです。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IsRotation
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "ztackoverflow"));

            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "ackoverflowst"));

            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "overflowstack"));
            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "stackoverflwo"));

            Console.WriteLine("Rotation : {0}",
                IsRotation("stackoverflow", "owstackoverfl"));

            string strToTestFrom = "stackoverflow";
            foreach(string s in StringRotations(strToTestFrom))
            {
                Console.WriteLine("is {0} rotation of {1} ? {2}",
                    s, strToTestFrom,
                    IsRotation(strToTestFrom, s) );
            }
            Console.ReadLine();
        }

        public static IEnumerable<string> StringRotations(string src)
        {
            for (int i = 0; i < src.Length; ++i)
            {
                var sb = new StringBuilder();
                for (int x = 0; x < src.Length; ++x)
                    sb.Append(src[(i + x) % src.Length]);

                yield return sb.ToString();
            }
        }

        public static bool IsRotation(string a, string b)
        {
            if (b.Length != a.Length || a.IndexOf(b[0]) < 0 ) return false;
            foreach(int ndx in IndexList(a, b[0]))
            {
                int i = ndx;
                if (b.ToCharArray().All(x => x == a[i++ % a.Length]))
                    return true;
            }
            return false;
        }

        public static IEnumerable<int> IndexList(string src, char c)
        {
            for (int i = 0; i < src.Length; ++i)
                if (src[i] == c)
                    yield return i;
        }

    }//class Program

}//namespace IsRotation

ラムダアプローチの出力は次のとおりです。

Rotation : False
Rotation : True
Rotation : True
Rotation : False
Rotation : True
is stackoverflow rotation of stackoverflow ? True
is tackoverflows rotation of stackoverflow ? True
is ackoverflowst rotation of stackoverflow ? True
is ckoverflowsta rotation of stackoverflow ? True
is koverflowstac rotation of stackoverflow ? True
is overflowstack rotation of stackoverflow ? True
is verflowstacko rotation of stackoverflow ? True
is erflowstackov rotation of stackoverflow ? True
is rflowstackove rotation of stackoverflow ? True
is flowstackover rotation of stackoverflow ? True
is lowstackoverf rotation of stackoverflow ? True
is owstackoverfl rotation of stackoverflow ? True
is wstackoverflo rotation of stackoverflow ? True

誰もC ++ソリューションを提供していないので。ここにそれ：

bool isRotation(string s1,string s2) {

  string temp = s1;
  temp += s1;
  return (s1.length() == s2.length()) && (temp.find(s2) != string::npos);
}

Operaの単純なポインター回転トリックは機能しますが、実行時間の最悪のケースでは非常に非効率的です。多くの長い繰り返しの文字列を含む文字列を単に想像してください。

S1 = HELLOHELLOHELLO1HELLOHELLOHELLO2

S2 = HELLOHELLOHELLO2HELLOHELLOHELLO1

「不一致が見つかるまでループし、1ずつインクリメントしてもう一度試す」は、計算上は恐ろしいアプローチです。

あまり努力せずにプレーンCで連結アプローチを実行できることを証明するために、これが私の解決策です。

  int isRotation(const char* s1, const char* s2) {
        assert(s1 && s2);

        size_t s1Len = strlen(s1);

        if (s1Len != strlen(s2)) return 0;

        char s1SelfConcat[ 2 * s1Len + 1 ];

        sprintf(s1SelfConcat, "%s%s", s1, s1);   

        return (strstr(s1SelfConcat, s2) ? 1 : 0);
}

これは、オーバーヘッドのO（n）メモリ使用量を犠牲にして、実行時間に比例します。

（strstr（）の実装はプラットフォーム固有ですが、特に頭の痛い場合は、常にBoyer-Mooreアルゴリズムなどのより高速な代替手段で置き換えることができます）

C＃：

s1 == null && s2 == null || s1.Length == s2.Length && (s1 + s1).Contains(s2)

私は、s2がs1と連結されたs1のサブストリングであるかどうかをチェックする答えが好きです。

その優雅さを失わない最適化を追加したかったのです。

文字列を連結する代わりに、結合ビューを使用できます（他の言語についてはわかりませんが、C ++ではBoost.Rangeがそのようなビューを提供します）。

文字列が別の文字列の部分文字列であるかどうかのチェックは、線形の平均複雑度（最悪の場合の複雑度は二次式）であるため、この最適化は速度を平均で2倍向上させるはずです。

純粋なJavaの回答（nullチェックはありません）

private boolean isRotation(String s1,String s2){
    if(s1.length() != s2.length()) return false;
    for(int i=0; i < s1.length()-1; i++){
        s1 = new StringBuilder(s1.substring(1)).append(s1.charAt(0)).toString();
        //--or-- s1 = s1.substring(1) + s1.charAt(0)
        if(s1.equals(s2)) return true;
    }
    return false;
}

そして今、完全に異なる何かのために。

文字列が互いの回転ではないときに、いくつかの制約されたコンテキストで本当に速い答えが欲しい場合

• 両方の文字列について、文字ベースのチェックサム（すべての文字をxorするなど）を計算します。署名が異なる場合、文字列は相互のローテーションではありません。

同意すると失敗する可能性がありますが、文字列が一致しない場合は非常に高速で、一致する場合は、文字列連結などの別のアルゴリズムを使用して確認できます。

基づいて、他のRubyのソリューションの答え：

def rotation?(a, b); a.size == b.size and (b*2)[a]; end

strlenとstrpos関数を使用してPHPで記述するのは非常に簡単です。

function isRotation($string1, $string2) {
    return strlen($string1) == strlen($string2) && (($string1.$string1).strpos($string2) != -1);
}

strpos内部で何が使用されているかはわかりませんが、KMPを使用している場合、これは時間的に線形になります。

文字列の1つを逆にします。両方のFFTを取ります（それらを整数の単純なシーケンスとして扱います）。結果をポイントごとに乗算します。逆FFTを使用して変換します。文字列が互いの回転である場合、結果は単一のピークになります-ピークの位置は、それらが互いに対してどれだけ回転しているかによって示されます。

なぜこのようなものではないのですか？

//is q a rotation of p?
bool isRotation(string p, string q) {
    string table = q + q;    
    return table.IndexOf(p) != -1;
}

もちろん、独自のIndexOf（）関数を作成することもできます。.NETが単純な方法と高速な方法のどちらを使用しているかはわかりません。

素朴：

int IndexOf(string s) {
    for (int i = 0; i < this.Length - s.Length; i++)
        if (this.Substring(i, s.Length) == s) return i;
    return -1;
}

もっと早く：

int IndexOf(string s) {
    int count = 0;
    for (int i = 0; i < this.Length; i++) {
        if (this[i] == s[count])
            count++;
        else
            count = 0;
        if (count == s.Length)
            return i - s.Length;
    }
    return -1;
}

編集：いくつかの問題があります。確認したくない。;）

私はこれをPerlで行います：

sub isRotation { 
     return length $_[0] == length $_[1] and index($_[1],$_[0],$_[0]) != -1; 
}

int rotation(char *s1,char *s2)
{
    int i,j,k,p=0,n;
    n=strlen(s1);
    k=strlen(s2);
    if (n!=k)
        return 0;
    for (i=0;i<n;i++)
    {
        if (s1[0]==s2[i])
        {
            for (j=i,k=0;k<n;k++,j++)
            {
                if (s1[k]==s2[j])
                    p++;
                if (j==n-1)
                    j=0;
            }
        }
    }
    if (n==p+1)
      return 1;
    else
      return 0;
}

に参加string1しstring2、KMPアルゴリズムを使用してstring2、新しく形成された文字列にが存在するかどうかを確認します。KMPの時間の複雑さはよりも少ないからですsubstr。