dándole vueltas a un problemilla c++ necesito un poco de ayuda

Iniciado por el gusanillo, 5 Junio 2018, 09:58 AM

0 Miembros y 1 Visitante están viendo este tema.

el gusanillo

Buenos días, estoy haciendo este ejercicio de c++ y me he atascado.Dice así:

Escribir un programa que dado un array de 10 caracteres (introducidos a mano en el código)calcule cuantas veces aparecen dos caracteres iguales seguidos, considerando que un carácter no puede pertenecer a dos parejas.

#include<stdio.h>
#include.conio.h>
int main()
{
int x,contador=0;
for(x=0;x<10;x++)//bucle para recorrer el array
{
/*si el carácter en la posición x es igual al carácter en la posición x+1 incrementamos contador en 1 unidad y descartamos el próximo carácter por pertenecer a una pareja
Caracteres: P  A  R  E  J J  A
Indices:     0 1  2  3  4     6  */
if(Caracteres
  • ==Caracteres[x+1])
    {
    Contador++;
    x++;
    }
    }

    Esto es lo que llevo. A ver si me podeis echar una mano.

    Un saludo y gracias.


SrMcLister

#1
Buenas el problema de tu código sería que no compruebas si esa pareja ya ha existido anteriormente, está muy bien pero te faltaría eso...
Aquí te dejo un código que he hecho referente a tu tarea
Espero que te ayude.

Código (cpp) [Seleccionar]

#include <iostream>
using namespace std;

bool noEncontrado(char letra, const char usadas[], int longitud){
   for(int i=0;i<longitud;i++)
       if(letra==usadas[i])
           return false;
   return true;
}


int main(int argc, char const *argv[]){

   const int MAXLETRAS=10;
   int contadorusadas=0;
   char palabra[MAXLETRAS] = {'A','A','D','F','A','A','S','S','R','U'};
   char usadas[MAXLETRAS];

   for(int i=0;i<MAXLETRAS;i++){
       if(palabra[i]==palabra[i+1])
           if(noEncontrado(palabra[i],usadas,contadorusadas)){
               usadas[contadorusadas]=palabra[i];
               contadorusadas++;
           }
   }
   
    cout << "Han aparecido " << contadorusadas << " letras con parejas" << endl;
   cout << "Letras con parejas encontradas" << endl;
   for(int i=0;i<contadorusadas;i++) cout << usadas[i] << endl;
   return 0;
}


PD: Acostumbrate a poner el código entre etiquetas propias de código.
Un saludo.
Código (cpp) [Seleccionar]

return((u.areHappy() && u.knowIt()) ? u.clapYourHands() : u.goFuckYourself());

el gusanillo

Buenas tardes, lo primero darle las gracias por la ayuda. Me he puesto a darle caña y de paso he escrito el programa que me envió y me da fallo en la compilación de la linea 20. Sigo dándole vueltas porque no me parece un ejercicio sencillo,creo que tiene miga.

Un saludo

SrMcLister

Buenas gusanillo.
A ver, te comento...
Lo primero, ¿me podrías especificar el error que te da al compilar?;He compilado el mismo código que te he puesto y me sale perfecto.
Segundo, ¿a que te refieres que sigues dándole vueltas? el ejercicio es simple. Dado un array de caracteres, encontrar parejas, la miga reside en que si encuentras una pareja ya se pone como "usada", o en este caso, entra al array de usadas.
Un saludo.
Código (cpp) [Seleccionar]

return((u.areHappy() && u.knowIt()) ? u.clapYourHands() : u.goFuckYourself());

MAFUS

#4
Un ejemplo en C.
Verás que solo es moverse por el array y las parejas son el elemento actual y el siguiente. Para evitar que un elemento se cuente dos veces seguidas se hace un salto manual.
#include <stdio.h>

int main() {
   char array[] = "AMESDIFPPDKEJSDDDJKPPPP";

   // Esto es para cualquier tipo de array unidimensional
   unsigned parejas = 0;
   size_t n_elementos = sizeof(array)/sizeof(array[0]);
   for(size_t i=0; i<n_elementos-1; ++i) { // el -1 es para no salirme del array después
       if(array[i]==array[i+1]) {
           ++i; // Esto hace que un elemento no pertenezca a dos parejas
           ++parejas;
       }
   }
   printf("Hay %d parejas de caracteres", parejas);
}

Beginner Web

Código (cpp) [Seleccionar]

#include <iostream>
#include <string.h>

using namespace std;

const int MAX=10;
typedef char tarreglo[MAX];

void cargar_arreglo(tarreglo &n, int &ocupado);
void mostrar_arreglo(tarreglo n, int ocupado);
void calcular_parejas(tarreglo n, int ocupado);

int main()
{
tarreglo palabra;
int lleno=0;
cargar_arreglo(palabra, lleno);
mostrar_arreglo(palabra, lleno);
calcular_parejas(palabra, lleno);
system("pause");
return 0;
}

void cargar_arreglo(tarreglo &n, int &ocupado)
{
for(int i=0; i<MAX; i++){
cout << "Ingrese caracter(0 para finalizar): ";
cin >> n[i];
if(n[i]=='0'){
break;
}
ocupado++;
}
}

void mostrar_arreglo(tarreglo n, int ocupado)
{
for(int i=0; i<ocupado; i++){
cout << n[i];
}
cout << endl;
}

void calcular_parejas(tarreglo n, int ocupado)
{
int parejas=0;
for(int i=0; i<ocupado; i++){
if(n[i]==n[i+1]){
parejas++;
i++;
}
}
cout << "Parejas: " << parejas << endl;
}
7w7

dijsktra

A ver, gusanillo, este problema ya lo preguntaste aquí ( y creo que resuelto)

https://foro.elhacker.net/programacion_cc/buenos_diastengo_muchas_dudas_con_un_ejercicio_de_caracteres-t480917.0.html;msg2155561#msg2155561

Si ponemos "caracteres adyacentes por parejas" o algo similar en el tema, podremos localizarlo mejor
Si la depuración es el proceso de eliminar fallos en el software, entonces programar debe ser el proceso de ponerlos dentro. (Edsger Dijsktra)

Serapis

Quizás no le parezca solucionado, porque no obedece a lo que él espera, y en tal caso, lo que falla es su especificación de pareja.

En teoría es pareja si dos caracteres son adyacentes, así: "carro" tiene una pareja de "r", pero, ...luego señala que "si ya pertenece a una pareja no puede pertenecer a otra"... esto resulta ambiguo, porque puede interpretarse de diferentes maneras, y no queda claro, cual es de su interés...:

Ejemplo 1: "carrro", al llevar 3 'r' serían dos parejas, pero parece encajar en la restricción impuesta, luego si aparece una pareja, trió, cuarteto, etc... equivale a solo una pareja?

Ejemplo 2: "el carro arrolló al peatón", en teoría hay 3 parejas "r", "r" y "l". Nuevamente la pregunta es, encaja en la restricción impuesta?. Es decir ¿si la "r" ya forma parte de una pareja, no se cuenta de nuevo si forma parte de otras parejas en lo sucesivo?.

Según el planteamiento, exige soluciones distintas. Qué especifique con claridad la consideración de pareja... puede que así tenga solucionado su problema o aún no.

dijsktra

Cita de: NEBIRE en 13 Junio 2018, 20:05 PM
Quizás no le parezca solucionado, porque no obedece a lo que él espera, y en tal caso, lo que falla es su especificación de pareja.[...]

Según el planteamiento, exige soluciones distintas. Qué especifique con claridad la consideración de pareja... puede que así tenga solucionado su problema o aún no.

Exacto!,  ;-)  esa es la cuestión. Especificar sin ambigüedad. Por eso yo intento siempre dar una especificación formal, sin ambigüedades. Mi propuesta era:

