Buenas tardes, tengo que hacer un codigo para determinar las ocurrencias,sin embargo, ya tengo el arreglo de ocurrencias y palabras pero no se como hacer para que cuando vaya imprimir me imprima solo una vez la palabra que este repetida. Cree una estructura para solucionar eso pero no he podido hacer la impresion de forma correcta (el codigo que anexo esta sin la impresión, puesto que no supe hacerla para solo imprimirla una vez). Agradeceria si me ayudan.



#include <iostream>
#include <string.h>
#include<ctype.h>
using namespace std;
struct ocu
{
    string word;
    int ocurrencias=0;
};
void ocurrencia(char Parrafo[],string *Palabras,int *ocurrencias,int &arra_y,struct ocu *ocurren);
int main()
{
    struct ocu *ocurren=new ocu[50];
    int *ocurrencias=new int[50],tamano,arra_y=0,cant=0;
    char Parrafo[500];
    string *Palabras = new string[50];
    cin.getline(Parrafo, sizeof(Parrafo));
    tamano=strlen(Parrafo);
    for(int i=0; i<tamano; i++)
        Parrafo=tolower(Parrafo);
    ocurrencia(Parrafo,Palabras,ocurrencias,arra_y,ocurren);
}

void ocurrencia(char Parrafo[],string *Palabras,int *ocurrencias,int &arra_y,struct ocu *ocurren)
{
    char *ptro,cant=0;
    ptro = strtok(Parrafo, " .,;");
    while (ptro != NULL)
    {
        *(Palabras+arra_y)=ptro;
        ptro = strtok(NULL, " .,;");
        arra_y++;
    }
    for(int i=0; i<arra_y; i++)
        *(ocurrencias+i)=1;

    for(int i=0; i<arra_y; i++)
    {
        for(int j=0; j<arra_y; j++)
        {
            if(*(Palabras+i)==*(Palabras+j))
            {
                if(i==j)
                {}
                else
                    *(ocurrencias+i)= *(ocurrencias+i)+1;
            }
        }
    }
}

Tendrás que cambiar el nombre de las variables que he utilizado por las que estás utilizando tú.

Hola creo que no me entendiste, yo tengo un arreglo de palabras, sin embargo , puedan haber palabras repetidas y solo quiero imprimirla una vez. El codigo que mandaste imprime todas las posiciones del arreglo .Yo lo pense de la siguiente manera.Sí la palabra tiene ocurrencia mayor a 1 recorro el arreglo y borre las palabras q sean iguales(Null) y luego imprimo el arreglo modificado se me acaba de ocurrir voy a intentarlo asi.

Gracias por sus respuestas. Lo termine haciendo asi

 for(int i=0; i<arra_y; i++)
    {
        if(*(ocurrencias+i)>1)
        {
            for(int j=arra_y-1; j>0; j--)
            {
                if(i==j) {}
                else
                {
                    if(*(Palabras+i)==*(Palabras+j))
                    {
                        *(Palabras+j)="0";
                        *(ocurrencias+j)=0;
                    }
                }

            }
        }
    }
    for(int i=0; i<arra_y; i++)
    {
        if(*(Palabras+i)!="0")
        {
            ocurren[cant].word=*(Palabras+i);
            ocurren[cant].ocurrencias=*(ocurrencias+i);
            cant++;
        }

    }
       cout<<endl<<"Palabras && ocurrencias"<<endl;
    for(int i=0; i<cant; i++)
  cout<<ocurren.word<<"  -->"<<ocurren.ocurrencias<<endl;

Operando con arrays (si es obligatorio), hay opciones más eficientes; por ejemplo:

1 - Si el array de origen estuviere ordenado, no seria preciso más que imprimir el ítem y luego ir saltando los siguientes ítems mientras sean iguales al actual.

2 - Por tanto algo muy eficiente es ordenar primero el array si no lo está, y luego proceder con el paso 1.

3 - Recurrir a un array temporal... Se empieza imprimiento la primera palabra y añadiéndola al array B. Luego cuando se quiere imprimir otra palabra se comprueba si se existe en el array B, si no existe se añade al array B. fiamlemente el array B se imprime que solo contiene palabras únicas (también se puede ir imprimiendo sobre la marcha). Este método es más efectivo cuando el array no está ordenado (y no se permite ordenarlo). Resulta tanto más eficiente, cuando más elevado sea el número de repetidos (ese suceso implica pocos ítems en el array B, entre los que buscar cada vez). Debe descartarse si el array de origen fuera gigante, o si el número de repetidos es muy escaso, pués Descartar este método y forzado a usar arrays, implica usar el propio array en sendos bucles, el externo para el ítem actual, el interno para buscar su existencia en los previos. Tiene la desventaja de precisar un array temporal, ocupando más memoria.

4 - Si al caso, para 3, en vez de usar como estructura (temporal) un array, se permite otro tipo de estructura, que permita añadir los ítems ordenados, mejor, pués la búsqueda en esa estructura 'B', podría hacerse mediante una búsqueda binaria (caso de por ejemplo un árbol binario), o mejor una búsqueda atómica (si la estructura elegida fuera una tabla hash).

Por lo mismo si en origen se permite otras estructuras, siempre será más eficiente una tabla hash que cualquier otro método.

Como entiendo que es un ejercicio de algún centro de enseñanza y se trata de un principiante, queda descartado el uso de estructuras complejas (e imagino que posiblemente incluso quede descartado ordenar el array). Así que en tales circunstancias el caso 3 sería el más eficiente... ya que pone a prueba al estudiante en el uso de arrays y algorítmica, que es lo que en definitiva se persigue con el ejercicio.