Ejercicios C++: Strings (I)

Aquí unos ejercicios en los que usamos strings y todo lo aprendido anteriormente sobre Registros y arrays.

Diseñar un algoritmo (y desarrollar los subalgoritmos C++ correspondientes y el main para probarlo) que permita traducir una cadena numérica al número natural que representa:
Entrada: 7805 (hay que leer el dato como un string)
Salida: 7805 (hay que mostrar el dato como un unsigned)

#include <iostream>
#include <string>


using namespace std;

void leerCadena(string & cadena){
 cout << "Introduce cadena numérica: ";
 cin >> cadena;
}

unsigned potenciaDiez(unsigned exp){
 unsigned resultado=1;
 for(unsigned i = 1; i <= exp; i++){
 resultado = resultado * 10;
 }
 return resultado;
}

void transformar (string cadena, unsigned& num){
 num = 0;
 unsigned n;
 for(unsigned i= 0 ; i < cadena.size(); i++){
  n = (int(cadena[i]))-(int('0'));
  num = num + n * potenciaDiez(cadena.size()-1-i);
 }
}

int main() {
 string cadena;
 unsigned num;
 leerCadena(cadena);
 transformar(cadena, num);
 cout << "El número con el que se corresponde es el: "<< num;
 return 0;
}

Una palabra w es un anagrama de la palabra v, si podemos obtener w cambiando el orden de las letras de v. Por ejemplo, VACA es un anagrama de CAVA.
Diseñar un algoritmo (y desarrollar los subalgoritmos C++ correspondientes y el main para probarlo) que lea un texto y determine de cuántas palabras es anagrama la primera que aparece dentro de dicho texto. Hay que tener en cuenta que:

• El texto contiene un número indefinido de palabras.
• El texto termina con la palabra FIN.
• Cada palabra tiene un número indefinido pero limitado de caracteres (todos alfabético mayúsculas).
• El carácter separador de palabras es el espacio en blanco.

#include <iostream>
#include <string>
using namespace std;


void esAnagrama(string palabra, string texto){
 unsigned contador = 0;
 bool loes = false;
 string aux = texto;
 if(palabra.size() == texto.size()){

  for(unsigned i= 0; i < palabra.size(); i++){

   unsigned j= 0;
   loes = false;


   while(j < texto.size() && loes== false){

     if(palabra[i]== aux[j]){
      loes = true;
      contador++;
      aux[j]= ' ';
     }

    j++;
   }
  }

 }

 if(contador == palabra.size()){
  cout << texto << " es anagrama de "<< palabra << endl;
 }else{
  cout << texto << " no es anagrama de "<< palabra << endl;
 }
}


void introducirTexto(){
 string palabra, texto;
 cout << "Introduce texto: "<< endl;
 getline(cin, palabra, ' ');
 //getline(cin, texto, ' ');
 cin >> texto;
 while(texto != "FIN"){
  esAnagrama(palabra, texto);
  cin >> texto;
 }
}


int main() {
 introducirTexto();
 return 0;
}

Supongamos que deseamos evaluar a un determinado número de alumnos siguiendo el criterio de que aprobará una determinada evaluación aquel que supere o iguale la nota media de la clase en dicha evaluación.
Diseñar un algoritmo (y desarrollar los subalgoritmos C++ correspondientes y el main para probarlo) que lea por teclado un número de alumnos, N_alumnos (como máximo podrá tomar el valor de MAX_ALUMNOS=20), y las notas de tres evaluaciones para cada alumno, N_EVALUACIONES=3, y como resultado emita un informe indicando para cada alumno el resultado de cada evaluación (Aprobado o Suspenso).

#include <iostream>
using namespace std;

const unsigned MAX_ALUMNOS=20;
const unsigned N_EVALUACIONES=3;

typedef double notasAlumno[N_EVALUACIONES];

struct TAlumnos{
 string nombre;
 notasAlumno notas;
};

typedef TAlumnos ArrayAlumnos[MAX_ALUMNOS];

unsigned leerNalumnos(){
 unsigned N_alumnos;
 do{
  cout << "Introduce el número de alumnos (<= "<<MAX_ALUMNOS<<"): ";
  cin >> N_alumnos;
 }while(N_alumnos > MAX_ALUMNOS);
 return N_alumnos;
}

