Pergunta da entrevista: Verifique se uma string é uma rotação de outra string [fechada]

Hoje, um amigo meu fez a seguinte pergunta na entrevista para a posição de desenvolvedor de software:

Dadas duas seqüências s1e s2como você verificará se s1é uma versão rotacionada de s2?

Exemplo:

Se s1 = "stackoverflow", a seguir, estão algumas de suas versões rotacionadas:

"tackoverflows"
"ackoverflowst"
"overflowstack"

onde como não"stackoverflwo" é uma versão rotacionada.

A resposta que ele deu foi:

Pegue s2e encontre o prefixo mais longo que é uma sub-string de s1que fornecerá o ponto de rotação. Depois de encontrar esse ponto, pare s2nesse ponto para obter s2ae s2b, em seguida, verifique seconcatenate(s2a,s2b) == s1

Parece uma boa solução para mim e meu amigo. Mas o entrevistador pensou o contrário. Ele pediu uma solução mais simples. Por favor, ajude-me dizendo como você faria isso Java/C/C++?

Desde já, obrigado.

Primeiro, certifique-se s1e s2tem o mesmo comprimento. Em seguida, verifique se s2há uma subcadeia s1concatenada com 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

Em Java:

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

Certamente, uma resposta melhor seria: "Bem, eu perguntaria à comunidade stackoverflow e provavelmente teria pelo menos 4 respostas realmente boas em 5 minutos". O cérebro é bom e tudo, mas eu daria um valor mais alto a alguém que sabe trabalhar com outras pessoas para obter uma solução.

Outro exemplo de python (com base na resposta):

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

Como outros usuários enviaram uma solução quadrática de complexidade de pior caso, eu adicionaria uma linear (com base no algoritmo 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;
}

exemplo de trabalho

EDIT: A resposta aceita é claramente mais elegante e eficiente do que isso, se você a encontrar. Deixei essa resposta como faria se não tivesse pensado em dobrar a corda original.

Eu apenas a forcei. Verifique primeiro o comprimento e tente todos os desvios de rotação possíveis. Se nenhum deles funcionar, retorne false - se algum funcionar, retorne true imediatamente.

Não há necessidade específica de concatenar - basta usar ponteiros (C) ou índices (Java) e caminhar juntos, um em cada sequência - começando no início de uma sequência e a rotação atual do candidato deslocada na segunda sequência e quebrando sempre que necessário . Verifique a igualdade de caracteres em cada ponto da sequência. Se você chegar ao final da primeira string, estará pronto.

Provavelmente seria tão fácil concatenar - embora provavelmente menos eficiente, pelo menos em Java.

Aqui está um usando regex apenas por diversão:

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

Você pode simplificar um pouco se puder usar um caractere delimitador especial garantido para não estar em nenhuma das cadeias.

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

Você também pode usar lookbehind com repetição finita:

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

Whoa, whoa ... por que todo mundo está tão emocionado com uma O(n^2)resposta? Estou certo de que podemos fazer melhor aqui. A resposta acima inclui uma O(n)operação em um O(n)loop (a chamada substring / indexOf). Mesmo com um algoritmo de pesquisa mais eficiente; digamos Boyer-Mooreou KMP, o pior caso ainda éO(n^2) com duplicatas.

Uma O(n)resposta aleatória é direta; use um hash (como uma impressão digital de Rabin) que suporte umO(1) janela deslizante; hash string 1, hash string 2 e continue movendo a janela do hash 1 ao redor da string e veja se as funções hash colidem.

Se imaginarmos que o pior caso é algo como "escanear duas fileiras de DNA", a probabilidade de colisões aumenta, e isso provavelmente degenera para algo como O(n^(1+e)) ou algo (apenas adivinhe aqui).

Finalmente, há uma O(nlogn)solução determinística que tem uma constante muito grande fora. Basicamente, a idéia é levar uma convolução das duas cordas. O valor máximo da convolução será a diferença de rotação (se forem giradas); uma O(n)verificação confirma. O bom é que, se houver dois valores máximos iguais, os dois também serão soluções válidas. Você pode fazer a convolução com dois FFTs e um produto de ponto, e um iFFT, portanto nlogn + nlogn + n + nlogn + n == O(nlogn).

Como você não pode preencher com zeros e não pode garantir que as seqüências tenham 2 ^ n de comprimento, as FFTs não serão as mais rápidas; eles serão os lentos, aindaO(nlogn) uma constante muito maior que o algoritmo CT.

Tudo isso dito, estou absolutamente, 100% positivo de que existe uma O(n)solução determinística aqui, mas que se consiga encontrá-la.

Punho, verifique se as duas cordas têm o mesmo comprimento. Em C, você pode fazer isso com uma iteração simples do ponteiro.

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);
}

