ocorrencias c#

[alfinete]

private int ContaOcorrenciasStringminha(string original, string parcial)
        {
            int tamanhooriginal = original.Length;//tamanho da string original 
            int tamanhoparcial = parcial.Length; // tamanho da string parcial
            string [] palavra =  new string [tamanhoparcial] ; // array que guarda a string parcial
            string [] textooriginal = new string[tamanhooriginal]; // array que guarda a string original
            int conta_ocorrencias = 0;// guarda o num de ocorrencias
            int txto = 0; // indice da txtoriginal
            int txtp = 0; // indice da txtparcial
            int indice = 0; // gguarda o valor de txtp  para inicializar o for da string parcial


            // poe em cada posição do array o char de cada posição da string parcial
            for (int j = 0; j < tamanhoparcial; j++)
            {
                palavra[j] = parcial.Substring(j,1); 
            
            }

            // poe em cada posição do array o char de cada posição da string original
            for (int k = 0; k < tamanhooriginal ; k++)
            {
                textooriginal [k] = original.Substring(k, 1);

            }


            // percorre a string original
            for ( txto = 0; txto < tamanhooriginal ; txto++)
            {
                    // percorre a string a procurar (parcial)
                    for (txtp = indice; txtp < tamanhoparcial; txtp++)
                    {
                        // caso valor da posicão da original = a valor da string parcial
                        if (textooriginal[txto] == palavra[txtp])
                        {
                            indice = indice + 1;// incremeta indice
                            break;// sai do for
                        }
                      

                    }
                     // caso indice seja igual ao tamanho da string parcial incrementa o num de ocoorrencias
                     // e poe a nuloo indice
                    if (indice == tamanhoparcial)
                    {
                        indice = 0; // poe indice a 0
                        conta_ocorrencias = conta_ocorrencias + 1;// incrementa ocorrencia
                    }
                 
          
            }

            Nocoorencias = conta_ocorrencias;
            return Nocoorencias ;
        }

tenho este metodo feito por mim de raiz , pois é assim que o quero fazer ....

para calcular as ocorrencias de uma string noutra ...

ex

string principal " o alf chama-se alf e é amigo do alf "
string a procurar(parcial) "alf"

sobre este algoritmo as ocorrencias de "alf" na string principal são 3 até ai tedo bem...

mas se a string principal for

string principal = " o alf chama-se alf e é amigo do alf2"

a procurar pelo mesmo "alf" tb dá 3 mas só devia dar 2 --- e ele papa alf como alf2

gostava que me ajudassem a resolver este prob

 

[Baderous]

Se te dá esse resultado, então está a calcular o nº de substrings correctamente. Agora se queres que te dê 2 no último resultado, então a string que queres procurar é " alf " e não "alf".

 

[The_True_Eue]

" alf " (com espaços) resolve aquele problema, mas cria outros. Por exemplo "alf alf alf" só dá um resultado, porque a primeira e a última ocorrências não estão rodeadas por dois espaços.
Pelo que percebi o objectivo é contar ocorrências de palavras, certo?

Se queres ser tu a fazer tudo, experimenta isto:

1. Precisas de definir um conjunto de "separadores", i.e. caracteres que separam palavras, como espaços e sinais de pontuação. Ou então tudo o que não for uma letra.
2. Percorres a string original enquanto for igual à string parcial. Quando encontrares um caracteres diferente, vais para o passo 3. Se chegares ao fim da string parcial, verificas se o caractere seguinte na string original é um separador, ou se chegaste ao fim. Se for esse o caso (separador ou final), contas uma ocorrência. Senão vai para o passo 3.
3. "Saltas" até ao próximo separador na string original ou até ao fim da string.
4. "Saltas" até um caractere que não seja um separador, reinicias o índice que percorre a string parcial, e continuas no passo 2. Se entretanto chegares ao fim da string sais (obviamente).

Se quiseres ajuda para implementar isto, basta dizeres.


P.S.: Encontrei alguns problemas com o teu código:

• O ciclo interior (o que percorre a string parcial) não é necessário. Se um caracter for igual, sais do ciclo. Mas se for diferente continuas. Porquê? Se for diferente devias passar para o seguinte na string original. Assim "axxxxxxlxxxxxf" dá uma ocorrência. É melhor reveres essa parte.
• Para que fazes aqueles ciclos para copiar as strings para arrays de caracteres? Podes fazer isto: original, i.e., tratar a string como um array de caracteres sem fazer mais nada. O que fizeste é completamente desnecessário.
  

 