void leerAlumnos(unsigned N_alumnos, ArrayAlumnos& alumnos){
 for(unsigned i=0; i < N_alumnos; i++){

  cout << "Introduce el nombre y 3 notas: ";
   getline(cin, alumnos[i].nombre, ' ');
   for(unsigned j = 0; j < N_EVALUACIONES; j++){
    cin >> alumnos[i].notas[j];
   }
 }
}

double notaMedia (unsigned N_alumnos, const ArrayAlumnos& alumnos, unsigned evaluacion){
 double suma = 0;
 for(unsigned i= 0; i < N_alumnos; i++){
  suma = suma + alumnos[i].notas[evaluacion-1];

 }
 return suma/N_alumnos;
}






void notasAlumnos(unsigned N_alumnos, const ArrayAlumnos& alumnos){
 cout << "Alumno \t Nota 1 \t Nota 2 \t Nota 3" << endl;
 cout << "-------------------------------------------------------";
 for(unsigned i=0; i < N_alumnos; i++){

  cout << alumnos[i].nombre << "\t";

  for(unsigned ev = 1; ev <= N_EVALUACIONES; ev++){
   double media = notaMedia(N_alumnos, alumnos, ev);
   //cout << media << endl;
   if(alumnos[i].notas[ev-1] >= media){
    cout << "Aprobado \t";
   }else{
    cout << "Suspenso \t";
   }

  }

  cout << endl;


 }
}

int main() {
 
 unsigned N_alumnos = leerNalumnos();

 ArrayAlumnos alumnos;
 leerAlumnos(N_alumnos, alumnos);
 notasAlumnos(N_alumnos, alumnos);

 return 0;
}

Diseñar un algoritmo (desarrollando los subalgoritmos C++ correspondientes y el main para probarlo) que se comporte como una calculadora que pida repetidamente un operador de conjuntos y dos operandos que sean conjuntos de letras minúsculas y que escriba el resultado de la operación. Las operaciones se expresan como caracteres, siendo válidas las siguientes:
+ Unión de conjuntos
- Diferencia de conjuntos
* Intersección de conjuntos
El proceso se repetirá hasta que se introduzca como código de operación el carácter ‘&’. Los operadores y el resultado se expresan como cadenas de caracteres. Ejemplo:
Operación = *
Operando1 = azufre
Operando2 = zafio
Resultado = afz
Operación = -
Operando1 = abril
Operando2 = arco
Resultado = bil
Operación = &
FIN

#include <iostream>
#include <string>
using namespace std;

string restaString(string op1, string op2){
 string res;
 bool esta;
 for(unsigned i=0; i < op1.size(); i++){
  esta = false;
  unsigned j = 0;
  while(esta == false && j < op2.size()){
   if(op1[i] == op2[j]){
    esta = true;
   }

   j++;
  }

  if(!esta){
   res = res + op1[i];
  }

 }
 return res;
}

string interseccion(string op1, string op2){
 string res;
  bool esta;
  for(unsigned i=0; i < op1.size(); i++){
   esta = false;
   unsigned j = 0;
   while(esta == false && j < op2.size()){
    if(op1[i] == op2[j]){
     esta = true;
    }

    j++;
   }

   if(esta){
    res = res + op1[i];
   }

  }
  return res;
}

string realizarOperacion(char operacion, string op1, string op2){
 string resultado;
 switch (operacion){
 case '+': resultado = op1 + op2;;
  break;
 case '-': resultado = restaString(op1,op2);
  break;
 case '*': resultado = interseccion(op1, op2);
  break;
 }

 return resultado;
}


void introducirDatos(){
 char operacion;
 string op1, op2;




 do{
 cout << "Operación: ";
 cin >> operacion;
 } while(operacion != '+' && operacion != '-' && operacion != '*' && operacion != '&');

 while(operacion != '&'){
 cout << "Operando 1: ";
 cin >> op1;
 cout << "Operando 2: ";
 cin >> op2;


 string resultado = realizarOperacion(operacion, op1, op2);
 cout << "Resultado: "<< resultado << endl;

 do{
  cout << "Operación: ";
  cin >> operacion;
  } while(operacion != '+' && operacion != '-' && operacion != '*' && operacion != '&');

 if(operacion == '&'){
  cout << "FIN";
 }
 }


}




int main() {
 cout << "Operaciones con strings" << endl; 
 introducirDatos();
 return 0;
}