Ejercicios C++: procedimientos, funciones y recursividad (II)

¡Hola! Vuelvo con otra entrada de C++ para repasar tanto los procedimientos y funciones y el paso de parámetros a estos como la recursividad. Si os interesa practicar estos temas os recomiendo que además de ver esta entrada, os paséis por ésta  sobre procedimientos y ésta sobre recursividad publicadas hace unos días. Os dejo los ejercicios resueltos ;)

Escribe un programa que lea un número natural N por teclado y dibuje un triángulo de
asteriscos con base y altura N. Por ejemplo si N=5 debería dibujarse:

#include <iostream>
using namespace std;

void leerDatos(unsigned& x){
 int n;
 do{
  cout << "Introduce altura de la pirámide: ";
  cin >> n;
 }while( n < 1);
 x = n;
}

void dibujarFila(unsigned x, unsigned i){
 for(unsigned j = 1; j <= (x-i); j++){
  cout << " ";
 }
 for(unsigned j = 1; j<= i; j++){
  cout << "* ";
 }
 for(unsigned j = 1; j <= (x-i); j++){
  cout << " ";
 }
}

void dibujarPiramide (unsigned x){
 for(unsigned i = 1; i <= x; i++){
  dibujarFila(x, i);
  cout << endl;
 }
}

int main() {
 unsigned x;
 leerDatos(x);
 dibujarPiramide(x);
 return 0;
}

Escriba un programa que tome como entrada desde teclado dos números naturales (mayores
que cero) "N" e "i", e imprima en pantalla el dígito que ocupa la posición i-ésima del número
N. Si i es mayor que el número de dígitos de N, se escribirá en pantalla -1. Por ejemplo, para N
= 25064 e i = 2, el resultado es el dígito 6, y para i = 7, el resultado es -1.

#include<iostream>
#include <math.h>
using namespace std;

void introducirDatos(unsigned& N, unsigned& i){
 cout << "Introduce N  (>0) : ";
 cin >> N;
 cout << "Introduce i  (>0) : ";
 cin >> i;
}
int calcularDigito(unsigned N, unsigned i){
 int num;
 num = N /(pow( 10,(i-1)  ));
 if(num == 0){
  num = -1;
 }else{
  num = num%10;
 }
 return num;
}



int main() {
 unsigned N, i;
 cout << "Programa que imprime en pantalla el dígito que ocupa la posición i-ésima del número N."<< endl;
 introducirDatos(N, i);
 cout << "Resultado: " << calcularDigito(N, i);


 return 0;
}

Escribe un programa que acepte como entrada desde teclado un número natural mayor que cero
y dé como salida el resultado de sumar dos a dos los dígitos que aparecen en posiciones
simétricas respecto al dígito central dentro del número dado como entrada. Por ejemplo :
para el número : 2354869
la salida es: 2+9 = 11, 3 + 6 = 9, 5 + 8 = 13, 4
para el número : 6582
la salida es : 6 + 2 = 8, 5 + 8 = 13

#include <iostream>
using namespace std;

void introducirDatos(unsigned& N){
 cout << "Introduce N  (>0) : ";
 cin >> N;
}

unsigned longitudNumero(unsigned num){
 unsigned contador = 0;
 while(num!= 0){
  num = num/10;
  contador++;
 }
 return contador;
}
unsigned potencia(int a,int b) { //potencia(10, 3)
 unsigned resultado = 1;
 if(b == 1){
  resultado = a;
 } else if (b > 1){
  for(int i = 1; i <= b; i++){
   resultado = resultado * a;
  }
 }
 return resultado;
}

int calcularDigito(unsigned N, unsigned i){
 int num;
 num = N /(potencia( 10,(i-1)  ));
 if(num == 0){
  num = -1;
 }else{
  num = num%10;
 }
 return num;
}

void Sumar(unsigned N){
 unsigned longitud = longitudNumero(N);
 unsigned long2= longitud;

 unsigned suma;
 for(int i =1; i <= int(longitud/2); i++){
  suma = calcularDigito(N, i) + calcularDigito (N, long2);
  cout << calcularDigito (N, long2)<< "+" << calcularDigito(N, i)   <<"=" << suma << " ";
  long2 --;
 }
 if(longitud%2 != 0){
  cout << calcularDigito(N, unsigned(longitud/2)+1 );
 }
}