Aqui está um O(n)algoritmo existente. Ele usa <operador para os elementos das strings. Não é meu, é claro. Peguei a partir daqui (o site está em polonês. Encontrei uma vez no passado e não consegui encontrar algo assim agora em inglês, então mostro o que tenho :)).

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;
}

Eu acho que é melhor fazer isso em Java:

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

No Perl eu faria:

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

ou melhor ainda, usando a função index em vez da expressão regular:

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

Não tenho certeza se esse é o método mais eficiente, mas pode ser relativamente interessante : a transformação Burrows-Wheeler . De acordo com o artigo WP, todas as rotações da entrada produzem a mesma saída. Para aplicações como compactação, isso não é desejável, portanto a rotação original é indicada (por exemplo, por um índice; consulte o artigo). Mas, para uma comparação simples independente da rotação, parece ideal. Obviamente, não é necessariamente idealmente eficiente!

Tome cada personagem como uma amplitude e realize uma transformação discreta de Fourier neles. Se diferirem apenas por rotação, os espectros de frequência serão os mesmos do erro de arredondamento. Claro que isso é ineficiente, a menos que o comprimento seja uma potência de 2, para que você possa executar uma FFT :-)

Ninguém ofereceu uma abordagem de módulo ainda, então aqui está uma:

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;
}

Resultado:

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

[EDIT: 12-04-2010]

O piotr notou a falha no meu código acima. Ele erros quando o primeiro caractere na seqüência ocorre duas ou mais vezes. Por exemplo, stackoverflowtestado contraowstackoverflow em resultado de falso, quando deveria ser verdade.

Obrigado piotr por detectar o erro.

Agora, aqui está o código corrigido:

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

Aqui está a saída:

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

Aqui está a abordagem lambda:

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

Aqui está a saída da abordagem lambda:

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

Como ninguém deu uma solução em C ++. aqui está:

bool isRotation(string s1,string s2) {

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

O truque simples de rotação do ponteiro do Opera funciona, mas é extremamente ineficiente na pior das hipóteses em tempo de execução. Simplesmente imagine uma string com muitas execuções repetidas longas de caracteres, ou seja:

S1 = HELLOHELLOHELLO1HELLOHELLOHELLO2

S2 = HELLOHELLOHELLO2HELLOHELLOHELLO1

O "loop até que haja uma incompatibilidade, depois incremente um e tente novamente" é uma abordagem horrível, computacionalmente.

Para provar que você pode executar a abordagem de concatenação em C simples sem muito esforço, eis a minha solução:

  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);
}

Isso é linear no tempo de execução, às custas do uso de memória O (n) em sobrecarga.

(Observe que a implementação de strstr () é específica da plataforma, mas se é particularmente fatal, sempre pode ser substituída por uma alternativa mais rápida, como o algoritmo de Boyer-Moore)

C #:

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

Eu gosto da resposta que verifica se s2 é uma subcadeia de s1 concatenada com s1.

Eu queria adicionar uma otimização que não perdesse sua elegância.

Em vez de concatenar as strings, você pode usar uma visualização de junção (não sei para outro idioma, mas o C ++ Boost.Range fornece esse tipo de visualização).

Como a verificação de uma cadeia de caracteres é uma substring de outra possui complexidade média linear (a pior complexidade é quadrática), essa otimização deve melhorar a velocidade em um fator de 2 em média.

Uma resposta Java pura (sem verificações nulas)

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;
}

E agora para algo completamente diferente.

Se você deseja uma resposta realmente rápida em algum contexto restrito, quando as strings não são rotativas uma da outra

• calcule alguma soma de verificação baseada em caracteres (como xoring todos os caracteres) em ambas as strings. Se as assinaturas diferem, as seqüências de caracteres não são rotações uma da outra.

Concordado, ele pode falhar, mas é muito rápido dizer se as strings não correspondem e se elas correspondem, você ainda pode usar outro algoritmo, como concatenação de strings, para verificar.

Outra solução rubi baseado na resposta:

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

É muito fácil escrever em PHP usando strlene strposfunções:

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

Não sei o que strposusa internamente, mas se ele usa o KMP, isso será linear no tempo.

Inverta uma das cordas. Tome a FFT de ambas (tratando-as como sequências simples de números inteiros). Multiplique os resultados juntos por pontos. Transforme de volta usando FFT inverso. O resultado terá um único pico se as seqüências de caracteres forem rotações uma da outra - a posição do pico indicará o quanto elas são rotacionadas uma em relação à outra.

Por que não algo assim?

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

Obviamente, você poderia escrever sua própria função IndexOf (); Não tenho certeza se o .NET usa uma maneira ingênua ou mais rápida.

Ingênuo:

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;
}

Mais rápido:

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;
}

Editar: Eu posso ter alguns problemas isolados; não sinto vontade de checar. ;)

Eu faria isso em 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;
}

Associe string1-se string2e use o algoritmo KMP para verificar se string2está presente na string recém-formada. Como a complexidade temporal do KMP é menor que substr.