/*


  P : N >= 0
  Q : count = #i : 0 <= i < N-1: twin(V,N,i)

  where twin(V,N,i) ::= V[i]==V[i+1]) &&
                        ((i==0) ||
                        ((i>0) and V[i]!=V[i-1]) ||
                        (i>1) and V[i-1]==V[i-2])

*/


"Ahí" dice que un caracter es adyacente (twin no es la palabra mejor, en fin...) al siguiente  V[n]==V[n+1]) si no está atado ya inmediatamente anterior V[n]!=V[n-1]. Es posible que no esté atado (aun siendo igual) si ya el anterior estaba atada al anterior del anterior...El razonamiento se aplica a cualquiera, menos al primero (n == 0)  que no tiene anterior"

Uno puede estar de acuerdo con ella o no, (las definiciones se proponen, pero no se demuestran) pero si se escoje, el programa dado en

https://foro.elhacker.net/programacion_cc/buenos_diastengo_muchas_dudas_con_un_ejercicio_de_caracteres-t480917.0.html;msg2155561#msg2155561


cumple lo que se le pide.
Si la depuración es el proceso de eliminar fallos en el software, entonces programar debe ser el proceso de ponerlos dentro. (Edsger Dijsktra)

MAFUS

Yo entendí, y así lo plasmé en el código es que si hay tres letras iguales seguidas por orden de lectura las dos primeras forman pareja, como la de en medio ya se ha usado para pareja no puede juntarse con la que le sigue, con lo que la segunda y la tercera no forman pareja.
Pero si hubiera 4, y siguiendo el razonamiento anterior, la tercera sí formaría pareja con la cuarta. La tercera no ve a la segunda, por formar ésta última una pareja con otra, pero si ve la última y por tanto se empareja.
Siguiendo el razonamiento anterior, si hubiera 5 la última no formaría pareja.