int main() {
 unsigned N;
 introducirDatos(N);
 Sumar(N);


 return 0;
}

Decimos que una sucesión a1,a2,...,an de enteros forma una montaña, si existe un h tal
que : 1 <= h <= n y además
a1 < ...ah-1 < ah > ah+1 > ...an
Definimos la longitud de una montaña como el número de enteros que la forman. Por ejemplo
la sucesión -7, -1, 6, 21, 15 es una montaña de longitud 5.
Definimos un valle de la misma forma que una montaña pero cambiando el signo de las
desigualdades de la definición anterior:
a1 > ...ah-1 > ah < ah+1 < ...an
Por ejemplo 24, 13, 6, 15, 50 sería un valle.
Dada una secuencia de enteros terminada en cero (0) que como mínimo contiene una montaña
y un valle (suponemos que la secuencia de enteros de entrada es una secuencia correcta de
montañas y valles), diseña un programa que calcule la longitud de la montaña y el valle más
largos.

#include<iostream>
using namespace std;


void leerNumero(int& mmontana, int& mvalle){
 int num, ant=0;
 int montana =0;
 int valle = 0;
 mmontana =0;
 mvalle =0;
 int antant=0;
 cout << "Introduce: "<<endl;
 cin >> num;
 while(num!= 0){
  if(num < ant && antant < ant){
   valle = 2;
  }else{
   valle++;
   if(mvalle < valle){
    mvalle = valle;
   }
  }
  if(num > ant && antant > ant){
   montana =1;

  }else{
   montana++;
   if(mmontana < montana){
    mmontana = montana;
   }
  }
  antant = ant;
  ant= num;
  cin >> num;
 }
}

int main() {
 int mmontana;
 int mvalle;
 leerNumero(mmontana, mvalle);
 cout <<"Mayor montaña: "<< (mmontana+1) << endl;
 cout << "Mayor valle: "<< mvalle;
 return 0;
}

El máximo común divisor (mcd) de dos números naturales p y q es el mayor entero d que
divide a ambos. Un algoritmo muy conocido para calcularlo es el de Euclides. Éste utiliza
dos variables, que contienen inicialmente a cada uno de los números, y trata de hacer que su
contenido sea el mismo. Para ello, irá restando la menor a la mayor hasta que ambas
contengan el mismo valor. En dicho momento, el valor obtenido en cualquiera de ellas es el
máximo común divisor de los dos números iniciales. Por ejemplo, si P = 18 y Q = 12, el
algoritmo hará que P y Q vayan tomando los siguientes valores:
Inicialmente P == 18 y Q == 12 (P > Q => P = P - Q)
Después P == 6 y Q == 12 (Q > P => Q = Q - P)
Después P == 6 y Q == 6 (P == Q => El mcd es 6)
Diseña el algoritmo anterior siguiendo un enfoque recursivo:
unsigned mcd(unsigned P, unsigned Q)

#include <iostream>
using namespace std;

unsigned mcd(unsigned P, unsigned Q){
 unsigned res;
 if(P == Q){
  res = P;
 }else{
  if(P > Q){
   res = mcd(P - Q, Q);
  }else{
   res = mcd(P, Q - P );
  }
 }
 return res;
}

int main() {
 unsigned P, Q;
 cout << "Máximo común divisor. " << endl; // prints !!!Hello World!!!
 cout << "Introduce dos naturales: ";
 cin >> P >> Q;
 cout << "El mcd es "<< mcd(P,Q);
 return 0;
}

Diseña un procedimiento recursivo que lea una secuencia de caracteres de longitud arbitraria
terminada en un punto, y la imprima en orden inverso. El procedimiento no tiene parámetros.

#include <iostream>
using namespace std;

void invertirTexto(){
 char a;
 cin.get(a);
 if(a == '.'){

 }else{
  invertirTexto();
  cout << a;
 }
}

int main() {
 cout << "Introduce texto a invertir terminado en punto." << endl; // prints !!!Hello World!!
 invertirTexto();
 return 0;
}

Y hasta aquí la entrada de hoy ;)