[joao.miguel]

E que tal fazer um split da string por " ".
Depois percorres o array de strings com um foreach e retornas as ocorrências ?

 

[IComeFromBehind]

char[] wordSeparators = {' ', '\t', '\n'};

boolean match(string original, string partial, int startIndex) {
    int i = startIndex;
    for(int j = 0; i < startIndex + partial.Length; i++, j++)
        if(original[i] != partial[j])
            retrun false;
    if(startIndex + partial.Length == original.Length) {
        return true;
    } else if(startIndex + partial.Length < original.Length) {
        return wordSeparators.Contain(original[startIndex + partial.Length]);
    } else {
        retrun false;
    }
}

int countOcurrencesOfStringInString(string original, string partial) {
    int result = 0;
    for(int i = 0; i < original.Length - partial.length) {
        if(i == 0 || wordSeparators.Contain(original[i]))
            if(match(original, partial, i)) result++;
    }
    return result;
}

Só uma coisa não uses cometários do estilo:
indice = indice + 1;// incremeta indice

Yah eu sei o código tem erros.

 

[alfinete]

 private int CalcOcorr (string original, string parcial)
        {
            int tamanhooriginal = original.Length;
            int tamanhoparcial = parcial.Length ;
            string[] textooriginal = new string[tamanhooriginal]; // array que guarda a string original
            string texto2final = "";
            int i = 0;
            int j = 0;
            int txto = 0; // indice da txtoriginal
            int indice = 0; // gguarda o valor de txtp  para inicializar o for da string parcial

            string[] limitadores = { " ", ",", ".", "!", "&", "?", "(", ")", "{", ":",
             "}", "-" };

            // poe em cada posição do array o char de cada posição da string original
            for (int k = 0; k < tamanhooriginal; k++)
            {
                textooriginal[k] = original.Substring(k, 1);

            }

            for (txto = 0; txto < tamanhooriginal; txto++)
             {
                 // string = limitadores
                 if (textooriginal[txto] == limitadores[i] )
                     texto2final = string.Empty;
                //string diferente de limitadores
                 if (textooriginal[txto] != limitadores[i] )
                    texto2final = texto2final + textooriginal[txto];
                //texto final concatenado = texto parcaial
                if (texto2final == parcial)
                 {
                    indice = indice + 1;
                    texto2final = string.Empty;   
                 }
                 
                
             }

             Nocoorencias = indice;
             return Nocoorencias;
        }

obrigada , ja encontrei uma solução mais simplificada , mas continua com o mesmo bug que a outra

obrigada

agradecia uma ajuda

 

[IComeFromBehind]

public static final Set<Character> wordDelimiters = new HashSet<Character>() {{
        add(' '); add(','); add('.'); add('!'); add('&'); add('?'); add('(');
        add(')'); add('{'); add('}'); add(':'); add('-'); add('\t'); add('\n');
    }};
    
    public static boolean matchInPlace(String original, String partial, int startIndex) {
        int i = startIndex;
        for(int j = 0; j < partial.length(); j++, i++)
            if(original.charAt(i) != partial.charAt(j))
                return false;
        if(i == original.length() || wordDelimiters.contains(original.charAt(i)))
            return true;
        return false;
    }
    
    public static int match(String original, String partial, int startIndex) {
        if(original.length() < startIndex + partial.length())
            return 0;
        else if(startIndex == 0) {
            return (matchInPlace(original, partial, 0) ? 1 : 0) + match(original, partial, 1);
        }
        else if(wordDelimiters.contains(original.charAt(startIndex)))
            return (matchInPlace(original, partial, startIndex + 1) ? 1 : 0) + match(original, partial, startIndex + 2);
        else
            return match(original, partial, startIndex + 1);
    }
    
    public static int countOcurrencesOfStringInString(String original, String partial) {
        return match(original, partial, 0);
    }

 

[Nazgulled]

Não reeinventem a roda... Usem expressões regulares, resolves logo o teu problema com 2 ou 3 linhas.

Só não dou um exemplo porque ainda não percebi ao certo quais são TODOS os casos em que tenho de contar a palavra "alf" e quais são TODOS os casos em que não o devo fazer. Se deres ai vários exemplos de frases e explicares qual a contagem que tem que dar (e porquê) em cada frase, eu tento fazer um exemplo com expressões regulares.