Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find('@') == std::string::npos || mail.find('.com') == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante dado de alta con éxito." << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un método `altaEstudiante()` que solicita la información del estudiante y la valida según las reglas establecidas. Si la información no cumple con las reglas, el programa solicita que se ingrese nuevamente. Finalmente, muestra la información del estudiante en la consola.
Aquí te dejo un ejemplo de código en C++ que crea una matriz de 10x10 para jugar a Pacman con 2 enemigos y permite controlar al personaje con las teclas W, A, S, y D. El juego también cuenta con 2 vidas.
```cpp
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <windows.h>
using namespace std;
const int FILAS = 10;
const int COLUMNAS = 10;
const int VIDA = 2;
// Estructura para representar la posición del personaje
struct Posicion {
int x, y;
};
// Estructura para representar la posición de los enemigos
struct Enemigo {
int x, y;
};
// Matriz para representar el tablero
char tablero[FILAS][COLUMNAS];
// Posición inicial del personaje
Posicion pacman = {5, 5};
// Posición inicial de los enemigos
Enemigo enemigo1 = {3, 3};
Enemigo enemigo2 = {7, 7};
// Puntuación
int puntuacion = 0;
// Vidas
int vidas = VIDA;
// Función para dibujar el tablero
void dibujarTablero() {
for (int i = 0; i < FILAS; i++) {
for (int j = 0; j < COLUMNAS; j++) {
if (i == pacman.y && j == pacman.x) {
cout << "P ";
} else if (i == enemigo1.y && j == enemigo1.x) {
cout << "E1 ";
} else if (i == enemigo2.y && j == enemigo2.x) {
cout << "E2 ";
} else {
cout << ". ";
}
}
cout << endl;
}
}
// Función para mover el personaje
void moverPacman(int dx, int dy) {
if (pacman.x + dx >= 0 && pacman.x + dx < COLUMNAS && pacman.y + dy >= 0 && pacman.y + dy < FILAS) {
pacman.x += dx;
pacman.y += dy;
}
}
// Función para verificar colisión con los enemigos
bool verificarColision() {
if (pacman.x == enemigo1.x && pacman.y == enemigo1.y) {
return true;
} else if (pacman.x == enemigo2.x && pacman.y == enemigo2.y) {
return true;
}
return false;
}
// Función para verificar si el personaje está en una posición válida
bool verificarPosicion() {
if (pacman.x < 0 || pacman.x >= COLUMNAS || pacman.y < 0 || pacman.y >= FILAS) {
return false;
}
return true;
}
int main() {
srand(time(0));
for (int i = 0; i < FILAS; i++) {
for (int j = 0; j < COLUMNAS; j++) {
tablero[i][j] = '.';
}
}
while (vidas > 0) {
system("cls");
dibujarTablero();
cout << "Puntuación: " << puntuacion << endl;
cout << "Vidas: " << vidas << endl;
char tecla;
cout << "Presione W para mover hacia arriba, A para mover hacia la izquierda, S para mover hacia abajo, D para mover hacia la derecha: ";
cin >> tecla;
switch (tecla) {
case 'w':
moverPacman(0, -1);
break;
case 'a':
moverPacman(-1, 0);
break;
case 's':
moverPacman(0, 1);
break;
case 'd':
moverPacman(1, 0);
break;
}
if (verificarColision()) {
vidas--;
cout << "¡Colisión con un enemigo! Perdiste una vida." << endl;
Sleep(1000);
}
if (!verificarPosicion()) {
cout << "¡Fuera de la matriz! Perdiste una vida." << endl;
vidas--;
Sleep(1000);
}
if (pacman.x == 0 || pacman.x == COLUMNAS - 1 || pacman.y == 0 || pacman.y == FILAS - 1) {
puntuacion += 10;
cout << "¡Llegaste a la pared! Ganaste 10 puntos." << endl;
Sleep(1000);
}
}
system("cls");
cout << "¡Juego terminado! Tu puntuación final es: " << puntuacion << endl;
return 0;
}
```
Este código crea un tablero de 10x10 y permite controlar al personaje con las teclas W, A, S, y D. El juego cuenta con 2 enemigos y 2 vidas. El personaje puede ganar puntos al llegar a la pared del tablero. Si el personaje colisiona con un enemigo o sale de la matriz, pierde una vida. El juego termina cuando el personaje pierde todas sus vidas.
Aquí te dejo un ejemplo de código en C++ que calcula el promedio general de un grupo de 10 personas, donde cada persona tiene una calificación asociada. Utiliza la función `string` para almacenar los nombres de las personas.
```cpp
#include <iostream>
#include <string>
#include <vector>
// Estructura para almacenar la información de cada persona
struct Persona {
std::string nombre;
double calificacion;
};
int main() {
// Vector para almacenar las personas
std::vector<Persona> personas;
// Pedir la información de cada persona
for (int i = 0; i < 10; i++) {
Persona persona;
std::cout << "Ingrese el nombre de la persona " << i + 1 << ": ";
std::cin >> persona.nombre;
std::cout << "Ingrese la calificación de la persona " << i + 1 << ": ";
std::cin >> persona.calificacion;
// Agregar la persona al vector
personas.push_back(persona);
}
// Calcular el promedio general
double sumaCalificaciones = 0;
for (const auto& persona : personas) {
sumaCalificaciones += persona.calificacion;
}
double promedioGeneral = sumaCalificaciones / personas.size();
// Mostrar el promedio general
std::cout << "El promedio general de las calificaciones es: " << promedioGeneral << std::endl;
// Mostrar las calificaciones de cada persona
std::cout << "Calificaciones de cada persona:" << std::endl;
for (const auto& persona : personas) {
std::cout << persona.nombre << ": " << persona.calificacion << std::endl;
}
return 0;
}
```
Este código utiliza una estructura `Persona` para almacenar la información de cada persona, incluyendo su nombre y calificación. Luego, utiliza un vector para almacenar las personas y pedir la información de cada una de ellas. Finalmente, calcula el promedio general de las calificaciones y lo muestra en pantalla, junto con las calificaciones de cada persona.
Recuerda que debes compilar y ejecutar el código en un entorno de desarrollo como Visual Studio o un compilador de línea de comandos como `g++`.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname) {
this->nombre = nombre;
this->telefono = telefono;
this->mail = mail;
this->numeroReo = numeroReo;
this->nickname = nickname;
}
// Método para verificar si el correo electrónico es válido
bool verificarCorreo(std::string mail) {
return mail.find("@") != std::string::npos && mail.find(".com") != std::string::npos;
}
// Método para verificar si el número de reo es válido
bool verificarNumeroReo(std::string numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para verificar si el nombre es válido
bool verificarNombre(std::string nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para registrar al estudiante
void registrarEstudiante() {
std::string nombre, telefono, mail, numeroReo, nickname;
// Pedir los datos al usuario
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (!verificarNombre(nombre)) {
std::cout << "El nombre no puede contener números. Por favor, ingrese el nombre nuevamente: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
while (!verificarCorreo(mail)) {
std::cout << "El correo electrónico no es válido. Por favor, ingrese el correo electrónico nuevamente: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!verificarNumeroReo(numeroReo)) {
std::cout << "El número de reo no es válido. Por favor, ingrese el número de reo nuevamente: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
// Crear un objeto Estudiante con los datos ingresados
Estudiante estudiante(nombre, telefono, mail, numeroReo, nickname);
// Mostrar los datos del estudiante
std::cout << "Estudiante registrado con éxito:" << std::endl;
std::cout << "Nombre: " << estudiante.nombre << std::endl;
std::cout << "Teléfono: " << estudiante.telefono << std::endl;
std::cout << "Correo electrónico: " << estudiante.mail << std::endl;
std::cout << "Número de reo: " << estudiante.numeroReo << std::endl;
std::cout << "Nickname: " << estudiante.nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.registrarEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un constructor que toma los datos del estudiante como parámetros. La clase también tiene métodos para verificar si el correo electrónico y el número de reo son válidos. El método `registrarEstudiante` pide los datos al usuario, verifica que sean válidos y crea un objeto `Estudiante` con los datos ingresados. Finalmente, muestra los datos del estudiante.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find('@') == std::string::npos || mail.find('.com') == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante creado con éxito!" << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
En este código, la clase `Estudiante` tiene un método `altaEstudiante()` que solicita la información del estudiante y la valida según las reglas establecidas. Si la información no cumple con las reglas, el programa solicita que se ingrese nuevamente. Finalmente, el programa muestra la información del estudiante creado con éxito.
Aquí te dejo un ejemplo de código en C++ que implementa la secuencia de Fibonacci utilizando un bucle `while`:
```cpp
#include <iostream>
int main() {
int n, i = 0, j = 1, k = 0;
std::cout << "Ingrese el número de términos para la secuencia de Fibonacci: ";
std::cin >> n;
if (n <= 0) {
std::cout << "Error: El número de términos debe ser positivo.";
return 1;
}
std::cout << "Secuencia de Fibonacci: ";
while (k < n) {
std::cout << k << " ";
i = j;
j = k;
k = i + j;
}
return 0;
}
```
En este código, se pide al usuario que ingrese el número de términos para la secuencia de Fibonacci. Luego, se utiliza un bucle `while` para generar la secuencia. En cada iteración, se imprime el valor actual de `k`, y luego se actualizan los valores de `i`, `j` y `k` para la siguiente iteración.
La secuencia de Fibonacci es una secuencia de números en la que cada término es la suma de los dos términos anteriores. La secuencia comienza con 0 y 1, y luego se genera de la siguiente manera:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, ...
Espero que esto te ayude. ¡Si tienes alguna pregunta o necesitas más ayuda, no dudes en preguntar!
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find('@') == std::string::npos || mail.find('.com') == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante dado de alta con éxito." << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un método `altaEstudiante()` que solicita la información del estudiante y la valida según las reglas establecidas. Si la información no cumple con las reglas, el programa solicita que se ingrese nuevamente. Finalmente, muestra la información del estudiante en la consola.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
for (char c : nombre) {
if (!std::isalpha(c)) {
std::cout << "El nombre no puede contener números. Por favor, ingrese un nombre válido." << std::endl;
return;
}
}
this->nombre = nombre;
}
void setTelefono(const std::string& telefono) {
for (char c : telefono) {
if (!std::isdigit(c)) {
std::cout << "El teléfono debe contener solo números. Por favor, ingrese un teléfono válido." << std::endl;
return;
}
}
this->telefono = telefono;
}
void setMail(const std::string& mail) {
size_t posAt = mail.find('@');
size_t posDot = mail.find('.');
if (posAt == std::string::npos || posDot == std::string::npos) {
std::cout << "El correo electrónico debe contener '@' y '.'. Por favor, ingrese un correo electrónico válido." << std::endl;
return;
}
if (mail.find(".com") == std::string::npos) {
std::cout << "El correo electrónico debe terminar en '.com'. Por favor, ingrese un correo electrónico válido." << std::endl;
return;
}
this->mail = mail;
}
void setNumeroReo(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!std::isdigit(c)) {
std::cout << "El número de reo debe contener solo números. Por favor, ingrese un número de reo válido." << std::endl;
return;
}
}
this->numeroReo = numeroReo;
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void darDeAlta() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.darDeAlta();
return 0;
}
```
Este programa define una clase `Estudiante` con métodos para establecer los atributos del estudiante y un método `darDeAlta` para mostrar los datos del estudiante. En el `main`, se crea un objeto `Estudiante` y se solicita al usuario que ingrese los datos del estudiante. Luego, se llama al método `darDeAlta` para mostrar los datos del estudiante.
Recuerda que este programa no utiliza expresiones regulares para validar los datos, sino que utiliza bucles para verificar que los datos cumplan con las condiciones establecidas.
Aquí te muestro un ejemplo de cómo podrías implementar el programa que solicitas:
```cpp
#include <iostream>
// Función para pedir los valores a la matriz al usuario
void pedirValores(int matriz[2][3]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
std::cout << "Ingrese el valor para la posición [" << i << "][" << j << "]: ";
std::cin >> matriz[i][j];
}
}
}
// Función para calcular la suma de todos los elementos de la matriz
int calcularSuma(int matriz[2][3]) {
int suma = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
suma += matriz[i][j];
}
}
return suma;
}
int main() {
int matriz[2][3];
// Pedir los valores a la matriz al usuario
pedirValores(matriz);
// Calcular la suma de todos los elementos de la matriz
int suma = calcularSuma(matriz);
// Mostrar la matriz y la suma de sus elementos
std::cout << "Matriz:" << std::endl;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
std::cout << matriz[i][j] << " ";
}
std::cout << std::endl;
}
std::cout << "Suma de todos los elementos: " << suma << std::endl;
return 0;
}
```
Este programa define una matriz 2x3 llamada `matriz`, y dos funciones: `pedirValores` para pedir los valores a la matriz al usuario, y `calcularSuma` para calcular la suma de todos los elementos de la matriz. En el `main`, se llama a `pedirValores` para pedir los valores a la matriz, luego se llama a `calcularSuma` para calcular la suma de los elementos, y finalmente se muestra la matriz y la suma de sus elementos.
Aquí te dejo un ejemplo de código en C++ que crea un laberinto de 6x7 con un ciclo anidado para mover un personaje representado por un asterisco (*):
```c
#include <iostream>
using namespace std;
// Función para dibujar el laberinto
void dibujarLaberinto(int laberinto[6][7]) {
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 7; j++) {
if (laberinto[i][j] == 0) {
cout << "0 ";
} else if (laberinto[i][j] == 1) {
cout << "1 ";
} else if (laberinto[i][j] == 2) {
cout << "* ";
}
}
cout << endl;
}
}
// Función para mover el personaje
void moverPersonaje(int laberinto[6][7], int x, int y) {
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int i, j;
for (i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (nx >= 0 && nx < 6 && ny >= 0 && ny < 7 && laberinto[nx][ny] == 1) {
laberinto[x][y] = 2;
laberinto[nx][ny] = 2;
x = nx;
y = ny;
cout << "Moviéndome a (" << x << ", " << y << ")" << endl;
dibujarLaberinto(laberinto);
break;
}
}
}
int main() {
int laberinto[6][7] = {
{1, 1, 1, 1, 1, 1, 1},
{1, 0, 0, 0, 0, 0, 1},
{1, 0, 1, 1, 1, 0, 1},
{1, 0, 1, 0, 1, 0, 1},
{1, 0, 1, 1, 1, 0, 1},
{1, 1, 1, 1, 1, 1, 1}
};
int x = 0;
int y = 0;
laberinto[x][y] = 2;
while (true) {
dibujarLaberinto(laberinto);
cout << "Presione una tecla para mover..." << endl;
cin.get();
moverPersonaje(laberinto, x, y);
}
return 0;
}
```
Este código crea un laberinto de 6x7 con un ciclo anidado para mover un personaje representado por un asterisco (*). El personaje se puede mover en las cuatro direcciones (arriba, abajo, izquierda, derecha) y solo puede pasar por las celdas con valor 1. El laberinto se dibuja en la pantalla después de cada movimiento.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
class Estudiante {
public:
void altaEstudiante() {
std::string nombre, telefono, mail, nick;
int numeroReo;
while (true) {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
if (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
break;
} else {
std::cout << "El nombre no puede contener números. Por favor, ingrese un nombre válido." << std::endl;
}
}
while (true) {
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
if (telefono.find_first_not_of("0123456789") == std::string::npos) {
break;
} else {
std::cout << "El teléfono solo puede contener números. Por favor, ingrese un teléfono válido." << std::endl;
}
}
while (true) {
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
if (mail.find("@") != std::string::npos && mail.find(".com") != std::string::npos) {
break;
} else {
std::cout << "El correo electrónico debe terminar en .com. Por favor, ingrese un correo electrónico válido." << std::endl;
}
}
while (true) {
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
if (numeroReo >= 0) {
break;
} else {
std::cout << "El número de reo no puede ser negativo. Por favor, ingrese un número de reo válido." << std::endl;
}
}
while (true) {
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nick;
if (!nick.empty()) {
break;
} else {
std::cout << "El nickname no puede estar vacío. Por favor, ingrese un nickname válido." << std::endl;
}
}
std::cout << "Estudiante creado con éxito!" << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nick << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa utiliza un bucle `while` para asegurarse de que los datos ingresados por el usuario sean válidos. Si el usuario ingresa un dato inválido, el programa le pide que lo repita hasta que ingrese un dato válido. Una vez que se han ingresado todos los datos válidos, el programa crea un estudiante con éxito y muestra sus datos en la consola.
Aquí te dejo un ejemplo de código en C++ que implementa el juego "Adivina el número" con un rango de 1 a 10 números por adivinar. El juego utiliza un bucle `while` para permitir al usuario intentar adivinar el número tantas veces como desee, y utiliza `if` para verificar si el número ingresado es válido (no negativo) y si es correcto o no.
```c
#include <iostream>
int main() {
int numeroSecreto = 7; // Número secreto entre 1 y 10
int intentos = 0;
int numeroIngresado;
std::cout << "Bienvenido al juego 'Adivina el número'!" << std::endl;
std::cout << "El número secreto está entre 1 y 10." << std::endl;
while (true) {
std::cout << "Ingrese un número entre 1 y 10: ";
std::cin >> numeroIngresado;
// Verificar si el número ingresado es válido (no negativo)
if (numeroIngresado < 1) {
std::cout << "Error: El número ingresado no es válido. Por favor, ingrese un número positivo." << std::endl;
continue;
}
// Verificar si el número ingresado es correcto
if (numeroIngresado == numeroSecreto) {
std::cout << "¡Felicidades! Adivinaste el número secreto en " << intentos + 1 << " intentos." << std::endl;
break;
} else if (numeroIngresado < numeroSecreto) {
std::cout << "El número secreto es mayor que el número ingresado." << std::endl;
} else {
std::cout << "El número secreto es menor que el número ingresado." << std::endl;
}
intentos++;
}
return 0;
}
```
En este código, el número secreto es `7` y el rango de números por adivinar es entre 1 y 10. El juego utiliza un bucle `while` para permitir al usuario intentar adivinar el número tantas veces como desee. El juego verifica si el número ingresado es válido (no negativo) y si es correcto o no. Si el número ingresado es correcto, el juego muestra un mensaje de felicitación y termina. Si el número ingresado es incorrecto, el juego muestra un mensaje de ayuda para que el usuario pueda intentar de nuevo.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find('@') == std::string::npos || mail.find('.com') == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante creado con éxito!" << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un método `altaEstudiante()` que solicita la información del estudiante y la valida según las reglas establecidas. Si la información no cumple con las reglas, el programa solicita que se ingrese nuevamente. Finalmente, muestra la información del estudiante creado con éxito.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
#include <regex>
// Estructura para almacenar la información del estudiante
struct Estudiante {
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
};
// Función para validar el correo electrónico
bool validarCorreo(const std::string& mail) {
std::regex patron("^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+$");
return std::regex_match(mail, patron);
}
// Función para validar el número de reo
bool validarNumeroReo(const std::string& numeroReo) {
std::regex patron("^[0-9]+$");
return std::regex_match(numeroReo, patron);
}
// Función para validar el nombre
bool validarNombre(const std::string& nombre) {
std::regex patron("^[a-zA-Z]+$");
return std::regex_match(nombre, patron);
}
// Función para registrar un estudiante
void registrarEstudiante(Estudiante& estudiante) {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> estudiante.nombre;
while (!validarNombre(estudiante.nombre)) {
std::cout << "El nombre no puede contener números. Por favor, ingrese el nombre nuevamente: ";
std::cin >> estudiante.nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> estudiante.telefono;
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::cin >> estudiante.mail;
while (!validarCorreo(estudiante.mail)) {
std::cout << "El correo electrónico no es válido. Por favor, ingrese el correo electrónico nuevamente: ";
std::cin >> estudiante.mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> estudiante.numeroReo;
while (!validarNumeroReo(estudiante.numeroReo)) {
std::cout << "El número de reo solo puede contener números. Por favor, ingrese el número de reo nuevamente: ";
std::cin >> estudiante.numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> estudiante.nickname;
}
int main() {
Estudiante estudiante;
registrarEstudiante(estudiante);
std::cout << "Estudiante registrado con éxito:" << std::endl;
std::cout << "Nombre: " << estudiante.nombre << std::endl;
std::cout << "Teléfono: " << estudiante.telefono << std::endl;
std::cout << "Correo electrónico: " << estudiante.mail << std::endl;
std::cout << "Número de reo: " << estudiante.numeroReo << std::endl;
std::cout << "Nickname: " << estudiante.nickname << std::endl;
return 0;
}
```
Este programa utiliza una estructura `Estudiante` para almacenar la información del estudiante. La función `registrarEstudiante` solicita la información del estudiante y la valida según las reglas establecidas. Si la información no es válida, el programa solicita que se ingrese nuevamente. Finalmente, el programa imprime la información del estudiante registrado con éxito.
Aquí te dejo un ejemplo de código en C++ que implementa la secuencia de Fibonacci utilizando un bucle `while` de la forma más sencilla posible:
```cpp
#include <iostream>
int main() {
int a = 0, b = 1, n, i = 0;
std::cout << "Ingrese el número de términos para la secuencia de Fibonacci: ";
std::cin >> n;
while (i < n) {
std::cout << a << " ";
int temp = a;
a = b;
b = temp + b;
i++;
}
return 0;
}
```
En este código, `a` y `b` son los dos últimos números de la secuencia de Fibonacci. El bucle `while` se ejecuta `n` veces, donde `n` es el número de términos que se desean generar. En cada iteración, se imprime el valor actual de `a`, se actualiza `a` con el valor actual de `b`, y se actualiza `b` con la suma de `a` y `b`.
Aquí te dejo un ejemplo de código en C++ que implementa un mini juego de "Adivina el número" con un rango de 1 a 10 números por adivinar:
```c
#include <iostream>
int main() {
int numero_secreto = 7; // Número secreto entre 1 y 10
int intentos = 0;
int max_intentos = 10;
std::cout << "Bienvenido al juego de 'Adivina el número'!" << std::endl;
std::cout << "Tienes " << max_intentos << " intentos para adivinar el número secreto entre 1 y 10." << std::endl;
while (intentos < max_intentos) {
int numero_adivinado;
std::cout << "Introduce tu número adivinado: ";
std::cin >> numero_adivinado;
if (numero_adivinado < 1 || numero_adivinado > 10) {
std::cout << "Error: El número debe estar entre 1 y 10." << std::endl;
} else if (numero_adivinado < numero_secreto) {
std::cout << "El número secreto es mayor que el número que has introducido." << std::endl;
} else if (numero_adivinado > numero_secreto) {
std::cout << "El número secreto es menor que el número que has introducido." << std::endl;
} else {
std::cout << "¡Enhorabuena! Has adivinado el número secreto en " << intentos + 1 << " intentos." << std::endl;
return 0;
}
intentos++;
std::cout << "Te quedan " << max_intentos - intentos << " intentos." << std::endl;
}
std::cout << "Lo siento, has agotado todos tus intentos. El número secreto era " << numero_secreto << "." << std::endl;
return 0;
}
```
Este código utiliza un bucle `while` para permitir al jugador introducir su número adivinado hasta que agote todos sus intentos o adivine el número secreto. El juego utiliza `if` para comprobar si el número adivinado es correcto, menor o mayor que el número secreto, y para mostrar mensajes de error o éxito al jugador.
Aquí te dejo un ejemplo de programa en C++ que cumple con tus requisitos:
```cpp
#include <iostream>
#include <string>
#include <regex>
using namespace std;
struct Estudiante {
string nombre;
string telefono;
string mail;
string numeroReo;
string nickname;
};
void registrarEstudiante(Estudiante &estudiante) {
cout << "Ingrese el nombre del estudiante: ";
getline(cin, estudiante.nombre);
while (true) {
cout << "Ingrese el teléfono del estudiante: ";
getline(cin, estudiante.telefono);
if (estudiante.telefono.length() == 10 && isdigit(estudiante.telefono[0]) && isdigit(estudiante.telefono[1]) && isdigit(estudiante.telefono[2]) && isdigit(estudiante.telefono[3]) && isdigit(estudiante.telefono[4]) && isdigit(estudiante.telefono[5]) && isdigit(estudiante.telefono[6]) && isdigit(estudiante.telefono[7]) && isdigit(estudiante.telefono[8]) && isdigit(estudiante.telefono[9])) {
break;
} else {
cout << "Teléfono inválido. Por favor, ingrese un número de 10 dígitos sin espacios ni caracteres especiales." << endl;
}
}
while (true) {
cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
getline(cin, estudiante.mail);
regex patron("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
if (regex_match(estudiante.mail, patron)) {
if (estudiante.mail.find(".com") != string::npos) {
break;
} else {
cout << "Correo electrónico inválido. Por favor, ingrese un correo electrónico que termine en .com." << endl;
}
} else {
cout << "Correo electrónico inválido. Por favor, ingrese un correo electrónico válido." << endl;
}
}
while (true) {
cout << "Ingrese el número de reo del estudiante: ";
getline(cin, estudiante.numeroReo);
if (isdigit(estudiante.numeroReo[0]) && isdigit(estudiante.numeroReo[1]) && isdigit(estudiante.numeroReo[2]) && isdigit(estudiante.numeroReo[3]) && isdigit(estudiante.numeroReo[4]) && isdigit(estudiante.numeroReo[5]) && isdigit(estudiante.numeroReo[6]) && isdigit(estudiante.numeroReo[7]) && isdigit(estudiante.numeroReo[8]) && isdigit(estudiante.numeroReo[9])) {
break;
} else {
cout << "Número de reo inválido. Por favor, ingrese un número de 10 dígitos sin espacios ni caracteres especiales." << endl;
}
}
cout << "Ingrese el nickname del estudiante: ";
getline(cin, estudiante.nickname);
}
int main() {
Estudiante estudiante;
registrarEstudiante(estudiante);
cout << "Estudiante registrado con éxito:" << endl;
cout << "Nombre: " << estudiante.nombre << endl;
cout << "Teléfono: " << estudiante.telefono << endl;
cout << "Correo electrónico: " << estudiante.mail << endl;
cout << "Número de reo: " << estudiante.numeroReo << endl;
cout << "Nickname: " << estudiante.nickname << endl;
return 0;
}
```
Este programa utiliza una estructura `Estudiante` para almacenar la información del estudiante. La función `registrarEstudiante` solicita la información del estudiante al usuario y la valida según las reglas establecidas. Si la información es válida, la almacena en la estructura `Estudiante`. Finalmente, el programa imprime la información del estudiante registrado.
Nota que el programa utiliza la función `regex_match` para validar el correo electrónico y la función `isdigit` para validar los números de teléfono y número de reo. También utiliza un bucle `while` para solicitar la información al usuario hasta que sea válida.
Aquí te dejo un ejemplo de cómo podrías implementar el programa que solicitas en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("0123456789") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find(".com") == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante creado con éxito!" << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un método `altaEstudiante()` que solicita al usuario que ingrese los datos del estudiante. Utiliza un bucle `while` para verificar que los datos ingresados sean válidos (es decir, que el nombre no contenga números, que el correo electrónico termine en `.com`, que el número de reo solo contenga números, etc.). Si los datos no son válidos, el programa solicita que se ingresen de nuevo. Una vez que se ingresan los datos válidos, el programa muestra un mensaje de confirmación y muestra los datos del estudiante.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname) {
this->nombre = nombre;
this->telefono = telefono;
this->mail = mail;
this->numeroReo = numeroReo;
this->nickname = nickname;
}
// Método para verificar si el correo electrónico es válido
bool verificarCorreo(std::string mail) {
return mail.find("@") != std::string::npos && mail.find(".com") != std::string::npos;
}
// Método para verificar si el número de reo es válido
bool verificarNumeroReo(std::string numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para verificar si el nombre es válido
bool verificarNombre(std::string nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para registrar al estudiante
void registrarEstudiante() {
std::string nombre, telefono, mail, numeroReo, nickname;
// Pedir los datos al usuario
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (!verificarNombre(nombre)) {
std::cout << "El nombre no puede contener números. Por favor, ingrese el nombre nuevamente: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
while (!verificarCorreo(mail)) {
std::cout << "El correo electrónico no es válido. Por favor, ingrese el correo electrónico nuevamente: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!verificarNumeroReo(numeroReo)) {
std::cout << "El número de reo no es válido. Por favor, ingrese el número de reo nuevamente: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
// Crear un objeto Estudiante con los datos ingresados
Estudiante estudiante(nombre, telefono, mail, numeroReo, nickname);
// Mostrar los datos del estudiante
std::cout << "Estudiante registrado con éxito:" << std::endl;
std::cout << "Nombre: " << estudiante.nombre << std::endl;
std::cout << "Teléfono: " << estudiante.telefono << std::endl;
std::cout << "Correo electrónico: " << estudiante.mail << std::endl;
std::cout << "Número de reo: " << estudiante.numeroReo << std::endl;
std::cout << "Nickname: " << estudiante.nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.registrarEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un constructor que toma los datos del estudiante como parámetros. La clase también tiene métodos para verificar si el correo electrónico y el número de reo son válidos. El método `registrarEstudiante` pide los datos al usuario, verifica que sean válidos y crea un objeto `Estudiante` con los datos ingresados. Finalmente, muestra los datos del estudiante.
Aquí te dejo un ejemplo de código en C++ que implementa el juego "Adivina el número" con un rango de 1 a 10 números por adivinar. El juego utiliza un bucle `while` para permitir al usuario intentar adivinar el número tantas veces como desee, y utiliza `if` para verificar si el número ingresado es válido (no negativo) y si es correcto o no.
```c
#include <iostream>
int main() {
int numeroSecreto = 7; // Número secreto entre 1 y 10
int intentos = 0;
int numeroIngresado;
std::cout << "Bienvenido al juego 'Adivina el número'!" << std::endl;
std::cout << "El número secreto está entre 1 y 10." << std::endl;
while (true) {
std::cout << "Ingrese un número entre 1 y 10: ";
std::cin >> numeroIngresado;
// Verificar si el número ingresado es válido (no negativo)
if (numeroIngresado < 1) {
std::cout << "Error: El número ingresado no es válido. Por favor, ingrese un número positivo." << std::endl;
continue;
}
// Verificar si el número ingresado es correcto
if (numeroIngresado == numeroSecreto) {
std::cout << "¡Felicidades! Adivinaste el número secreto en " << intentos + 1 << " intentos." << std::endl;
break;
} else if (numeroIngresado < numeroSecreto) {
std::cout << "El número secreto es mayor que el número ingresado." << std::endl;
} else {
std::cout << "El número secreto es menor que el número ingresado." << std::endl;
}
intentos++;
}
return 0;
}
```
En este código, el número secreto es `7` y el rango de números por adivinar es entre 1 y 10. El juego utiliza un bucle `while` para permitir al usuario intentar adivinar el número tantas veces como desee. El juego verifica si el número ingresado es válido (no negativo) y si es correcto o no. Si el número ingresado es correcto, el juego muestra un mensaje de felicitación y termina. Si el número ingresado es incorrecto, el juego muestra un mensaje de ayuda para que el usuario pueda intentar de nuevo.
Aquí te dejo un ejemplo de código en C++ que dibuja un laberinto de 6x7 utilizando un ciclo anidado:
```c
#include <iostream>
// Función para dibujar el laberinto
void dibujarLaberinto(int filas, int columnas) {
// Ciclo anidado para dibujar cada fila y columna
for (int i = 0; i < filas; i++) {
for (int j = 0; j < columnas; j++) {
// Dibuja un asterisco (*) para representar un muro
std::cout << "* ";
}
// Salta a la siguiente línea después de cada fila
std::cout << std::endl;
}
}
int main() {
// Define el tamaño del laberinto
const int filas = 6;
const int columnas = 7;
// Llama a la función para dibujar el laberinto
dibujarLaberinto(filas, columnas);
return 0;
}
```
Este código utiliza un ciclo anidado para dibujar cada fila y columna del laberinto. El primer ciclo (`for (int i = 0; i < filas; i++)`) se encarga de dibujar cada fila, y el segundo ciclo (`for (int j = 0; j < columnas; j++)`) se encarga de dibujar cada columna dentro de cada fila.
El resultado será un laberinto de 6x7 con asteriscos (*) que representan los muros.
**Ejemplo de salida:**
```
* * * * * * *
* * * * * * *
* * * * * * *
* * * * * * *
* * * * * * *
* * * * * * *
```
Recuerda que este es solo un ejemplo básico y puedes personalizar el código para agregar más características al laberinto, como espacios en blanco para representar pasillos o números para representar la posición del jugador.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en Python que cumpla con tus requisitos:
```python
class Estudiante:
def __init__(self, nombre, telefono, mail, num_reo, nickname):
self.nombre = nombre
self.telefono = telefono
self.mail = mail
self.num_reo = num_reo
self.nickname = nickname
def validar_nombre(self):
if not self.nombre.isalpha():
return False
return True
def validar_telefono(self):
if not self.telefono.isdigit():
return False
return True
def validar_mail(self):
if "@" not in self.mail or ".com" not in self.mail:
return False
return True
def validar_num_reo(self):
if not self.num_reo.isdigit():
return False
return True
def validar_nick(self):
if not self.nickname.isalpha():
return False
return True
def alta_estudiante(self):
if self.validar_nombre() and self.validar_telefono() and self.validar_mail() and self.validar_num_reo() and self.validar_nick():
print("El estudiante ha sido dado de alta con éxito.")
else:
print("Error en la información del estudiante.")
def main():
nombre = input("Ingrese el nombre del estudiante: ")
telefono = input("Ingrese el teléfono del estudiante: ")
mail = input("Ingrese el correo electrónico del estudiante: ")
num_reo = input("Ingrese el número de reo del estudiante: ")
nickname = input("Ingrese el nickname del estudiante: ")
estudiante = Estudiante(nombre, telefono, mail, num_reo, nickname)
estudiante.alta_estudiante()
if __name__ == "__main__":
main()
```
En este código, creamos una clase `Estudiante` con un constructor que inicializa los atributos del estudiante. Luego, creamos métodos para validar cada uno de los atributos: `validar_nombre`, `validar_telefono`, `validar_mail`, `validar_num_reo` y `validar_nick`. Estos métodos comprueban si el atributo cumple con las condiciones establecidas.
Finalmente, creamos un método `alta_estudiante` que llama a los métodos de validación y imprime un mensaje según el resultado.
En el método `main`, pedimos al usuario que ingrese la información del estudiante y creamos un objeto `Estudiante` con esa información. Luego, llamamos al método `alta_estudiante` para validar la información y dar de alta al estudiante.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
#include <regex>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
if (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
this->nombre = nombre;
} else {
std::cout << "El nombre no puede contener números." << std::endl;
}
}
void setTelefono(const std::string& telefono) {
this->telefono = telefono;
}
void setMail(const std::string& mail) {
std::regex patron("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
if (std::regex_match(mail, patron)) {
this->mail = mail;
} else {
std::cout << "El correo electrónico no es válido." << std::endl;
}
}
void setNumeroReo(const std::string& numeroReo) {
std::regex patron("^[0-9]+$");
if (std::regex_match(numeroReo, patron)) {
this->numeroReo = numeroReo;
} else {
std::cout << "El número de reo solo puede contener números." << std::endl;
}
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void darDeAlta() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.darDeAlta();
return 0;
}
```
Este programa define una clase `Estudiante` con métodos para establecer los atributos del estudiante y un método `darDeAlta` para mostrar la información del estudiante. En el método `main`, se crea un objeto `Estudiante` y se solicita al usuario que ingrese la información del estudiante. Luego, se llama al método `darDeAlta` para mostrar la información del estudiante.
Aquí te dejo un ejemplo de código en C++ que calcula el área de un círculo utilizando la constante `pi` con un valor de 3.1416:
```cpp
#include <iostream>
// Constante pi con un valor de 3.1416
const float pi = 3.1416;
// Función para calcular el área de un círculo
float calcularArea(float radio) {
return pi * radio * radio;
}
int main() {
// Declarar variables
float radio;
// Pedir el radio al usuario
std::cout << "Ingrese el radio del círculo: ";
std::cin >> radio;
// Calcular el área del círculo
float area = calcularArea(radio);
// Mostrar el resultado
std::cout << "El área del círculo es: " << area << std::endl;
return 0;
}
```
En este código, la constante `pi` se define con un valor de 3.1416. La función `calcularArea` toma un radio como parámetro y devuelve el área del círculo utilizando la fórmula `pi * radio * radio`. En el `main`, se pide al usuario que ingrese el radio del círculo, se calcula el área utilizando la función `calcularArea` y se muestra el resultado.
Recuerda que en C++, es común utilizar la constante `M_PI` definida en la biblioteca `<cmath>` para representar el valor de pi, en lugar de definir una constante personalizada. Sin embargo, en este ejemplo, se utiliza una constante personalizada para ilustrar el concepto.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor vacío
Estudiante() {}
// Constructor con parámetros
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname)
: nombre(nombre), telefono(telefono), mail(mail), numeroReo(numeroReo), nickname(nickname) {}
// Método para verificar si el correo electrónico es válido
bool verificarCorreo(std::string mail) {
return mail.find('@') != std::string::npos && mail.find('.com') != std::string::npos;
}
// Método para verificar si el número de reo es válido
bool verificarNumeroReo(std::string numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para verificar si el nombre es válido
bool verificarNombre(std::string nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para registrar un estudiante
void registrarEstudiante() {
std::string nombre, telefono, mail, numeroReo, nickname;
// Pedir nombre
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
// Verificar si el nombre es válido
while (!verificarNombre(nombre)) {
std::cout << "El nombre no puede contener números. Ingrese el nombre nuevamente: ";
std::cin >> nombre;
}
// Pedir teléfono
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
// Pedir correo electrónico
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
// Verificar si el correo electrónico es válido
while (!verificarCorreo(mail)) {
std::cout << "El correo electrónico debe contener '@' y '.com'. Ingrese el correo electrónico nuevamente: ";
std::cin >> mail;
}
// Pedir número de reo
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
// Verificar si el número de reo es válido
while (!verificarNumeroReo(numeroReo)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo nuevamente: ";
std::cin >> numeroReo;
}
// Pedir nickname
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
// Crear un objeto Estudiante con los datos ingresados
Estudiante estudiante(nombre, telefono, mail, numeroReo, nickname);
// Mostrar los datos del estudiante
std::cout << "Estudiante registrado con éxito:" << std::endl;
std::cout << "Nombre: " << estudiante.nombre << std::endl;
std::cout << "Teléfono: " << estudiante.telefono << std::endl;
std::cout << "Correo electrónico: " << estudiante.mail << std::endl;
std::cout << "Número de reo: " << estudiante.numeroReo << std::endl;
std::cout << "Nickname: " << estudiante.nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.registrarEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con métodos para verificar si el correo electrónico, el número de reo y el nombre son válidos. Luego, el método `registrarEstudiante` pide los datos del estudiante y verifica que sean válidos antes de crear un objeto `Estudiante` con los datos ingresados. Finalmente, muestra los datos del estudiante registrado.
Puedes utilizar el siguiente código en C++ para calcular el precio total de las entradas:
```cpp
#include <iostream>
int main() {
int cantidadDePersonas;
double precioPorPersona = 5.0;
// Preguntar al usuario la cantidad de personas
std::cout << "Ingrese la cantidad de personas en el grupo: ";
std::cin >> cantidadDePersonas;
// Calcular el precio total
double precioTotal = cantidadDePersonas * precioPorPersona;
// Mostrar el resultado
std::cout << "El precio total de las entradas es: $" << precioTotal << std::endl;
return 0;
}
```
Este código hace lo siguiente:
1. Pide al usuario que ingrese la cantidad de personas en el grupo.
2. Calcula el precio total multiplicando la cantidad de personas por el precio por persona.
3. Muestra el resultado en la consola.
Puedes copiar y pegar este código en un archivo C++ y ejecutarlo para probarlo.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname) {
this->nombre = nombre;
this->telefono = telefono;
this->mail = mail;
this->numeroReo = numeroReo;
this->nickname = nickname;
}
// Método para verificar si el correo electrónico es válido
bool verificarCorreo(std::string mail) {
return mail.find("@") != std::string::npos && mail.find(".com") != std::string::npos;
}
// Método para verificar si el número de reo es válido
bool verificarNumeroReo(std::string numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para verificar si el nombre es válido
bool verificarNombre(std::string nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para registrar al estudiante
void registrarEstudiante() {
std::string nombre, telefono, mail, numeroReo, nickname;
// Pedir los datos al usuario
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (!verificarNombre(nombre)) {
std::cout << "El nombre no puede contener números. Por favor, ingrese el nombre nuevamente: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
while (!verificarCorreo(mail)) {
std::cout << "El correo electrónico no es válido. Por favor, ingrese el correo electrónico nuevamente: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!verificarNumeroReo(numeroReo)) {
std::cout << "El número de reo no es válido. Por favor, ingrese el número de reo nuevamente: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
// Crear un objeto Estudiante con los datos ingresados
Estudiante estudiante(nombre, telefono, mail, numeroReo, nickname);
// Mostrar los datos del estudiante
std::cout << "Estudiante registrado con éxito:" << std::endl;
std::cout << "Nombre: " << estudiante.nombre << std::endl;
std::cout << "Teléfono: " << estudiante.telefono << std::endl;
std::cout << "Correo electrónico: " << estudiante.mail << std::endl;
std::cout << "Número de reo: " << estudiante.numeroReo << std::endl;
std::cout << "Nickname: " << estudiante.nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.registrarEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un constructor que toma los datos del estudiante como parámetros. La clase también tiene métodos para verificar si el correo electrónico y el número de reo son válidos. El método `registrarEstudiante` pide los datos al usuario, verifica que sean válidos y crea un objeto `Estudiante` con los datos ingresados. Finalmente, muestra los datos del estudiante.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
class Estudiante {
public:
void altaEstudiante() {
std::string nombre, telefono, mail, nick, reo;
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find('@') == std::string::npos || mail.find('.com') == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> reo;
while (reo.find_first_not_of("0123456789") != std::string::npos) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> reo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nick;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << reo << std::endl;
std::cout << "Nickname: " << nick << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa utiliza un bucle `while` para verificar que los datos ingresados por el usuario sean válidos. Si el usuario ingresa un dato inválido, el programa le pide que lo ingrese de nuevo. El programa también utiliza `std::string` para almacenar los datos ingresados por el usuario.
Recuerda que este es un ejemplo básico y que en un programa real, es recomendable agregar más validaciones y errores para asegurarte de que los datos sean correctos y no causen problemas en el programa.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
std::cout << "El nombre no puede contener números." << std::endl;
return;
}
}
this->nombre = nombre;
}
void setTelefono(const std::string& telefono) {
for (char c : telefono) {
if (!isdigit(c)) {
std::cout << "El teléfono debe contener solo números." << std::endl;
return;
}
}
this->telefono = telefono;
}
void setMail(const std::string& mail) {
size_t posAt = mail.find('@');
size_t posDot = mail.find('.');
if (posAt == std::string::npos || posDot == std::string::npos) {
std::cout << "El correo electrónico debe contener '@' y '.'." << std::endl;
return;
}
if (posDot < posAt + 1) {
std::cout << "El correo electrónico debe contener '.' después de '@'." << std::endl;
return;
}
if (mail.find(".com") == std::string::npos) {
std::cout << "El correo electrónico debe terminar en '.com'." << std::endl;
return;
}
this->mail = mail;
}
void setNumeroReo(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
std::cout << "El número de reo debe contener solo números." << std::endl;
return;
}
}
this->numeroReo = numeroReo;
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void darDeAlta() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.darDeAlta();
return 0;
}
```
Este programa crea una clase `Estudiante` con métodos para establecer los atributos del estudiante y un método `darDeAlta` para mostrar la información del estudiante. En el `main`, se crea un objeto `Estudiante` y se solicita la información del estudiante al usuario. Si la información no cumple con los requisitos, se muestra un mensaje de error y se solicita la información nuevamente. Finalmente, se muestra la información del estudiante.
Aquí te dejo un ejemplo de código en C++ que utiliza un ciclo anidado de 3x3 y busca las diagonales donde aparecen los valores {1,0,0}, {0,1,0} y {0,0,1}:
```cpp
#include <iostream>
int main() {
int matriz[3][3] = {{1,0,0}, {0,1,0}, {0,0,1}};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (matriz[i][j] == 1) {
std::cout << matriz[i][j] << " ";
} else {
std::cout << " ";
}
}
std::cout << std::endl;
}
return 0;
}
```
En este código, el primer ciclo `for` recorre las filas de la matriz, y el segundo ciclo `for` recorre las columnas. Si el valor actual de la matriz es 1, se imprime; de lo contrario, se imprime un espacio en blanco.
Al ejecutar este código, se imprimirá la siguiente salida:
```
1
1
1
```
Espero que esto te ayude. ¡Si tienes alguna pregunta o necesitas más ayuda, no dudes en preguntar!
Aquí te dejo un ejemplo de código en C++ que calcula el área de un círculo utilizando la fórmula `A = πr^2`, donde `A` es el área y `r` es el radio del círculo.
```cpp
#include <iostream>
#include <cmath>
using namespace std;
// Función para calcular el área de un círculo
double calcularArea(double radio) {
const double PI = 3.14159; // Valor aproximado de PI
return PI * pow(radio, 2);
}
int main() {
double radio;
// Pide al usuario que ingrese el radio del círculo
cout << "Ingrese el radio del círculo: ";
cin >> radio;
// Calcula el área del círculo
double area = calcularArea(radio);
// Muestra el resultado
cout << "El área del círculo es: " << area << endl;
return 0;
}
```
En este código, la función `calcularArea` toma como parámetro el radio del círculo y devuelve el área calculada utilizando la fórmula `A = πr^2`. En el `main`, se pide al usuario que ingrese el radio del círculo, se calcula el área utilizando la función `calcularArea` y se muestra el resultado.
Recuerda que el valor de PI se puede obtener utilizando la función `M_PI` de la biblioteca `math.h`, pero en este ejemplo se utiliza un valor aproximado para simplificar el código.
Aquí te dejo un ejemplo de código en C++ que crea una matriz de 10x10 con un personaje y dos enemigos, y permite controlar al personaje con las teclas W, A, S, y D. El juego se detiene cuando el personaje choca con una pared o con un enemigo.
```cpp
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
const int FILAS = 10;
const int COLUMNAS = 10;
const int VIDA = 2;
char matriz[FILAS][COLUMNAS];
int xPersonaje = 1;
int yPersonaje = 1;
int xEnemigo1 = 3;
int yEnemigo1 = 3;
int xEnemigo2 = 5;
int yEnemigo2 = 5;
int vida = VIDA;
void inicializarMatriz() {
for (int i = 0; i < FILAS; i++) {
for (int j = 0; j < COLUMNAS; j++) {
matriz[i][j] = '#';
}
}
matriz[xPersonaje][yPersonaje] = '*';
matriz[xEnemigo1][yEnemigo1] = 'E';
matriz[xEnemigo2][yEnemigo2] = 'e';
}
void imprimirMatriz() {
for (int i = 0; i < FILAS; i++) {
for (int j = 0; j < COLUMNAS; j++) {
cout << matriz[i][j] << " ";
}
cout << endl;
}
}
void moverPersonaje(char tecla) {
int nuevoX, nuevoY;
switch (tecla) {
case 'w':
nuevoX = xPersonaje;
nuevoY = yPersonaje - 1;
break;
case 'a':
nuevoX = xPersonaje - 1;
nuevoY = yPersonaje;
break;
case 's':
nuevoX = xPersonaje;
nuevoY = yPersonaje + 1;
break;
case 'd':
nuevoX = xPersonaje + 1;
nuevoY = yPersonaje;
break;
default:
return;
}
if (nuevoX >= 0 && nuevoX < FILAS && nuevoY >= 0 && nuevoY < COLUMNAS && matriz[nuevoX][nuevoY] != '#') {
matriz[xPersonaje][yPersonaje] = '#';
xPersonaje = nuevoX;
yPersonaje = nuevoY;
matriz[xPersonaje][yPersonaje] = '*';
}
}
int main() {
srand(time(0));
inicializarMatriz();
while (vida > 0) {
imprimirMatriz();
cout << "Vidas: " << vida << endl;
cout << "Presione W para moverse hacia arriba, A para moverse hacia la izquierda, S para moverse hacia abajo y D para moverse hacia la derecha." << endl;
char tecla;
cin >> tecla;
moverPersonaje(tecla);
// Mover enemigos
if (rand() % 10 == 0) {
int nuevoX, nuevoY;
switch (rand() % 4) {
case 0:
nuevoX = xEnemigo1;
nuevoY = yEnemigo1 - 1;
break;
case 1:
nuevoX = xEnemigo1 - 1;
nuevoY = yEnemigo1;
break;
case 2:
nuevoX = xEnemigo1;
nuevoY = yEnemigo1 + 1;
break;
case 3:
nuevoX = xEnemigo1 + 1;
nuevoY = yEnemigo1;
break;
}
if (nuevoX >= 0 && nuevoX < FILAS && nuevoY >= 0 && nuevoY < COLUMNAS && matriz[nuevoX][nuevoY] != '#') {
matriz[xEnemigo1][yEnemigo1] = '#';
xEnemigo1 = nuevoX;
yEnemigo1 = nuevoY;
matriz[xEnemigo1][yEnemigo1] = 'E';
}
}
if (rand() % 10 == 0) {
int nuevoX, nuevoY;
switch (rand() % 4) {
case 0:
nuevoX = xEnemigo2;
nuevoY = yEnemigo2 - 1;
break;
case 1:
nuevoX = xEnemigo2 - 1;
nuevoY = yEnemigo2;
break;
case 2:
nuevoX = xEnemigo2;
nuevoY = yEnemigo2 + 1;
break;
case 3:
nuevoX = xEnemigo2 + 1;
nuevoY = yEnemigo2;
break;
}
if (nuevoX >= 0 && nuevoX < FILAS && nuevoY >= 0 && nuevoY < COLUMNAS && matriz[nuevoX][nuevoY] != '#') {
matriz[xEnemigo2][yEnemigo2] = '#';
xEnemigo2 = nuevoX;
yEnemigo2 = nuevoY;
matriz[xEnemigo2][yEnemigo2] = 'e';
}
}
// Comprobar colisiones
if (xPersonaje == xEnemigo1 && yPersonaje == yEnemigo1) {
vida--;
matriz[xPersonaje][yPersonaje] = '#';
xPersonaje = 1;
yPersonaje = 1;
matriz[xPersonaje][yPersonaje] = '*';
}
if (xPersonaje == xEnemigo2 && yPersonaje == yEnemigo2) {
vida--;
matriz[xPersonaje][yPersonaje] = '#';
xPersonaje = 1;
yPersonaje = 1;
matriz[xPersonaje][yPersonaje] = '*';
}
if (xPersonaje < 0 || xPersonaje >= FILAS || yPersonaje < 0 || yPersonaje >= COLUMNAS) {
vida--;
matriz[xPersonaje][yPersonaje] = '#';
xPersonaje = 1;
yPersonaje = 1;
matriz[xPersonaje][yPersonaje] = '*';
}
}
imprimirMatriz();
cout << "Game Over. Vidas: " << vida << endl;
return 0;
}
```
Este código crea una matriz de 10x10 con un personaje y dos enemigos, y permite controlar al personaje con las teclas W, A, S, y D. El juego se detiene cuando el personaje choca con una pared o con un enemigo. Los enemigos se mueven aleatoriamente en cada iteración del bucle principal.
Aquí te dejo un ejemplo de código en C++ que calcula el área de un círculo utilizando la constante `pi` con un valor de 3.1416:
```cpp
#include <iostream>
// Constante pi con un valor de 3.1416
const float pi = 3.1416;
// Función para calcular el área de un círculo
float calcularArea(float radio) {
return pi * radio * radio;
}
int main() {
// Declarar variables
float radio;
// Pedir el radio al usuario
std::cout << "Ingrese el radio del círculo: ";
std::cin >> radio;
// Calcular el área del círculo
float area = calcularArea(radio);
// Mostrar el resultado
std::cout << "El área del círculo es: " << area << std::endl;
return 0;
}
```
En este código, la constante `pi` se define con un valor de 3.1416. La función `calcularArea` toma un radio como parámetro y devuelve el área del círculo utilizando la fórmula `pi * radio * radio`. En el `main`, se pide al usuario que ingrese el radio del círculo, se calcula el área utilizando la función `calcularArea` y se muestra el resultado.
Recuerda que en C++, es común utilizar la constante `M_PI` definida en la biblioteca `<cmath>` para representar el valor de pi, en lugar de definir una constante personalizada. Sin embargo, en este ejemplo, se utiliza una constante personalizada para ilustrar el concepto.
Aquí te dejo un ejemplo de código en C++ que calcula el promedio general de un grupo de 10 personas, donde cada persona tiene una calificación asociada. Utiliza la función `string` para almacenar los nombres de las personas.
```cpp
#include <iostream>
#include <string>
#include <vector>
// Estructura para almacenar la información de cada persona
struct Persona {
std::string nombre;
double calificacion;
};
int main() {
// Vector para almacenar las personas
std::vector<Persona> personas;
// Pedir la información de cada persona
for (int i = 0; i < 10; i++) {
Persona persona;
std::cout << "Ingrese el nombre de la persona " << i + 1 << ": ";
std::cin >> persona.nombre;
std::cout << "Ingrese la calificación de la persona " << i + 1 << ": ";
std::cin >> persona.calificacion;
// Agregar la persona al vector
personas.push_back(persona);
}
// Calcular el promedio general
double sumaCalificaciones = 0;
for (const auto& persona : personas) {
sumaCalificaciones += persona.calificacion;
}
double promedioGeneral = sumaCalificaciones / personas.size();
// Mostrar el promedio general
std::cout << "El promedio general de las calificaciones es: " << promedioGeneral << std::endl;
// Mostrar las calificaciones de cada persona
std::cout << "Calificaciones de cada persona:" << std::endl;
for (const auto& persona : personas) {
std::cout << persona.nombre << ": " << persona.calificacion << std::endl;
}
return 0;
}
```
Este código utiliza una estructura `Persona` para almacenar la información de cada persona, incluyendo su nombre y calificación. Luego, utiliza un vector para almacenar las personas y pedir la información de cada una de ellas. Finalmente, calcula el promedio general de las calificaciones y lo muestra en pantalla, junto con las calificaciones de cada persona.
Recuerda que este código asume que las calificaciones son números enteros o decimales, y que el promedio general se calcula dividiendo la suma de las calificaciones por el número de personas. Si necesitas hacer algo más complejo, como calcular el promedio de calificaciones por categoría o algo similar, debes adaptar el código según tus necesidades.
Aquí te dejo un ejemplo de código en C++ que calcula el área de un círculo utilizando la constante `pi` con un valor de 3.1416:
```cpp
#include <iostream>
using namespace std;
int main() {
// Constante pi con un valor de 3.1416
const float pi = 3.1416;
// Declaración de variables
float radio;
// Preguntar al usuario por el radio del círculo
cout << "Ingrese el radio del círculo: ";
cin >> radio;
// Calcular el área del círculo
float area = pi * radio * radio;
// Mostrar el resultado
cout << "El área del círculo es: " << area << endl;
return 0;
}
```
En este código, se declara una constante `pi` con un valor de 3.1416. Luego, se pide al usuario que ingrese el radio del círculo. Finalmente, se calcula el área del círculo utilizando la fórmula `área = pi * radio^2` y se muestra el resultado.
Recuerda que en C++ es recomendable evitar el uso de `using namespace std;` en archivos de cabecera o en archivos grandes, ya que puede causar conflictos de nombres. En su lugar, puedes importar solo las funciones o variables que necesites con `using std::cout;` o `using std::cin;`.
Aquí te muestro un ejemplo de código en C++ que calcula el área de un círculo:
```cpp
#include <iostream>
#include <cmath>
// Función para calcular el área de un círculo
double calcularAreaCirculo(double radio) {
// Constante pi
const double PI = 3.14159;
// Calcula el área del círculo
double area = PI * pow(radio, 2);
return area;
}
int main() {
// Declaración de variables
double radio;
// Pide al usuario que ingrese el radio del círculo
std::cout << "Ingrese el radio del círculo: ";
std::cin >> radio;
// Calcula el área del círculo
double area = calcularAreaCirculo(radio);
// Muestra el resultado
std::cout << "El área del círculo es: " << area << std::endl;
return 0;
}
```
En este código, la función `calcularAreaCirculo` toma como parámetro el radio del círculo y devuelve el área calculada. La función utiliza la constante `PI` para calcular el área del círculo según la fórmula `A = πr^2`.
En el `main`, se pide al usuario que ingrese el radio del círculo, se calcula el área utilizando la función `calcularAreaCirculo` y se muestra el resultado.
Recuerda que debes compilar y ejecutar el código para ver el resultado.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname) {
this->nombre = nombre;
this->telefono = telefono;
this->mail = mail;
this->numeroReo = numeroReo;
this->nickname = nickname;
}
// Método para verificar si el correo electrónico es válido
bool verificarCorreo(std::string mail) {
return mail.find("@") != std::string::npos && mail.find(".com") != std::string::npos;
}
// Método para verificar si el número de reo es válido
bool verificarNumeroReo(std::string numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para verificar si el nombre es válido
bool verificarNombre(std::string nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para registrar al estudiante
void registrarEstudiante() {
std::string nombre, telefono, mail, numeroReo, nickname;
// Pedir los datos al usuario
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (!verificarNombre(nombre)) {
std::cout << "El nombre no puede contener números. Por favor, ingrese el nombre nuevamente: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
while (!verificarCorreo(mail)) {
std::cout << "El correo electrónico no es válido. Por favor, ingrese el correo electrónico nuevamente: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!verificarNumeroReo(numeroReo)) {
std::cout << "El número de reo no es válido. Por favor, ingrese el número de reo nuevamente: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
// Crear un objeto Estudiante con los datos ingresados
Estudiante estudiante(nombre, telefono, mail, numeroReo, nickname);
// Mostrar los datos del estudiante
std::cout << "Estudiante registrado con éxito:" << std::endl;
std::cout << "Nombre: " << estudiante.nombre << std::endl;
std::cout << "Teléfono: " << estudiante.telefono << std::endl;
std::cout << "Correo electrónico: " << estudiante.mail << std::endl;
std::cout << "Número de reo: " << estudiante.numeroReo << std::endl;
std::cout << "Nickname: " << estudiante.nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.registrarEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un constructor que toma los datos del estudiante como parámetros. La clase también tiene métodos para verificar si el correo electrónico y el número de reo son válidos. El método `registrarEstudiante` pide los datos al usuario, verifica que sean válidos y crea un objeto `Estudiante` con los datos ingresados. Finalmente, muestra los datos del estudiante.
Aquí te dejo un ejemplo de código en C++ que crea una matriz de 10x10 para jugar a Pacman con 2 enemigos. El personaje se controla con las teclas W, A, S y D, y tiene 2 vidas.
```cpp
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
// Definimos las constantes para las direcciones
const int DERECHA = 0;
const int IZQUIERDA = 1;
const int ARRIBA = 2;
const int ABAJO = 3;
// Definimos la estructura para el personaje
struct Personaje {
int x, y;
int vida;
};
// Definimos la estructura para el enemigo
struct Enemigo {
int x, y;
};
// Definimos la matriz para el juego
int matriz[10][10];
int main() {
// Inicializamos la semilla para la generación aleatoria
srand(time(0));
// Inicializamos el personaje y los enemigos
Personaje pacman;
Enemigo enemigo1, enemigo2;
// Inicializamos la posición del personaje y los enemigos
pacman.x = 5;
pacman.y = 5;
pacman.vida = 2;
enemigo1.x = 3;
enemigo1.y = 3;
enemigo2.x = 7;
enemigo2.y = 7;
// Inicializamos la matriz con 0
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
matriz[i][j] = 0;
}
}
// Mostramos la matriz inicial
cout << "Matriz inicial:" << endl;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
cout << matriz[i][j] << " ";
}
cout << endl;
}
// Bucle principal del juego
while (pacman.vida > 0) {
// Mostramos la matriz actual
cout << "Matriz actual:" << endl;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
cout << matriz[i][j] << " ";
}
cout << endl;
}
// Pedimos la dirección al usuario
int direccion;
cout << "Ingrese la dirección (0=Derecha, 1=Izquierda, 2=Arriba, 3=Abajo): ";
cin >> direccion;
// Movemos el personaje según la dirección
switch (direccion) {
case DERECHA:
if (pacman.x < 9 && matriz[pacman.y][pacman.x + 1] != 1) {
pacman.x++;
}
break;
case IZQUIERDA:
if (pacman.x > 0 && matriz[pacman.y][pacman.x - 1] != 1) {
pacman.x--;
}
break;
case ARRIBA:
if (pacman.y > 0 && matriz[pacman.y - 1][pacman.x] != 1) {
pacman.y--;
}
break;
case ABAJO:
if (pacman.y < 9 && matriz[pacman.y + 1][pacman.x] != 1) {
pacman.y++;
}
break;
}
// Movemos los enemigos
enemigo1.x += rand() % 3 - 1;
enemigo1.y += rand() % 3 - 1;
enemigo2.x += rand() % 3 - 1;
enemigo2.y += rand() % 3 - 1;
// Comprobamos si el personaje choca con un enemigo
if (pacman.x == enemigo1.x && pacman.y == enemigo1.y) {
pacman.vida--;
cout << "Pacman choca con un enemigo. Vida restada." << endl;
}
if (pacman.x == enemigo2.x && pacman.y == enemigo2.y) {
pacman.vida--;
cout << "Pacman choca con un enemigo. Vida restada." << endl;
}
// Comprobamos si el personaje sale de la matriz
if (pacman.x < 0 || pacman.x > 9 || pacman.y < 0 || pacman.y > 9) {
pacman.x = 5;
pacman.y = 5;
cout << "Pacman sale de la matriz. Posición inicial restablecida." << endl;
}
// Comprobamos si el personaje choca con un muro
if (matriz[pacman.y][pacman.x] == 1) {
pacman.x = 5;
pacman.y = 5;
cout << "Pacman choca con un muro. Posición inicial restablecida." << endl;
}
// Comprobamos si el personaje ha ganado
if (pacman.x == 0 && pacman.y == 0) {
cout << "Pacman ha ganado!" << endl;
break;
}
}
// Mostramos el resultado final
cout << "Matriz final:" << endl;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
cout << matriz[i][j] << " ";
}
cout << endl;
}
return 0;
}
```
Este código crea una matriz de 10x10 y simula un juego de Pacman con 2 enemigos. El personaje se controla con las teclas W, A, S y D, y tiene 2 vidas. El juego termina cuando el personaje choca con un enemigo o sale de la matriz. Si el personaje choca con un muro, se restablece a la posición inicial. Si el personaje ha ganado, se muestra un mensaje de victoria.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
#include <regex>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
if (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
this->nombre = nombre;
} else {
std::cout << "El nombre no puede contener números." << std::endl;
}
}
void setTelefono(const std::string& telefono) {
this->telefono = telefono;
}
void setMail(const std::string& mail) {
std::regex patron("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
if (std::regex_match(mail, patron)) {
this->mail = mail;
} else {
std::cout << "El correo electrónico no es válido." << std::endl;
}
}
void setNumeroReo(const std::string& numeroReo) {
std::regex patron("^[0-9]+$");
if (std::regex_match(numeroReo, patron)) {
this->numeroReo = numeroReo;
} else {
std::cout << "El número de reo solo puede contener números." << std::endl;
}
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void mostrarDatos() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.mostrarDatos();
return 0;
}
```
Este programa define una clase `Estudiante` con métodos para establecer los datos del estudiante y un método para mostrar los datos. Los métodos de establecimiento de datos validan los datos ingresados según las reglas establecidas. El programa principal solicita los datos del estudiante al usuario y luego muestra los datos establecidos.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
for (char c : nombre) {
if (!std::isalpha(c)) {
std::cout << "El nombre no puede contener números." << std::endl;
return;
}
}
this->nombre = nombre;
}
void setTelefono(const std::string& telefono) {
for (char c : telefono) {
if (!std::isdigit(c)) {
std::cout << "El teléfono debe contener solo números." << std::endl;
return;
}
}
this->telefono = telefono;
}
void setMail(const std::string& mail) {
size_t posAt = mail.find('@');
size_t posDot = mail.find('.');
if (posAt == std::string::npos || posDot == std::string::npos) {
std::cout << "El correo electrónico debe contener '@' y '.'." << std::endl;
return;
}
if (mail.find(".com") == std::string::npos) {
std::cout << "El correo electrónico debe terminar en '.com'." << std::endl;
return;
}
this->mail = mail;
}
void setNumeroReo(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!std::isdigit(c)) {
std::cout << "El número de reo debe contener solo números." << std::endl;
return;
}
}
this->numeroReo = numeroReo;
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void darDeAlta() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.darDeAlta();
return 0;
}
```
Este programa crea una clase `Estudiante` con métodos para establecer los atributos del estudiante y un método para dar de alta al estudiante. En el método `main`, se crea un objeto `Estudiante` y se solicita al usuario que ingrese los datos del estudiante. Luego, se llama al método `darDeAlta` para mostrar los datos del estudiante.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
#include <regex>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
if (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
this->nombre = nombre;
} else {
std::cout << "El nombre no puede contener números." << std::endl;
}
}
void setTelefono(const std::string& telefono) {
if (telefono.length() == 10 && std::all_of(telefono.begin(), telefono.end(), ::isdigit)) {
this->telefono = telefono;
} else {
std::cout << "El teléfono debe tener 10 dígitos y solo números." << std::endl;
}
}
void setMail(const std::string& mail) {
std::regex patron("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
if (std::regex_match(mail, patron)) {
this->mail = mail;
} else {
std::cout << "El correo electrónico debe tener la forma 'nombre@dominio.com'." << std::endl;
}
}
void setNumeroReo(const std::string& numeroReo) {
if (std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
this->numeroReo = numeroReo;
} else {
std::cout << "El número de reo solo puede contener números." << std::endl;
}
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void mostrarDatos() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.mostrarDatos();
return 0;
}
```
Este programa define una clase `Estudiante` con métodos para establecer los datos del estudiante y un método para mostrar los datos. Los métodos de establecimiento de datos validan los datos ingresados según las reglas establecidas. El programa principal solicita los datos del estudiante al usuario y luego muestra los datos establecidos.
Puedes utilizar la siguiente función en C++ para calcular el promedio general de las calificaciones de los alumnos:
```cpp
#include <iostream>
#include <string>
// Estructura para almacenar la información de un alumno
struct Alumno {
std::string nombre;
double calificacion;
};
int main() {
// Declarar un arreglo de alumnos
Alumno alumnos[64];
// Pedir la información de cada alumno
for (int i = 0; i < 64; i++) {
std::cout << "Ingrese el nombre del alumno " << i + 1 << ": ";
std::cin >> alumnos[i].nombre;
std::cout << "Ingrese la calificación del alumno " << i + 1 << ": ";
std::cin >> alumnos[i].calificacion;
}
// Calcular la suma de las calificaciones
double sumaCalificaciones = 0;
for (int i = 0; i < 64; i++) {
sumaCalificaciones += alumnos[i].calificacion;
}
// Calcular el promedio general
double promedioGeneral = sumaCalificaciones / 64;
// Mostrar el promedio general
std::cout << "El promedio general de las calificaciones es: " << promedioGeneral << std::endl;
return 0;
}
```
Este código utiliza una estructura `Alumno` para almacenar la información de cada alumno, incluyendo su nombre y calificación. Luego, utiliza un bucle `for` para pedir la información de cada alumno y calcular la suma de sus calificaciones. Finalmente, calcula el promedio general dividiendo la suma de las calificaciones por el número de alumnos.
Recuerda que en C++, no hay un tipo de dato específico para almacenar decimales, pero el tipo `double` es comúnmente utilizado para ello. El tipo `double` puede almacenar números con decimales con una precisión de hasta 15 dígitos.
Si deseas que el código sea más robusto y maneje posibles errores, puedes agregar comprobaciones para asegurarte de que el usuario ingrese información válida. Por ejemplo, puedes verificar que el nombre del alumno no esté vacío y que la calificación sea un número válido.
Aquí te muestro un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <cmath>
// Función para calcular el perímetro de un polígono regular
double calcularPerimetro(int lados, double lado) {
return lados * lado;
}
// Función para calcular la apotema de un polígono regular
double calcularApotema(int lados, double lado) {
return std::sqrt(std::pow(lado, 2) - std::pow(lado / 2, 2));
}
// Función para calcular el área de un polígono regular
double calcularArea(int lados, double lado) {
double apotema = calcularApotema(lados, lado);
double perimetro = calcularPerimetro(lados, lado);
return (perimetro * apotema) / 2;
}
// Función para mostrar opciones de polígonos
void mostrarOpciones() {
std::cout << "Seleccione un polígono regular:" << std::endl;
std::cout << "1. Pentágono" << std::endl;
std::cout << "2. Hexágono" << std::endl;
std::cout << "3. Heptágono" << std::endl;
std::cout << "4. Octágono" << std::endl;
}
// Función para obtener la longitud de un lado de un polígono regular
void obtenerLado(int &lados, double &lado) {
std::cout << "Ingrese la longitud de un lado del polígono: ";
std::cin >> lado;
lados = 5; // Por defecto, asumimos que es un pentágono
switch (lados) {
case 5:
std::cout << "Pentágono seleccionado." << std::endl;
break;
case 6:
std::cout << "Hexágono seleccionado." << std::endl;
break;
case 7:
std::cout << "Heptágono seleccionado." << std::endl;
break;
case 8:
std::cout << "Octágono seleccionado." << std::endl;
break;
default:
std::cout << "Polígono no válido." << std::endl;
exit(1);
}
}
int main() {
int lados;
double lado;
mostrarOpciones();
std::cout << "Ingrese el número del polígono que desea seleccionar: ";
std::cin >> lados;
obtenerLado(lados, lado);
double area = calcularArea(lados, lado);
std::cout << "El área del polígono es: " << area << std::endl;
return 0;
}
```
Este programa define cuatro funciones: `calcularPerimetro`, `calcularApotema` y `calcularArea` para calcular el perímetro, la apotema y el área de un polígono regular, respectivamente. La función `mostrarOpciones` muestra las opciones de polígonos disponibles y la función `obtenerLado` obtiene la longitud de un lado del polígono seleccionado.
En el `main`, se muestra la lista de opciones de polígonos y se solicita al usuario que ingrese el número del polígono que desea seleccionar. Luego, se llama a la función `obtenerLado` para obtener la longitud de un lado del polígono seleccionado y se calcula el área del polígono utilizando la función `calcularArea`. Finalmente, se muestra el área del polígono en la consola.
Aquí te dejo un ejemplo de código en C++ que cumple con las características que mencionaste:
```cpp
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <windows.h>
using namespace std;
// Definición de la matriz de identidad
const int FILAS = 30;
const int COLUMNAS = 30;
// Definición de la estructura para el personaje
struct Personaje {
int x, y;
int vidas;
int llaves;
};
// Definición de la estructura para los enemigos
struct Enemigo {
int x, y;
int velocidad;
};
// Definición de la estructura para las llaves
struct Llave {
int x, y;
};
// Definición de la matriz de identidad
char laberinto[FILAS][COLUMNAS] = {
// Inicializar la matriz con espacios en blanco
{" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", "
Aquí te dejo un ejemplo de código en C++ que calcula el promedio general de 64 alumnos con sus calificaciones:
```cpp
#include <iostream>
#include <string>
int main() {
const int NUM_ALUMNOS = 64;
float sumaCalificaciones = 0;
float promedioGeneral = 0;
for (int i = 0; i < NUM_ALUMNOS; i++) {
std::string nombreAlumno;
float calificacion;
std::cout << "Ingrese el nombre del alumno " << i + 1 << ": ";
std::cin >> nombreAlumno;
std::cout << "Ingrese la calificación del alumno " << i + 1 << ": ";
std::cin >> calificacion;
sumaCalificaciones += calificacion;
}
promedioGeneral = sumaCalificaciones / NUM_ALUMNOS;
std::cout << "El promedio general de los " << NUM_ALUMNOS << " alumnos es: " << promedioGeneral << std::endl;
return 0;
}
```
En este código, utilizamos un bucle `for` para recorrer los 64 alumnos. Para cada alumno, solicitamos su nombre y calificación, y las sumamos a la variable `sumaCalificaciones`. Finalmente, calculamos el promedio general dividiendo la suma de calificaciones por el número de alumnos.
Para obtener números decimales, utilizamos el tipo de dato `float` para almacenar las calificaciones y el promedio general.
**Nota:** Si deseas utilizar un bucle `while` en lugar de `for`, puedes hacerlo de la siguiente manera:
```cpp
int i = 0;
while (i < NUM_ALUMNOS) {
// código del bucle
i++;
}
```
Sin embargo, en este caso, el bucle `for` es más adecuado ya que nos permite recorrer los 64 alumnos de manera más directa y eficiente.
Aquí te dejo un ejemplo de código en C++ que crea una matriz de identidad de 4x4:
```cpp
#include <iostream>
// Definimos la clase Matriz para representar la matriz de identidad
class Matriz {
private:
int** datos;
int filas;
int columnas;
public:
// Constructor para crear una matriz de identidad de tamaño n x n
Matriz(int n) {
filas = n;
columnas = n;
datos = new int*[filas];
for (int i = 0; i < filas; i++) {
datos[i] = new int[columnas];
}
// Inicializamos la matriz de identidad
for (int i = 0; i < filas; i++) {
for (int j = 0; j < columnas; j++) {
if (i == j) {
datos[i][j] = 1;
} else {
datos[i][j] = 0;
}
}
}
}
// Destructor para liberar la memoria asignada
~Matriz() {
for (int i = 0; i < filas; i++) {
delete[] datos[i];
}
delete[] datos;
}
// Método para imprimir la matriz
void imprimir() {
for (int i = 0; i < filas; i++) {
for (int j = 0; j < columnas; j++) {
std::cout << datos[i][j] << " ";
}
std::cout << std::endl;
}
}
};
int main() {
// Creamos una matriz de identidad de 4x4
Matriz matriz(4);
std::cout << "Matriz de identidad 4x4:" << std::endl;
matriz.imprimir();
return 0;
}
```
Este código define una clase `Matriz` que representa una matriz de identidad de tamaño n x n. La matriz se inicializa con ceros y se establecen los elementos en la diagonal principal en 1. El constructor crea la matriz y la inicializa, el destructor libera la memoria asignada y el método `imprimir` imprime la matriz en la consola.
En el `main`, creamos una matriz de identidad de 4x4 y la imprimimos en la consola.
Aquí te dejo un ejemplo de código en C++ que utiliza un ciclo anidado de 3x3 para encontrar las diagonales donde aparecen los valores {1,0,0}, {0,1,0} y {0,0,1}:
```cpp
#include <iostream>
int main() {
int matriz[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
// Ciclo anidado para recorrer la matriz
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
// Verificar si estamos en la diagonal principal
if (i == j) {
std::cout << "Diagonal principal: " << matriz[i][j] << " ";
}
// Verificar si estamos en la diagonal secundaria
else if (i + j == 2) {
std::cout << "Diagonal secundaria: " << matriz[i][j] << " ";
}
// Verificar si estamos en la diagonal de la izquierda a la derecha
else if (j == 0 && i != j) {
std::cout << "Diagonal izquierda a derecha: " << matriz[i][j] << " ";
}
// Verificar si estamos en la diagonal de la derecha a la izquierda
else if (j == 2 && i != j) {
std::cout << "Diagonal derecha a izquierda: " << matriz[i][j] << " ";
}
// Si no estamos en ninguna de las diagonales, simplemente imprimimos el valor
else {
std::cout << matriz[i][j] << " ";
}
}
std::cout << std::endl;
}
return 0;
}
```
Este código crea una matriz 3x3 con los valores {1,0,0}, {0,1,0} y {0,0,1} en la diagonal principal. Luego, utiliza un ciclo anidado para recorrer la matriz y verificar en qué diagonal se encuentra cada elemento. Si el elemento se encuentra en la diagonal principal, secundaria, izquierda a derecha o derecha a izquierda, imprime el valor correspondiente. Si no se encuentra en ninguna de las diagonales, simplemente imprime el valor del elemento.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en Python que cumpla con tus requisitos:
```python
class Estudiante:
def __init__(self, nombre, telefono, mail, num_reo, nickname):
self.nombre = nombre
self.telefono = telefono
self.mail = mail
self.num_reo = num_reo
self.nickname = nickname
def validar_nombre(self):
if not self.nombre.isalpha():
return False
return True
def validar_telefono(self):
if not self.telefono.isdigit():
return False
return True
def validar_mail(self):
if "@" not in self.mail or ".com" not in self.mail:
return False
return True
def validar_num_reo(self):
if not self.num_reo.isdigit():
return False
return True
def validar_nick(self):
if not self.nickname.isalpha():
return False
return True
def alta_estudiante(self):
if self.validar_nombre() and self.validar_telefono() and self.validar_mail() and self.validar_num_reo() and self.validar_nick():
print("El estudiante ha sido dado de alta con éxito.")
else:
print("Error en la información del estudiante.")
def main():
nombre = input("Ingrese el nombre del estudiante: ")
telefono = input("Ingrese el teléfono del estudiante: ")
mail = input("Ingrese el correo electrónico del estudiante: ")
num_reo = input("Ingrese el número de reo del estudiante: ")
nickname = input("Ingrese el nickname del estudiante: ")
estudiante = Estudiante(nombre, telefono, mail, num_reo, nickname)
estudiante.alta_estudiante()
if __name__ == "__main__":
main()
```
En este código, creamos una clase `Estudiante` con un constructor que inicializa los atributos del estudiante. Luego, creamos métodos para validar cada uno de los atributos: `validar_nombre`, `validar_telefono`, `validar_mail`, `validar_num_reo` y `validar_nick`. Estos métodos comprueban si el atributo cumple con las condiciones establecidas.
Finalmente, creamos un método `alta_estudiante` que llama a los métodos de validación y imprime un mensaje según el resultado.
En el método `main`, pedimos al usuario que ingrese la información del estudiante y creamos un objeto `Estudiante` con esa información. Luego, llamamos al método `alta_estudiante` para validar la información y dar de alta al estudiante.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname) {
this->nombre = nombre;
this->telefono = telefono;
this->mail = mail;
this->numeroReo = numeroReo;
this->nickname = nickname;
}
// Método para verificar si el correo electrónico es válido
bool verificarCorreo(std::string mail) {
return mail.find("@") != std::string::npos && mail.find(".com") != std::string::npos;
}
// Método para verificar si el nombre solo contiene letras
bool verificarNombre(std::string nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para verificar si el número de reo solo contiene números
bool verificarNumeroReo(std::string numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para registrar al estudiante
void registrarEstudiante() {
std::string nombre, telefono, mail, numeroReo, nickname;
// Pedir los datos al usuario
std::cout << "Ingrese su nombre: ";
std::cin >> nombre;
while (!verificarNombre(nombre)) {
std::cout << "El nombre solo puede contener letras. Por favor, ingrese su nombre nuevamente: ";
std::cin >> nombre;
}
std::cout << "Ingrese su teléfono: ";
std::cin >> telefono;
std::cout << "Ingrese su correo electrónico: ";
std::cin >> mail;
while (!verificarCorreo(mail)) {
std::cout << "El correo electrónico debe contener '@' y '.com'. Por favor, ingrese su correo electrónico nuevamente: ";
std::cin >> mail;
}
std::cout << "Ingrese su número de reo: ";
std::cin >> numeroReo;
while (!verificarNumeroReo(numeroReo)) {
std::cout << "El número de reo solo puede contener números. Por favor, ingrese su número de reo nuevamente: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese su nickname: ";
std::cin >> nickname;
// Crear un objeto Estudiante con los datos ingresados
Estudiante estudiante(nombre, telefono, mail, numeroReo, nickname);
// Mostrar los datos del estudiante
std::cout << "Estudiante registrado con éxito:" << std::endl;
std::cout << "Nombre: " << estudiante.nombre << std::endl;
std::cout << "Teléfono: " << estudiante.telefono << std::endl;
std::cout << "Correo electrónico: " << estudiante.mail << std::endl;
std::cout << "Número de reo: " << estudiante.numeroReo << std::endl;
std::cout << "Nickname: " << estudiante.nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.registrarEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un constructor que toma los datos del estudiante como parámetros. La clase también tiene métodos para verificar si el correo electrónico es válido, si el nombre solo contiene letras y si el número de reo solo contiene números.
El método `registrarEstudiante` pide los datos al usuario, verifica que sean válidos y crea un objeto `Estudiante` con los datos ingresados. Finalmente, muestra los datos del estudiante.
En el `main`, se crea un objeto `Estudiante` vacío y se llama al método `registrarEstudiante` para registrar al estudiante.
Aquí te muestro una versión modificada del código que utiliza las flechas del teclado para moverse en la matriz. Para hacer esto, utilizaremos la biblioteca `ncurses` que es una biblioteca de C++ para crear interfaces de usuario en modo texto.
Primero, debes instalar la biblioteca `ncurses` en tu sistema. En Ubuntu o distribuciones similares, puedes instalarla con el siguiente comando:
```bash
sudo apt-get install libncurses5-dev
```
Luego, puedes compilar y ejecutar el programa con el siguiente comando:
```bash
g++ -o movimiento movimiento.cpp -lncurses
```
Aquí te muestro el código:
```cpp
#include <ncurses.h>
#include <iostream>
// Constantes para las direcciones
const int DERECHA = 1;
const int IZQUIERDA = -1;
const int ARRIBA = -1;
const int ABAJO = 1;
// Estructura para representar la posición
struct Posicion {
int x;
int y;
};
int main() {
// Inicializar ncurses
initscr();
noecho();
curs_set(0);
// Tamaño de la matriz
int sizeX = 6;
int sizeY = 7;
// Matriz
int matrix[6][7] = {
{0, 1, 0, 0, 0, 0, 0},
{0, 1, 0, 0, 0, 0, 0},
{0, 1, 1, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0, 0},
{0, 0, 1, 1, 1, 0, 0},
{0, 0, 0, 0, 1, 0, 0}
};
// Posición inicial
Posicion posicion = {1, 1};
// Imprimir la matriz
mvprintw(0, 0, "Matriz:");
for (int i = 0; i < sizeX; i++) {
for (int j = 0; j < sizeY; j++) {
mvprintw(i + 1, j * 3, "%d ", matrix[i][j]);
}
mvprintw(i + 1, sizeY * 3, "\n");
}
// Imprimir la posición actual
mvprintw(posicion.y + 1, posicion.x * 3, "P");
// Bucle principal
while (true) {
// Obtener la entrada del usuario
int entrada = getch();
// Moverse según la entrada
switch (entrada) {
case KEY_UP:
if (posicion.y > 0 && matrix[posicion.y - 1][posicion.x] == 1) {
posicion.y--;
}
break;
case KEY_DOWN:
if (posicion.y < sizeX - 1 && matrix[posicion.y + 1][posicion.x] == 1) {
posicion.y++;
}
break;
case KEY_LEFT:
if (posicion.x > 0 && matrix[posicion.y][posicion.x - 1] == 1) {
posicion.x--;
}
break;
case KEY_RIGHT:
if (posicion.x < sizeY - 1 && matrix[posicion.y][posicion.x + 1] == 1) {
posicion.x++;
}
break;
}
// Imprimir la matriz actualizada
clear();
mvprintw(0, 0, "Matriz:");
for (int i = 0; i < sizeX; i++) {
for (int j = 0; j < sizeY; j++) {
mvprintw(i + 1, j * 3, "%d ", matrix[i][j]);
}
mvprintw(i + 1, sizeY * 3, "\n");
}
// Imprimir la posición actual
mvprintw(posicion.y + 1, posicion.x * 3, "P");
// Actualizar la pantalla
refresh();
}
// Terminar ncurses
endwin();
return 0;
}
```
Este código utiliza la biblioteca `ncurses` para crear una interfaz de usuario en modo texto y permite al usuario moverse en la matriz utilizando las flechas del teclado. La posición actual se indica con la letra "P".
Aquí te dejo un ejemplo de código en C++ que crea una matriz de 10x10 para jugar a Pacman con 2 enemigos:
```cpp
#include <iostream>
#include <vector>
// Estructura para representar una posición en la matriz
struct Posicion {
int x, y;
};
// Enum para representar los objetos en la matriz
enum Objeto {
VACIO,
PACMAN,
ENEMIGO1,
ENEMIGO2,
FRUTA
};
// Clase para representar la matriz
class Matriz {
private:
std::vector<std::vector<Objeto>> matriz;
int ancho, alto;
public:
// Constructor para inicializar la matriz
Matriz(int ancho, int alto) : ancho(ancho), alto(alto) {
matriz.resize(alto, std::vector<Objeto>(ancho, VACIO));
}
// Método para obtener el objeto en una posición
Objeto getObjeto(int x, int y) {
if (x >= 0 && x < ancho && y >= 0 && y < alto) {
return matriz[y][x];
} else {
return VACIO;
}
}
// Método para establecer el objeto en una posición
void setObjeto(int x, int y, Objeto objeto) {
if (x >= 0 && x < ancho && y >= 0 && y < alto) {
matriz[y][x] = objeto;
}
}
// Método para imprimir la matriz
void imprimir() {
for (int i = 0; i < alto; i++) {
for (int j = 0; j < ancho; j++) {
switch (matriz[i][j]) {
case VACIO:
std::cout << " ";
break;
case PACMAN:
std::cout << "P";
break;
case ENEMIGO1:
std::cout << "E1";
break;
case ENEMIGO2:
std::cout << "E2";
break;
case FRUTA:
std::cout << "F";
break;
}
}
std::cout << std::endl;
}
}
};
int main() {
// Inicializar la matriz
Matriz matriz(10, 10);
// Establecer la posición de Pacman
matriz.setObjeto(5, 5, PACMAN);
// Establecer la posición de los enemigos
matriz.setObjeto(3, 3, ENEMIGO1);
matriz.setObjeto(7, 7, ENEMIGO2);
// Imprimir la matriz
matriz.imprimir();
return 0;
}
```
Este código crea una matriz de 10x10 y establece la posición de Pacman en el centro de la matriz. También establece la posición de los dos enemigos en la esquina superior izquierda y la esquina inferior derecha de la matriz, respectivamente. La matriz se imprime en la consola.
Recuerda que este es solo un ejemplo básico y que para crear un juego de Pacman completo necesitarás agregar más funcionalidad, como la lógica de movimiento de Pacman y los enemigos, la gestión de la puntuación, etc.
Espero que esto te ayude a empezar a desarrollar tu juego de Pacman. ¡Buena suerte!
Aquí te dejo un ejemplo de código en C++ que crea un laberinto de 6x7 con un personaje representado por un asterisco (*) y utiliza un ciclo anidado para mover al personaje:
```c
#include <iostream>
using namespace std;
int main() {
// Laberinto 6x7
int laberinto[6][7] = {
{1, 1, 1, 1, 1, 1, 1},
{1, 0, 0, 0, 0, 0, 1},
{1, 0, 1, 1, 1, 0, 1},
{1, 0, 1, 0, 1, 0, 1},
{1, 0, 1, 1, 1, 0, 1},
{1, 1, 1, 1, 1, 1, 1}
};
int x = 1, y = 1; // Posición inicial del personaje
while (true) {
// Imprimir laberinto
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 7; j++) {
if (i == x && j == y) {
cout << "*"; // Personaje
} else {
cout << laberinto[i][j]; // Laberinto
}
}
cout << endl;
}
// Pedir movimiento
char movimiento;
cout << "Ingrese movimiento (W/A/S/D): ";
cin >> movimiento;
// Realizar movimiento
switch (movimiento) {
case 'W':
if (x > 0 && laberinto[x-1][y] == 1) {
x--;
}
break;
case 'A':
if (y > 0 && laberinto[x][y-1] == 1) {
y--;
}
break;
case 'S':
if (x < 5 && laberinto[x+1][y] == 1) {
x++;
}
break;
case 'D':
if (y < 6 && laberinto[x][y+1] == 1) {
y++;
}
break;
}
// Verificar si el personaje ha salido del laberinto
if (x == 0 || x == 5 || y == 0 || y == 6) {
cout << "¡Has salido del laberinto!" << endl;
break;
}
}
return 0;
}
```
Este código crea un laberinto de 6x7 con un personaje representado por un asterisco (*) en la posición inicial (1, 1). El personaje puede moverse en las cuatro direcciones (W/A/S/D) y el laberinto se imprime después de cada movimiento. Si el personaje sale del laberinto, el programa termina.
Aquí te dejo un ejemplo de cómo podrías implementar el programa que solicitas en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find('@') == std::string::npos || mail.find('.com') == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante dado de alta con éxito." << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un método `altaEstudiante()` que solicita la información del estudiante y la valida según las condiciones establecidas. Si la información no es válida, el programa solicita que se ingrese nuevamente. Finalmente, muestra la información del estudiante dado de alta con éxito.
Aquí te dejo un ejemplo de cómo podrías implementar el programa que solicitas en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find('@') == std::string::npos || mail.find('.com') == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante creado con éxito!" << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un método `altaEstudiante()` que solicita la información del estudiante y la valida según las reglas establecidas. Si la información no es válida, el programa solicita que se ingrese nuevamente. Finalmente, muestra la información del estudiante creado con éxito.
Aquí te dejo un ejemplo de cómo podrías implementar el programa que solicitas en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("0123456789") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find(".com") == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante dado de alta con éxito!" << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un método `altaEstudiante()` que solicita la información del estudiante y la valida según las reglas establecidas. Si la información no es válida, el programa solicita que se ingrese nuevamente. Finalmente, muestra la información del estudiante dado de alta con éxito.
En el `main()`, se crea un objeto `Estudiante` y se llama al método `altaEstudiante()` para iniciar el proceso de alta del estudiante.
Aquí te dejo un ejemplo de código en C++ que implementa la secuencia de Fibonacci utilizando un bucle `while`:
```cpp
#include <iostream>
int main() {
int n, i = 0, j = 1, k = 0;
std::cout << "Ingrese el número de términos para la secuencia de Fibonacci: ";
std::cin >> n;
if (n <= 0) {
std::cout << "Error: El número de términos debe ser positivo.";
return 1;
}
std::cout << "Secuencia de Fibonacci: ";
while (k < n) {
std::cout << k << " ";
i = j;
j = k;
k = i + j;
}
return 0;
}
```
En este código, se pide al usuario que ingrese el número de términos para la secuencia de Fibonacci. Luego, se utiliza un bucle `while` para generar los términos de la secuencia. En cada iteración, se imprime el término actual y se actualizan los valores de `i`, `j` y `k` para calcular el siguiente término.
Por ejemplo, si el usuario ingresa `10`, el programa imprimirá la secuencia de Fibonacci hasta el décimo término:
```
Secuencia de Fibonacci: 0 1 1 2 3 5 8 13 21 34
```
Espero que esto te ayude. ¡Si tienes alguna pregunta o necesitas más ayuda, no dudes en preguntar!
Aquí te muestro un ejemplo de cómo podrías implementar el programa que solicitas en C++:
```cpp
#include <iostream>
// Función para pedir los valores de la matriz
void pedirValores(int matriz[2][3]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
std::cout << "Ingrese el valor de la posición [" << i << "][" << j << "]: ";
std::cin >> matriz[i][j];
}
}
}
// Función para calcular la suma de los elementos de la matriz
int calcularSuma(int matriz[2][3]) {
int suma = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
suma += matriz[i][j];
}
}
return suma;
}
// Función para recorrer la matriz con un ciclo while
void recorrerWhile(int matriz[2][3]) {
int i = 0;
while (i < 2) {
int j = 0;
while (j < 3) {
std::cout << "Valor de la posición [" << i << "][" << j << "]: " << matriz[i][j] << std::endl;
j++;
}
i++;
}
}
// Función para recorrer la matriz con un ciclo for
void recorrerFor(int matriz[2][3]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
std::cout << "Valor de la posición [" << i << "][" << j << "]: " << matriz[i][j] << std::endl;
}
}
}
// Función para recorrer la matriz con un ciclo do-while
void recorrerDoWhile(int matriz[2][3]) {
int i = 0;
do {
int j = 0;
do {
std::cout << "Valor de la posición [" << i << "][" << j << "]: " << matriz[i][j] << std::endl;
j++;
} while (j < 3);
i++;
} while (i < 2);
}
int main() {
int matriz[2][3];
// Pedir los valores de la matriz
pedirValores(matriz);
// Calcular la suma de los elementos de la matriz
int suma = calcularSuma(matriz);
std::cout << "La suma de los elementos de la matriz es: " << suma << std::endl;
// Recorrer la matriz con un ciclo while
std::cout << "Recorriendo la matriz con un ciclo while:" << std::endl;
recorrerWhile(matriz);
// Recorrer la matriz con un ciclo for
std::cout << "\nRecorriendo la matriz con un ciclo for:" << std::endl;
recorrerFor(matriz);
// Recorrer la matriz con un ciclo do-while
std::cout << "\nRecorriendo la matriz con un ciclo do-while:" << std::endl;
recorrerDoWhile(matriz);
return 0;
}
```
Este programa declara una matriz 2x3, pide al usuario ingresar los valores, calcula la suma de los elementos y recorre la matriz con tres tipos de ciclos diferentes: while, for y do-while.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname) {
this->nombre = nombre;
this->telefono = telefono;
this->mail = mail;
this->numeroReo = numeroReo;
this->nickname = nickname;
}
// Método para verificar si el correo electrónico es válido
bool verificarCorreo(std::string mail) {
return mail.find("@") != std::string::npos && mail.find(".com") != std::string::npos;
}
// Método para verificar si el nombre solo contiene letras
bool verificarNombre(std::string nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para verificar si el número de reo solo contiene números
bool verificarNumeroReo(std::string numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para registrar al estudiante
void registrarEstudiante() {
std::string nombre, telefono, mail, numeroReo, nickname;
// Pedir los datos al usuario
std::cout << "Ingrese su nombre: ";
std::cin >> nombre;
while (!verificarNombre(nombre)) {
std::cout << "El nombre solo puede contener letras. Por favor, ingrese su nombre nuevamente: ";
std::cin >> nombre;
}
std::cout << "Ingrese su teléfono: ";
std::cin >> telefono;
std::cout << "Ingrese su correo electrónico: ";
std::cin >> mail;
while (!verificarCorreo(mail)) {
std::cout << "El correo electrónico debe contener '@' y '.com'. Por favor, ingrese su correo electrónico nuevamente: ";
std::cin >> mail;
}
std::cout << "Ingrese su número de reo: ";
std::cin >> numeroReo;
while (!verificarNumeroReo(numeroReo)) {
std::cout << "El número de reo solo puede contener números. Por favor, ingrese su número de reo nuevamente: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese su nickname: ";
std::cin >> nickname;
// Crear un objeto Estudiante con los datos ingresados
Estudiante estudiante(nombre, telefono, mail, numeroReo, nickname);
// Mostrar los datos del estudiante
std::cout << "Estudiante registrado con éxito:" << std::endl;
std::cout << "Nombre: " << estudiante.nombre << std::endl;
std::cout << "Teléfono: " << estudiante.telefono << std::endl;
std::cout << "Correo electrónico: " << estudiante.mail << std::endl;
std::cout << "Número de reo: " << estudiante.numeroReo << std::endl;
std::cout << "Nickname: " << estudiante.nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.registrarEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un constructor que toma los datos del estudiante como parámetros. La clase también tiene métodos para verificar si el correo electrónico es válido, si el nombre solo contiene letras y si el número de reo solo contiene números.
El método `registrarEstudiante` pide los datos al usuario, verifica que sean válidos y crea un objeto `Estudiante` con los datos ingresados. Finalmente, muestra los datos del estudiante.
En el `main`, se crea un objeto `Estudiante` vacío y se llama al método `registrarEstudiante` para registrar al estudiante.
Aquí te dejo un ejemplo de código en C++ que cumple con tus requisitos:
```c
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <windows.h>
using namespace std;
// Definición de la estructura para el personaje
struct Personaje {
int x, y;
int vidas;
};
// Definición de la estructura para el enemigo
struct Enemigo {
int x, y;
};
// Definición de la estructura para la llave
struct Llave {
int x, y;
};
// Definición de la matriz de laberinto
int laberinto[10][10] = {
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 1},
{1, 0, 1, 1, 1, 1, 1, 1, 0, 1},
{1, 0, 1, 0, 0, 0, 0, 1, 0, 1},
{1, 0, 1, 0, 1, 1, 0, 1, 0, 1},
{1, 0, 1, 0, 1, 0, 0, 1, 0, 1},
{1, 0, 1, 0, 1, 0, 1, 1, 0, 1},
{1, 0, 0, 0, 1, 0, 1, 0, 0, 1},
{1, 1, 1, 1, 1, 0, 1, 1, 1, 1},
{1, 0, 0, 0, 0, 0, 0, 0, 0, 1}
};
// Definición de las variables para el personaje, enemigos y llaves
Personaje personaje;
Enemigo enemigo1, enemigo2;
Llave llave;
// Función para inicializar el laberinto
void inicializarLaberinto() {
// Inicializar el personaje en la posición (1, 1)
personaje.x = 1;
personaje.y = 1;
personaje.vidas = 2;
// Inicializar los enemigos en posiciones aleatorias
srand(time(0));
enemigo1.x = rand() % 10;
enemigo1.y = rand() % 10;
while (laberinto[enemigo1.x][enemigo1.y] == 0) {
enemigo1.x = rand() % 10;
enemigo1.y = rand() % 10;
}
enemigo2.x = rand() % 10;
enemigo2.y = rand() % 10;
while (laberinto[enemigo2.x][enemigo2.y] == 0 || (enemigo2.x == enemigo1.x && enemigo2.y == enemigo1.y)) {
enemigo2.x = rand() % 10;
enemigo2.y = rand() % 10;
}
// Inicializar la llave en una posición aleatoria
llave.x = rand() % 10;
llave.y = rand() % 10;
while (laberinto[llave.x][llave.y] == 0) {
llave.x = rand() % 10;
llave.y = rand() % 10;
}
}
// Función para dibujar el laberinto
void dibujarLaberinto() {
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
if (laberinto[i][j] == 0) {
cout << "# ";
} else {
cout << " ";
}
}
cout << endl;
}
}
// Función para actualizar el laberinto
void actualizarLaberinto() {
// Actualizar la posición del personaje
if (GetAsyncKeyState(VK_UP) < 0) {
if (laberinto[personaje.x][personaje.y - 1] == 1) {
personaje.y--;
}
}
if (GetAsyncKeyState(VK_DOWN) < 0) {
if (laberinto[personaje.x][personaje.y + 1] == 1) {
personaje.y++;
}
}
if (GetAsyncKeyState(VK_LEFT) < 0) {
if (laberinto[personaje.x - 1][personaje.y] == 1) {
personaje.x--;
}
}
if (GetAsyncKeyState(VK_RIGHT) < 0) {
if (laberinto[personaje.x + 1][personaje.y] == 1) {
personaje.x++;
}
}
// Actualizar la posición de los enemigos
if (enemigo1.x == personaje.x && enemigo1.y == personaje.y) {
personaje.vidas--;
enemigo1.x = rand() % 10;
enemigo1.y = rand() % 10;
while (laberinto[enemigo1.x][enemigo1.y] == 0) {
enemigo1.x = rand() % 10;
enemigo1.y = rand() % 10;
}
}
if (enemigo2.x == personaje.x && enemigo2.y == personaje.y) {
personaje.vidas--;
enemigo2.x = rand() % 10;
enemigo2.y = rand() % 10;
while (laberinto[enemigo2.x][enemigo2.y] == 0 || (enemigo2.x == enemigo1.x && enemigo2.y == enemigo1.y)) {
enemigo2.x = rand() % 10;
enemigo2.y = rand() % 10;
}
}
// Comprobar si se ha encontrado la llave
if (personaje.x == llave.x && personaje.y == llave.y) {
cout << "¡Has encontrado la llave!" << endl;
// Aquí puedes agregar la lógica para avanzar al siguiente nivel
}
}
int main() {
inicializarLaberinto();
while (true) {
system("cls");
dibujarLaberinto();
cout << "Vidas: " << personaje.vidas << endl;
cout << "Posición del personaje: (" << personaje.x << ", " << personaje.y << ")" << endl;
cout << "Posición del enemigo 1: (" << enemigo1.x << ", " << enemigo1.y << ")" << endl;
cout << "Posición del enemigo 2: (" << enemigo2.x << ", " << enemigo2.y << ")" << endl;
cout << "Posición de la llave: (" << llave.x << ", " << llave.y << ")" << endl;
actualizarLaberinto();
if (personaje.vidas <= 0) {
cout << "¡Has perdido!" << endl;
break;
}
Sleep(100);
}
return 0;
}
```
Este código crea un laberinto de 10x10 con un personaje que se puede mover con las teclas W, A, S, D. Los enemigos se mueven aleatoriamente y el personaje debe evitar que los enemigos lo alcancen. La llave se encuentra en una posición aleatoria y el personaje debe encontrarla para avanzar al siguiente nivel. El juego termina cuando el personaje pierde todas sus vidas.
Recuerda que este es solo un ejemplo y puedes personalizarlo según tus necesidades.
Aquí te muestro una versión modificada del código que permite moverte usando las flechas del teclado. Para hacer esto, utilizaremos la biblioteca `ncurses` que es una biblioteca de C++ para crear interfaces de usuario en modo texto.
Primero, debes instalar la biblioteca `ncurses` en tu sistema. En Ubuntu o distribuciones similares, puedes instalarla con el siguiente comando:
```bash
sudo apt-get install libncurses5-dev
```
Luego, puedes compilar y ejecutar el programa con el siguiente comando:
```bash
g++ -o movimiento movimiento.cpp -lncurses
```
Aquí te muestro el código:
```cpp
#include <ncurses.h>
#include <iostream>
// Constantes para la dirección de movimiento
const int UP = 0;
const int DOWN = 1;
const int LEFT = 2;
const int RIGHT = 3;
// Estructura para representar la posición del personaje
struct Posicion {
int x;
int y;
};
// Función para dibujar la matriz
void dibujarMatriz(int matrix[6][7]) {
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 7; j++) {
if (i == 0 && j == 0) {
mvprintw(i, j, "P");
} else {
mvprintw(i, j, "%d", matrix[i][j]);
}
}
}
}
int main() {
// Inicializar ncurses
initscr();
noecho();
curs_set(0);
// Definir la matriz
int sizeX = 6;
int sizeY = 7;
int matrix[6][7] = {
{0, 1, 0, 0, 0, 0, 0},
{0, 1, 0, 0, 0, 0, 0},
{0, 1, 1, 0, 0, 0, 0},
{0, 0, 1, 0, 0, 0, 0},
{0, 0, 1, 1, 1, 0, 0},
{0, 0, 0, 0, 1, 0, 0}
};
// Definir la posición inicial del personaje
Posicion posicion = {0, 0};
// Dibujar la matriz
dibujarMatriz(matrix);
// Mover el personaje
while (true) {
// Obtener la dirección de movimiento
int direccion = getch();
// Mover el personaje según la dirección
switch (direccion) {
case 'w':
if (posicion.y > 0) {
posicion.y--;
}
break;
case 's':
if (posicion.y < 5) {
posicion.y++;
}
break;
case 'a':
if (posicion.x > 0) {
posicion.x--;
}
break;
case 'd':
if (posicion.x < 6) {
posicion.x++;
}
break;
}
// Dibujar la matriz actualizada
clear();
dibujarMatriz(matrix);
mvprintw(posicion.y, posicion.x, "P");
// Actualizar la pantalla
refresh();
}
// Terminar ncurses
endwin();
return 0;
}
```
En este código, el personaje se mueve según la dirección obtenida con `getch()`. La dirección se puede obtener con las teclas `w`, `a`, `s` y `d`. El personaje se dibuja en la posición actualizada en la matriz.
Aquí te dejo un ejemplo de código en C++ que implementa el juego "Adivina el número" con un rango de 1 a 10 números por adivinar. El juego utiliza un bucle `while` para permitir al usuario intentar adivinar el número tantas veces como desee, y utiliza `if` para verificar si el número ingresado es válido (no negativo) y si es correcto o no.
```c
#include <iostream>
int main() {
int numeroSecreto = 7; // Número secreto entre 1 y 10
int intentos = 0;
int numeroIngresado;
std::cout << "Bienvenido al juego 'Adivina el número'!" << std::endl;
std::cout << "El número secreto está entre 1 y 10." << std::endl;
while (true) {
std::cout << "Ingrese un número entre 1 y 10: ";
std::cin >> numeroIngresado;
// Verificar si el número ingresado es válido (no negativo)
if (numeroIngresado < 1) {
std::cout << "Error: El número ingresado no es válido. Por favor, ingrese un número positivo." << std::endl;
continue;
}
// Verificar si el número ingresado es correcto
if (numeroIngresado == numeroSecreto) {
std::cout << "¡Felicidades! Adivinaste el número secreto en " << intentos + 1 << " intentos." << std::endl;
break;
} else if (numeroIngresado < numeroSecreto) {
std::cout << "El número secreto es mayor que el número ingresado." << std::endl;
} else {
std::cout << "El número secreto es menor que el número ingresado." << std::endl;
}
intentos++;
}
return 0;
}
```
En este código, el número secreto es `7` y el rango de números por adivinar es entre 1 y 10. El juego utiliza un bucle `while` para permitir al usuario intentar adivinar el número tantas veces como desee. El juego verifica si el número ingresado es válido (no negativo) y si es correcto o no. Si el número ingresado es correcto, el juego muestra un mensaje de felicitación y termina. Si el número ingresado es incorrecto, el juego muestra un mensaje de ayuda para que el usuario pueda intentar de nuevo.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
#include <regex>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
if (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
this->nombre = nombre;
} else {
std::cout << "El nombre no puede contener números." << std::endl;
}
}
void setTelefono(const std::string& telefono) {
this->telefono = telefono;
}
void setMail(const std::string& mail) {
std::regex patron("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
if (std::regex_match(mail, patron)) {
this->mail = mail;
} else {
std::cout << "El correo electrónico no es válido." << std::endl;
}
}
void setNumeroReo(const std::string& numeroReo) {
std::regex patron("^[0-9]+$");
if (std::regex_match(numeroReo, patron)) {
this->numeroReo = numeroReo;
} else {
std::cout << "El número de reo solo puede contener números." << std::endl;
}
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void darDeAlta() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.darDeAlta();
return 0;
}
```
Este programa define una clase `Estudiante` con métodos para establecer los atributos del estudiante y un método `darDeAlta` para mostrar la información del estudiante. En el método `main`, se crea un objeto `Estudiante` y se solicita al usuario que ingrese la información del estudiante. Luego, se llama al método `darDeAlta` para mostrar la información del estudiante.
Aquí te muestro un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <cmath>
// Función para calcular el perímetro de un polígono regular
double calcularPerimetro(int lados, double lado) {
return lados * lado;
}
// Función para calcular la apotema de un polígono regular
double calcularApotema(int lados, double lado) {
return lado / (2 * std::tan(M_PI / lados));
}
// Función para calcular el área de un polígono regular
double calcularArea(int lados, double lado) {
double apotema = calcularApotema(lados, lado);
double perimetro = calcularPerimetro(lados, lado);
return (perimetro * apotema) / 2;
}
// Función para mostrar el menú de opciones
void mostrarMenu() {
std::cout << "Seleccione un polígono regular para calcular su área:" << std::endl;
std::cout << "1. Pentágono" << std::endl;
std::cout << "2. Hexágono" << std::endl;
std::cout << "3. Heptágono" << std::endl;
std::cout << "4. Octágono" << std::endl;
}
// Función principal
int main() {
int lados[] = {5, 6, 7, 8};
double lado;
int opcion;
mostrarMenu();
std::cout << "Ingrese la opción del polígono: ";
std::cin >> opcion;
if (opcion >= 1 && opcion <= 4) {
std::cout << "Ingrese la longitud de un lado del polígono: ";
std::cin >> lado;
double area = calcularArea(lados[opcion - 1], lado);
std::cout << "El área del polígono es: " << area << std::endl;
} else {
std::cout << "Opción inválida" << std::endl;
}
return 0;
}
```
En este programa, se definen cuatro funciones:
* `calcularPerimetro`: Calcula el perímetro de un polígono regular a partir de la longitud de un lado y el número de lados.
* `calcularApotema`: Calcula la apotema de un polígono regular a partir de la longitud de un lado y el número de lados.
* `calcularArea`: Calcula el área de un polígono regular a partir de la longitud de un lado y el número de lados.
* `mostrarMenu`: Muestra el menú de opciones para seleccionar un polígono regular.
En la función principal, se muestra el menú de opciones y se solicita al usuario que ingrese la opción del polígono. Luego, se solicita la longitud de un lado del polígono y se calcula el área utilizando la función `calcularArea`. Finalmente, se muestra el resultado en la consola.
Aquí te dejo un ejemplo de código en C++ que calcula el promedio general de un grupo de 10 personas, donde cada persona tiene una calificación asociada. Utiliza la función `string` para almacenar los nombres de las personas.
```cpp
#include <iostream>
#include <string>
#include <vector>
// Estructura para almacenar la información de cada persona
struct Persona {
std::string nombre;
double calificacion;
};
int main() {
// Vector para almacenar las personas
std::vector<Persona> personas;
// Pedir la información de cada persona
for (int i = 0; i < 10; i++) {
Persona persona;
std::cout << "Ingrese el nombre de la persona " << i + 1 << ": ";
std::cin >> persona.nombre;
std::cout << "Ingrese la calificación de la persona " << i + 1 << ": ";
std::cin >> persona.calificacion;
// Agregar la persona al vector
personas.push_back(persona);
}
// Calcular el promedio general
double sumaCalificaciones = 0;
for (const auto& persona : personas) {
sumaCalificaciones += persona.calificacion;
}
double promedioGeneral = sumaCalificaciones / personas.size();
// Mostrar el promedio general
std::cout << "El promedio general de las calificaciones es: " << promedioGeneral << std::endl;
// Mostrar las calificaciones de cada persona
std::cout << "Calificaciones de cada persona:" << std::endl;
for (const auto& persona : personas) {
std::cout << persona.nombre << ": " << persona.calificacion << std::endl;
}
return 0;
}
```
Este código utiliza una estructura `Persona` para almacenar la información de cada persona, incluyendo su nombre y calificación. Luego, utiliza un vector para almacenar las personas y pedir la información de cada una de ellas. Finalmente, calcula el promedio general de las calificaciones y lo muestra en pantalla, junto con las calificaciones de cada persona.
Recuerda que debes compilar y ejecutar el código en un entorno de desarrollo como Visual Studio o un compilador de línea de comandos como `g++`.
Aquí te dejo un ejemplo de cómo podrías implementar un laberinto en C++ utilizando el código que proporcionaste. En este ejemplo, el laberinto se representa como una matriz bidimensional, donde los valores 0 representan espacios vacíos y los valores 1 representan paredes.
```cpp
#include <iostream>
#include <vector>
// Estructura para representar la posición en el laberinto
struct Posicion {
int x;
int y;
};
// Clase para representar el laberinto
class Laberinto {
private:
int sizeX;
int sizeY;
std::vector<std::vector<int>> matriz;
public:
// Constructor para inicializar el laberinto
Laberinto(int sizeX, int sizeY) {
this->sizeX = sizeX;
this->sizeY = sizeY;
matriz.resize(sizeX, std::vector<int>(sizeY, 0));
}
// Método para inicializar la matriz del laberinto
void inicializarMatriz(int** matriz) {
for (int i = 0; i < sizeX; i++) {
for (int j = 0; j < sizeY; j++) {
this->matriz[i][j] = matriz[i][j];
}
}
}
// Método para imprimir el laberinto
void imprimirLaberinto() {
for (int i = 0; i < sizeX; i++) {
for (int j = 0; j < sizeY; j++) {
std::cout << matriz[i][j] << " ";
}
std::cout << std::endl;
}
}
// Método para verificar si una posición es válida
bool esPosicionValida(int x, int y) {
return (x >= 0 && x < sizeX && y >= 0 && y < sizeY);
}
// Método para verificar si una posición está bloqueada por una pared
bool estaBloqueada(int x, int y) {
return matriz[x][y] == 1;
}
// Método para moverse a una posición
void moverse(Posicion posicion) {
if (esPosicionValida(posicion.x, posicion.y) && !estaBloqueada(posicion.x, posicion.y)) {
std::cout << "Se ha movido a la posición (" << posicion.x << ", " << posicion.y << ")" << std::endl;
} else {
std::cout << "No se puede mover a la posición (" << posicion.x << ", " << posicion.y << ")" << std::endl;
}
}
};
int main() {
int sizeX = 6;
int sizeY = 7;
int** matriz = new int*[sizeX];
for (int i = 0; i < sizeX; i++) {
matriz[i] = new int[sizeY];
for (int j = 0; j < sizeY; j++) {
matriz[i][j] = 0;
}
}
matriz[0][1] = 1;
matriz[1][1] = 1;
matriz[2][1] = 1;
matriz[2][2] = 1;
matriz[3][2] = 1;
matriz[4][2] = 1;
matriz[4][3] = 1;
matriz[4][4] = 1;
matriz[5][4] = 1;
Laberinto laberinto(sizeX, sizeY);
laberinto.inicializarMatriz(matriz);
laberinto.imprimirLaberinto();
Posicion posicion;
posicion.x = 0;
posicion.y = 0;
laberinto.moverse(posicion);
delete[] matriz[0];
delete[] matriz;
return 0;
}
```
En este ejemplo, se crea una clase `Laberinto` que representa el laberinto. La clase tiene métodos para inicializar la matriz del laberinto, imprimir el laberinto, verificar si una posición es válida y verificar si una posición está bloqueada por una pared. El método `moverse` permite moverse a una posición en el laberinto.
En el `main`, se crea un laberinto con una matriz de 6x7 y se inicializa con algunas paredes. Luego, se imprime el laberinto y se mueve a la posición (0, 0).
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
if (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
this->nombre = nombre;
} else {
std::cout << "El nombre no puede contener números." << std::endl;
}
}
void setTelefono(const std::string& telefono) {
this->telefono = telefono;
}
void setMail(const std::string& mail) {
if (mail.find('@') != std::string::npos && mail.find('.com') != std::string::npos) {
this->mail = mail;
} else {
std::cout << "El correo electrónico debe contener '@' y '.com'." << std::endl;
}
}
void setNumeroReo(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
std::cout << "El número de reo solo puede contener números." << std::endl;
return;
}
}
this->numeroReo = numeroReo;
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void mostrarDatos() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.mostrarDatos();
return 0;
}
```
Este programa crea una clase `Estudiante` con métodos para establecer los datos del estudiante y un método para mostrar los datos. En el método `main`, se crea un objeto `Estudiante` y se solicita al usuario que ingrese los datos del estudiante. Luego, se llama al método `mostrarDatos` para mostrar los datos del estudiante.
Aquí te dejo un ejemplo de código en C++ que implementa el juego "Adivina el número" con un rango de 1 a 10 números por adivinar. El juego utiliza un bucle `while` para permitir al usuario intentar adivinar el número tantas veces como desee, y utiliza `if` para verificar si el número ingresado es válido (no negativo) y si es correcto o no.
```c
#include <iostream>
int main() {
int numeroSecreto = 7; // Número secreto entre 1 y 10
int intentos = 0;
int numeroIngresado;
std::cout << "Bienvenido al juego 'Adivina el número'!" << std::endl;
std::cout << "El número secreto está entre 1 y 10." << std::endl;
while (true) {
std::cout << "Ingrese un número entre 1 y 10: ";
std::cin >> numeroIngresado;
// Verificar si el número ingresado es válido (no negativo)
if (numeroIngresado < 1) {
std::cout << "Error: El número ingresado no es válido. Por favor, ingrese un número positivo." << std::endl;
continue;
}
// Verificar si el número ingresado es correcto
if (numeroIngresado == numeroSecreto) {
std::cout << "¡Felicidades! Adivinaste el número secreto en " << intentos + 1 << " intentos." << std::endl;
break;
} else if (numeroIngresado < numeroSecreto) {
std::cout << "El número secreto es mayor que el número ingresado." << std::endl;
} else {
std::cout << "El número secreto es menor que el número ingresado." << std::endl;
}
intentos++;
}
return 0;
}
```
En este código, el número secreto es `7` y el rango de números por adivinar es entre 1 y 10. El juego utiliza un bucle `while` para permitir al usuario intentar adivinar el número tantas veces como desee. El juego verifica si el número ingresado es válido (no negativo) y si es correcto o no. Si el número ingresado es correcto, el juego muestra un mensaje de felicitación y termina. Si el número ingresado es incorrecto, el juego muestra un mensaje de ayuda para que el usuario pueda intentar de nuevo.
Aquí te muestro un ejemplo de código en C++ que calcula el promedio de 3 notas utilizando 2 funciones:
```cpp
#include <iostream>
// Función para leer una nota
double leerNota() {
double nota;
std::cout << "Ingrese la nota: ";
std::cin >> nota;
return nota;
}
// Función para calcular el promedio de 3 notas
double calcularPromedio(double nota1, double nota2, double nota3) {
return (nota1 + nota2 + nota3) / 3;
}
int main() {
double nota1, nota2, nota3;
// Leer las 3 notas
nota1 = leerNota();
nota2 = leerNota();
nota3 = leerNota();
// Calcular el promedio
double promedio = calcularPromedio(nota1, nota2, nota3);
// Mostrar el promedio
std::cout << "El promedio de las 3 notas es: " << promedio << std::endl;
return 0;
}
```
En este código, la función `leerNota()` se encarga de leer una nota del usuario y devolverla como un valor `double`. La función `calcularPromedio()` recibe las 3 notas como parámetros y devuelve el promedio de ellas. En el `main()`, se leen las 3 notas utilizando la función `leerNota()`, se calcula el promedio utilizando la función `calcularPromedio()` y se muestra el resultado en la consola.
Aquí te muestro un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <cmath>
// Función para calcular el perímetro de un polígono regular
double calcularPerimetro(int lados, double lado) {
return lados * lado;
}
// Función para calcular la apotema de un polígono regular
double calcularApotema(int lados, double lado) {
return std::sqrt(std::pow(lado, 2) - std::pow(lado / 2, 2));
}
// Función para calcular el área de un polígono regular
double calcularArea(int lados, double lado) {
double apotema = calcularApotema(lados, lado);
double perimetro = calcularPerimetro(lados, lado);
return (perimetro * apotema) / 2;
}
// Función para mostrar opciones de polígonos
void mostrarOpciones() {
std::cout << "Seleccione un polígono regular:" << std::endl;
std::cout << "1. Pentágono" << std::endl;
std::cout << "2. Hexágono" << std::endl;
std::cout << "3. Heptágono" << std::endl;
std::cout << "4. Octágono" << std::endl;
}
// Función para obtener la longitud de un lado de un polígono regular
void obtenerLado(int &lados, double &lado) {
std::cout << "Ingrese la longitud de un lado del polígono: ";
std::cin >> lado;
lados = 5; // Por defecto, asumimos que es un pentágono
switch (lados) {
case 5:
std::cout << "Pentágono seleccionado." << std::endl;
break;
case 6:
std::cout << "Hexágono seleccionado." << std::endl;
break;
case 7:
std::cout << "Heptágono seleccionado." << std::endl;
break;
case 8:
std::cout << "Octágono seleccionado." << std::endl;
break;
default:
std::cout << "Polígono no válido." << std::endl;
exit(1);
}
}
int main() {
int lados;
double lado;
mostrarOpciones();
std::cout << "Ingrese el número del polígono que desea seleccionar: ";
std::cin >> lados;
obtenerLado(lados, lado);
double area = calcularArea(lados, lado);
std::cout << "El área del polígono es: " << area << std::endl;
return 0;
}
```
Este programa define cuatro funciones: `calcularPerimetro`, `calcularApotema` y `calcularArea` para calcular el perímetro, la apotema y el área de un polígono regular, respectivamente. La función `mostrarOpciones` muestra las opciones de polígonos disponibles y la función `obtenerLado` obtiene la longitud de un lado del polígono seleccionado.
En el `main`, se muestra la lista de opciones de polígonos y se solicita al usuario que ingrese el número del polígono que desea seleccionar. Luego, se llama a la función `obtenerLado` para obtener la longitud de un lado del polígono seleccionado y se calcula el área del polígono utilizando la función `calcularArea`. Finalmente, se muestra el área del polígono en la consola.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find('@') == std::string::npos || mail.find('.com') == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante creado con éxito!" << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un método `altaEstudiante()` que solicita la información del estudiante y la valida según las reglas establecidas. Si la información no cumple con las reglas, el programa solicita que se ingrese nuevamente. Finalmente, el programa muestra la información del estudiante creado con éxito.
Aquí te dejo un ejemplo de código en C++ que calcula el promedio general de un grupo de 10 personas, donde cada persona tiene una calificación asociada. Utiliza la función `string` para almacenar los nombres de las personas.
```cpp
#include <iostream>
#include <string>
#include <vector>
// Estructura para almacenar la información de cada persona
struct Persona {
std::string nombre;
double calificacion;
};
int main() {
// Vector para almacenar las personas
std::vector<Persona> personas;
// Pedir la información de cada persona
for (int i = 0; i < 10; i++) {
Persona persona;
std::cout << "Ingrese el nombre de la persona " << i + 1 << ": ";
std::cin >> persona.nombre;
std::cout << "Ingrese la calificación de la persona " << i + 1 << ": ";
std::cin >> persona.calificacion;
// Agregar la persona al vector
personas.push_back(persona);
}
// Calcular el promedio general
double sumaCalificaciones = 0;
for (const auto& persona : personas) {
sumaCalificaciones += persona.calificacion;
}
double promedioGeneral = sumaCalificaciones / personas.size();
// Mostrar el promedio general
std::cout << "El promedio general de las calificaciones es: " << promedioGeneral << std::endl;
// Mostrar las calificaciones de cada persona
std::cout << "Calificaciones de cada persona:" << std::endl;
for (const auto& persona : personas) {
std::cout << persona.nombre << ": " << persona.calificacion << std::endl;
}
return 0;
}
```
Este código utiliza una estructura `Persona` para almacenar la información de cada persona, incluyendo su nombre y calificación. Luego, utiliza un vector para almacenar las personas y pedir la información de cada una de ellas. Finalmente, calcula el promedio general de las calificaciones y lo muestra en pantalla, junto con las calificaciones de cada persona.
Recuerda que debes compilar y ejecutar el código en un entorno de desarrollo como Visual Studio o un compilador de línea de comandos como `g++`.
Aquí te muestro un ejemplo de cómo podrías implementar el programa que solicitas en C++:
```cpp
#include <iostream>
// Función para pedir los valores de la matriz
void pedirValores(int matriz[2][3]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
std::cout << "Ingrese el valor de la posición [" << i << "][" << j << "]: ";
std::cin >> matriz[i][j];
}
}
}
// Función para calcular la suma de los elementos de la matriz
int calcularSuma(int matriz[2][3]) {
int suma = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
suma += matriz[i][j];
}
}
return suma;
}
// Función para recorrer la matriz con un ciclo while
void recorrerWhile(int matriz[2][3]) {
int i = 0;
while (i < 2) {
int j = 0;
while (j < 3) {
std::cout << "Valor de la posición [" << i << "][" << j << "]: " << matriz[i][j] << std::endl;
j++;
}
i++;
}
}
// Función para recorrer la matriz con un ciclo for
void recorrerFor(int matriz[2][3]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
std::cout << "Valor de la posición [" << i << "][" << j << "]: " << matriz[i][j] << std::endl;
}
}
}
// Función para recorrer la matriz con un ciclo do-while
void recorrerDoWhile(int matriz[2][3]) {
int i = 0;
do {
int j = 0;
do {
std::cout << "Valor de la posición [" << i << "][" << j << "]: " << matriz[i][j] << std::endl;
j++;
} while (j < 3);
i++;
} while (i < 2);
}
int main() {
int matriz[2][3];
// Pedir los valores de la matriz
pedirValores(matriz);
// Calcular la suma de los elementos de la matriz
int suma = calcularSuma(matriz);
std::cout << "La suma de los elementos de la matriz es: " << suma << std::endl;
// Recorrer la matriz con un ciclo while
std::cout << "Recorriendo la matriz con un ciclo while:" << std::endl;
recorrerWhile(matriz);
// Recorrer la matriz con un ciclo for
std::cout << "\nRecorriendo la matriz con un ciclo for:" << std::endl;
recorrerFor(matriz);
// Recorrer la matriz con un ciclo do-while
std::cout << "\nRecorriendo la matriz con un ciclo do-while:" << std::endl;
recorrerDoWhile(matriz);
return 0;
}
```
Este programa declara una matriz 2x3, pide al usuario ingresar los valores, calcula la suma de los elementos y recorre la matriz con tres tipos de ciclos diferentes: while, for y do-while.
Aquí te dejo un ejemplo de código en C++ que cumple con las características que mencionaste:
```cpp
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <windows.h>
using namespace std;
// Definición de la matriz de identidad
const int FILAS = 30;
const int COLUMNAS = 30;
// Definición de la estructura para el personaje
struct Personaje {
int x, y;
int vidas;
int llaves;
};
// Definición de la estructura para los enemigos
struct Enemigo {
int x, y;
int velocidad;
};
// Definición de la estructura para las llaves
struct Llave {
int x, y;
};
// Definición de la matriz de identidad
char laberinto[FILAS][COLUMNAS] = {
// Inicializar la matriz con espacios en blanco
{" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", "
Please keep input under 1000 characters
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
std::cout << "El nombre no puede contener números." << std::endl;
return;
}
}
this->nombre = nombre;
}
void setTelefono(const std::string& telefono) {
for (char c : telefono) {
if (!isdigit(c)) {
std::cout << "El teléfono debe contener solo números." << std::endl;
return;
}
}
this->telefono = telefono;
}
void setMail(const std::string& mail) {
size_t posAt = mail.find('@');
size_t posDot = mail.find('.');
if (posAt == std::string::npos || posDot == std::string::npos) {
std::cout << "El correo electrónico debe contener '@' y '.'." << std::endl;
return;
}
if (posDot < posAt + 1) {
std::cout << "El correo electrónico debe contener '.' después de '@'." << std::endl;
return;
}
if (mail.find(".com") == std::string::npos) {
std::cout << "El correo electrónico debe terminar en '.com'." << std::endl;
return;
}
this->mail = mail;
}
void setNumeroReo(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
std::cout << "El número de reo debe contener solo números." << std::endl;
return;
}
}
this->numeroReo = numeroReo;
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void darDeAlta() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.darDeAlta();
return 0;
}
```
Este programa crea una clase `Estudiante` con métodos para establecer los atributos del estudiante y un método para dar de alta al estudiante. En el método `main`, se solicita al usuario que ingrese los datos del estudiante y se llama al método `darDeAlta` para mostrar los datos del estudiante.
Aquí te dejo un ejemplo de código en C++ que cumple con las características que mencionaste:
```cpp
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <windows.h>
using namespace std;
// Definición de la matriz de identidad
const int FILAS = 30;
const int COLUMNAS = 30;
// Definición de la clase Personaje
class Personaje {
public:
int x, y;
int vidas;
int llaves;
Personaje(int x, int y) {
this->x = x;
this->y = y;
this->vidas = 3;
this->llaves = 0;
}
void mover(int dx, int dy) {
x += dx;
y += dy;
}
};
// Definición de la clase Enemigo
class Enemigo {
public:
int x, y;
int velocidad;
Enemigo(int x, int y, int velocidad) {
this->x = x;
this->y = y;
this->velocidad = velocidad;
}
void mover(Personaje &personaje) {
if (x < personaje.x) {
x++;
} else if (x > personaje.x) {
x--;
}
if (y < personaje.y) {
y++;
} else if (y > personaje.y) {
y--;
}
}
};
// Definición de la clase Laberinto
class Laberinto {
public:
vector<vector<char>> matriz;
Personaje personaje;
vector<Enemigo> enemigos;
int nivel;
Laberinto() {
matriz.resize(FILAS, vector<char>(COLUMNAS, ' '));
personaje = Personaje(1, 1);
enemigos.resize(3);
enemigos[0] = Enemigo(1, 2, 1);
enemigos[1] = Enemigo(2, 1, 1);
enemigos[2] = Enemigo(3, 3, 1);
nivel = 1;
}
void dibujar() {
system("cls");
for (int i = 0; i < FILAS; i++) {
for (int j = 0; j < COLUMNAS; j++) {
if (i == personaje.y && j == personaje.x) {
cout << "P";
} else if (i == enemigos[0].y && j == enemigos[0].x) {
cout << "E";
} else if (i == enemigos[1].y && j == enemigos[1].x) {
cout << "E";
} else if (i == enemigos[2].y && j == enemigos[2].x) {
cout << "E";
} else if (i == 10 && j == 10) {
cout << "K";
} else if (i == 20 && j == 20) {
cout << "K";
} else if (i == 30 && j == 30) {
cout << "K";
} else {
cout << matriz[i][j];
}
}
cout << endl;
}
}
void actualizar() {
personaje.mover(0, 0);
for (int i = 0; i < 3; i++) {
enemigos[i].mover(personaje);
}
if (personaje.x == 10 && personaje.y == 10) {
personaje.llaves++;
matriz[10][10] = ' ';
} else if (personaje.x == 20 && personaje.y == 20) {
personaje.llaves++;
matriz[20][20] = ' ';
} else if (personaje.x == 30 && personaje.y == 30) {
personaje.llaves++;
matriz[30][30] = ' ';
}
if (personaje.vidas == 0) {
cout << "¡Has muerto! ¡Juego sobre!" << endl;
exit(0);
}
if (personaje.llaves == 3) {
nivel++;
personaje.llaves = 0;
enemigos[0].x = 1;
enemigos[0].y = 1;
enemigos[1].x = 2;
enemigos[1].y = 1;
enemigos[2].x = 3;
enemigos[2].y = 3;
}
}
};
int main() {
srand(time(0));
Laberinto laberinto;
while (true) {
laberinto.dibujar();
char tecla;
cin >> tecla;
if (tecla == 'w') {
laberinto.personaje.mover(0, -1);
} else if (tecla == 's') {
laberinto.personaje.mover(0, 1);
} else if (tecla == 'a') {
laberinto.personaje.mover(-1, 0);
} else if (tecla == 'd') {
laberinto.personaje.mover(1, 0);
}
laberinto.actualizar();
if (laberinto.nivel == 4) {
cout << "¡Felicidades! Has completado el juego." << endl;
break;
}
}
return 0;
}
void menu() {
cout << "Bienvenido al juego de laberinto!" << endl;
cout << "1. Empezar" << endl;
cout << "2. Créditos" << endl;
cout << "3. Salir" << endl;
int opcion;
cin >> opcion;
if (opcion == 1) {
main();
} else if (opcion == 2) {
cout << "Juego creado por: [Tu nombre]" << endl;
} else if (opcion == 3) {
exit(0);
}
}
int main() {
menu();
return 0;
}
```
Este código crea un juego de laberinto con un personaje que se puede mover con las teclas W, A, S, D. El personaje tiene 3 vidas y debe recolectar 3 llaves para pasar al siguiente nivel. Hay 3 enemigos que persiguen al personaje. El juego tiene un menú para empezar o ver los créditos.
Aquí te muestro un ejemplo de código en C++ que calcula el promedio de 3 notas utilizando 2 funciones:
```cpp
#include <iostream>
// Función para leer una nota
double leerNota() {
double nota;
std::cout << "Ingrese la nota: ";
std::cin >> nota;
return nota;
}
// Función para calcular el promedio de 3 notas
double calcularPromedio(double nota1, double nota2, double nota3) {
return (nota1 + nota2 + nota3) / 3;
}
int main() {
double nota1, nota2, nota3;
// Leer las 3 notas
nota1 = leerNota();
nota2 = leerNota();
nota3 = leerNota();
// Calcular el promedio
double promedio = calcularPromedio(nota1, nota2, nota3);
// Mostrar el promedio
std::cout << "El promedio de las 3 notas es: " << promedio << std::endl;
return 0;
}
```
En este código, la función `leerNota()` se encarga de leer una nota del usuario y devolverla como un valor `double`. La función `calcularPromedio()` recibe las 3 notas como parámetros y devuelve el promedio de ellas. En el `main()`, se leen las 3 notas utilizando la función `leerNota()`, se calcula el promedio utilizando la función `calcularPromedio()` y se muestra el resultado en la consola.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname)
: nombre(nombre), telefono(telefono), mail(mail), numeroReo(numeroReo), nickname(nickname) {}
// Getter y setter para cada atributo
std::string getNombre() const { return nombre; }
std::string getTelefono() const { return telefono; }
std::string getMail() const { return mail; }
std::string getNumeroReo() const { return numeroReo; }
std::string getNickname() const { return nickname; }
// Método para verificar si el correo electrónico es válido
bool esCorreoValido(const std::string& mail) {
size_t posicionAt = mail.find('@');
size_t posicionPunto = mail.find('.');
return posicionAt != std::string::npos && posicionPunto != std::string::npos && mail.find(".com") != std::string::npos;
}
// Método para verificar si el número de reo es válido
bool esNumeroReoValido(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para verificar si el nombre es válido
bool esNombreValido(const std::string& nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para registrar un estudiante
void registrarEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::cin >> nombre;
while (!esNombreValido(nombre)) {
std::cout << "El nombre no puede contener números. Por favor, ingrese un nombre válido: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::cin >> mail;
while (!esCorreoValido(mail)) {
std::cout << "El correo electrónico no es válido. Por favor, ingrese un correo electrónico válido: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::cin >> numeroReo;
while (!esNumeroReoValido(numeroReo)) {
std::cout << "El número de reo no es válido. Por favor, ingrese un número de reo válido: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::cin >> nickname;
Estudiante estudiante(nombre, telefono, mail, numeroReo, nickname);
std::cout << "Estudiante registrado con éxito." << std::endl;
std::cout << "Nombre: " << estudiante.getNombre() << std::endl;
std::cout << "Teléfono: " << estudiante.getTelefono() << std::endl;
std::cout << "Correo electrónico: " << estudiante.getMail() << std::endl;
std::cout << "Número de reo: " << estudiante.getNumeroReo() << std::endl;
std::cout << "Nickname: " << estudiante.getNickname() << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.registrarEstudiante();
return 0;
}
```
Este programa define una clase `Estudiante` con atributos para nombre, teléfono, correo electrónico, número de reo y nickname. La clase tiene métodos para verificar si el correo electrónico y el número de reo son válidos, y un método para registrar un estudiante.
El método `registrarEstudiante` solicita al usuario que ingrese los datos del estudiante y verifica que sean válidos. Si los datos no son válidos, solicita al usuario que los ingrese de nuevo.
Finalmente, el programa crea un objeto `Estudiante` con los datos ingresados y los muestra en la consola.
Aquí te dejo un ejemplo de código en C++ que cumple con las características que mencionaste:
```cpp
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <windows.h>
using namespace std;
// Definición de la matriz de identidad
const int FILAS = 30;
const int COLUMNAS = 30;
// Definición de la estructura para el personaje
struct Personaje {
int x, y;
int vidas;
int llaves;
};
// Definición de la estructura para los enemigos
struct Enemigo {
int x, y;
int velocidad;
};
// Definición de la estructura para las llaves
struct Llave {
int x, y;
};
// Definición de la matriz de identidad
char laberinto[FILAS][COLUMNAS] = {
// Inicializar la matriz con espacios en blanco
{" ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", "
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
for (char c : nombre) {
if (!std::isalpha(c)) {
std::cout << "El nombre no puede contener números." << std::endl;
return;
}
}
this->nombre = nombre;
}
void setTelefono(const std::string& telefono) {
for (char c : telefono) {
if (!std::isdigit(c)) {
std::cout << "El teléfono debe contener solo números." << std::endl;
return;
}
}
this->telefono = telefono;
}
void setMail(const std::string& mail) {
size_t posAt = mail.find('@');
size_t posDot = mail.find('.');
if (posAt == std::string::npos || posDot == std::string::npos) {
std::cout << "El correo electrónico debe contener '@' y '.'." << std::endl;
return;
}
if (mail.find(".com") == std::string::npos) {
std::cout << "El correo electrónico debe terminar en '.com'." << std::endl;
return;
}
this->mail = mail;
}
void setNumeroReo(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!std::isdigit(c)) {
std::cout << "El número de reo debe contener solo números." << std::endl;
return;
}
}
this->numeroReo = numeroReo;
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void darDeAlta() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.darDeAlta();
return 0;
}
```
Este programa crea una clase `Estudiante` con métodos para establecer los atributos del estudiante y un método para dar de alta al estudiante. Los métodos de establecimiento de atributos validan la entrada del usuario para asegurarse de que cumpla con las condiciones establecidas. El método `darDeAlta` imprime los atributos del estudiante en la consola. En el `main`, se crea un objeto `Estudiante` y se solicita al usuario que ingrese los atributos del estudiante, que se establecen utilizando los métodos correspondientes. Finalmente, se llama al método `darDeAlta` para imprimir los atributos del estudiante.
Aquí te muestro un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <cmath>
// Función para calcular el perímetro de un polígono regular
double calcularPerimetro(int lados, double lado) {
return lados * lado;
}
// Función para calcular la apotema de un polígono regular
double calcularApotema(int lados, double lado) {
return std::sqrt(std::pow(lado, 2) - std::pow(lado / 2, 2));
}
// Función para calcular el área de un polígono regular
double calcularArea(int lados, double lado) {
double apotema = calcularApotema(lados, lado);
double perimetro = calcularPerimetro(lados, lado);
return (perimetro * apotema) / 2;
}
// Función para mostrar opciones de polígonos
void mostrarOpciones() {
std::cout << "Seleccione un polígono regular:" << std::endl;
std::cout << "1. Pentágono" << std::endl;
std::cout << "2. Hexágono" << std::endl;
std::cout << "3. Heptágono" << std::endl;
std::cout << "4. Octágono" << std::endl;
}
// Función para obtener la longitud de un lado de un polígono regular
void obtenerLado(int &lados, double &lado) {
std::cout << "Ingrese la longitud de un lado del polígono: ";
std::cin >> lado;
lados = 5; // Por defecto, asumimos que es un pentágono
switch (lados) {
case 5:
std::cout << "Pentágono seleccionado." << std::endl;
break;
case 6:
std::cout << "Hexágono seleccionado." << std::endl;
break;
case 7:
std::cout << "Heptágono seleccionado." << std::endl;
break;
case 8:
std::cout << "Octágono seleccionado." << std::endl;
break;
default:
std::cout << "Polígono no válido." << std::endl;
exit(1);
}
}
int main() {
int lados;
double lado;
mostrarOpciones();
std::cout << "Ingrese el número del polígono que desea seleccionar: ";
std::cin >> lados;
obtenerLado(lados, lado);
double area = calcularArea(lados, lado);
std::cout << "El área del polígono es: " << area << std::endl;
return 0;
}
```
Este programa define cuatro funciones: `calcularPerimetro`, `calcularApotema` y `calcularArea` para calcular el perímetro, la apotema y el área de un polígono regular, respectivamente. La función `mostrarOpciones` muestra las opciones de polígonos disponibles y la función `obtenerLado` obtiene la longitud de un lado del polígono seleccionado.
En el `main`, se muestra la lista de opciones de polígonos y se solicita al usuario que ingrese el número del polígono que desea seleccionar. Luego, se llama a la función `obtenerLado` para obtener la longitud de un lado del polígono seleccionado y se calcula el área del polígono utilizando la función `calcularArea`. Finalmente, se muestra el área del polígono en la consola.
Aquí te muestro un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <cmath>
// Función para calcular el perímetro de un polígono regular
double calcularPerimetro(int lados, double lado) {
return lados * lado;
}
// Función para calcular la apotema de un polígono regular
double calcularApotema(int lados, double lado) {
return std::sqrt(std::pow(lado, 2) - std::pow(lado / 2, 2));
}
// Función para calcular el área de un polígono regular
double calcularArea(int lados, double lado) {
double apotema = calcularApotema(lados, lado);
double perimetro = calcularPerimetro(lados, lado);
return (perimetro * apotema) / 2;
}
// Función para mostrar opciones de polígonos
void mostrarOpciones() {
std::cout << "Seleccione un polígono regular:" << std::endl;
std::cout << "1. Pentágono" << std::endl;
std::cout << "2. Hexágono" << std::endl;
std::cout << "3. Heptágono" << std::endl;
std::cout << "4. Octágono" << std::endl;
}
// Función para obtener la longitud de un lado de un polígono regular
void obtenerLado(int &lados, double &lado) {
std::cout << "Ingrese la longitud de un lado del polígono: ";
std::cin >> lado;
std::cout << "Ingrese el número de lados del polígono: ";
std::cin >> lados;
}
// Función principal
int main() {
int lados;
double lado;
int opcion;
mostrarOpciones();
std::cout << "Ingrese su opción: ";
std::cin >> opcion;
switch (opcion) {
case 1:
lados = 5;
break;
case 2:
lados = 6;
break;
case 3:
lados = 7;
break;
case 4:
lados = 8;
break;
default:
std::cout << "Opción inválida" << std::endl;
return 1;
}
obtenerLado(lados, lado);
double area = calcularArea(lados, lado);
std::cout << "El área del polígono es: " << area << std::endl;
return 0;
}
```
Este programa define varias funciones para calcular el perímetro, la apotema y el área de un polígono regular. La función `mostrarOpciones` muestra las opciones de polígonos disponibles, y la función `obtenerLado` obtiene la longitud de un lado y el número de lados del polígono. La función `calcularArea` calcula el área del polígono utilizando las fórmulas dadas.
En la función principal, se muestra las opciones de polígonos y se obtiene la opción seleccionada por el usuario. Luego, se calcula el área del polígono utilizando la función `calcularArea` y se muestra el resultado.
Aquí te dejo un ejemplo de código en C++ que cumple con tus requisitos. Este código utiliza la biblioteca `ncurses` para crear una matriz de 10x10 y controlar el personaje con las teclas `W`, `S`, `A` y `D`.
```c
#include <ncurses.h>
#include <stdlib.h>
#include <time.h>
// Definimos las constantes para la matriz
const int FILAS = 10;
const int COLUMNAS = 10;
// Definimos las constantes para el personaje y los enemigos
const int PERSONAJE = 1;
const int ENEMIGO = 2;
const int LLAVE = 3;
// Definimos las constantes para las teclas
const int TECLA_ARRIBA = 'w';
const int TECLA_ABAJO = 's';
const int TECLA_IZQUIERDA = 'a';
const int TECLA_DERECHA = 'd';
// Definimos las constantes para las vidas
const int VIDAS_INICIALES = 2;
// Definimos la matriz de laberinto
int laberinto[FILAS][COLUMNAS];
// Definimos las variables para el personaje y los enemigos
int personaje_x, personaje_y;
int enemigo1_x, enemigo1_y;
int enemigo2_x, enemigo2_y;
int vida = VIDAS_INICIALES;
int llave_recolectada = 0;
int main() {
// Inicializamos la biblioteca ncurses
initscr();
cbreak();
noecho();
curs_set(0);
// Inicializamos la matriz de laberinto
for (int i = 0; i < FILAS; i++) {
for (int j = 0; j < COLUMNAS; j++) {
laberinto[i][j] = 0;
}
}
// Creamos los enemigos
srand(time(NULL));
enemigo1_x = rand() % COLUMNAS;
enemigo1_y = rand() % FILAS;
enemigo2_x = rand() % COLUMNAS;
enemigo2_y = rand() % FILAS;
// Creamos la llave
int llave_x, llave_y;
do {
llave_x = rand() % COLUMNAS;
llave_y = rand() % FILAS;
} while (laberinto[llave_y][llave_x] != 0);
// Colocamos el personaje en la posición inicial
personaje_x = 1;
personaje_y = 1;
// Colocamos el personaje en la matriz
laberinto[personaje_y][personaje_x] = PERSONAJE;
// Colocamos los enemigos en la matriz
laberinto[enemigo1_y][enemigo1_x] = ENEMIGO;
laberinto[enemigo2_y][enemigo2_x] = ENEMIGO;
// Colocamos la llave en la matriz
laberinto[llave_y][llave_x] = LLAVE;
// Dibujamos la matriz de laberinto
while (true) {
// Limpia la pantalla
clear();
// Dibuja la matriz de laberinto
for (int i = 0; i < FILAS; i++) {
for (int j = 0; j < COLUMNAS; j++) {
if (laberinto[i][j] == 0) {
addstr("# ");
} else if (laberinto[i][j] == PERSONAJE) {
addstr("P ");
} else if (laberinto[i][j] == ENEMIGO) {
addstr("E ");
} else if (laberinto[i][j] == LLAVE) {
addstr("L ");
} else {
addstr(" ");
}
}
addstr("\n");
}
// Muestra el número de vidas
addstr("Vidas: ");
addstr(itoa(vida, NULL, 10));
addstr("\n");
// Muestra el mensaje de victoria
if (llave_recolectada == 1) {
addstr("¡Victoria!");
refresh();
delay(2000);
break;
}
// Obtiene la tecla presionada
int tecla = getch();
// Mueve el personaje según la tecla presionada
switch (tecla) {
case TECLA_ARRIBA:
if (personaje_y > 0 && laberinto[personaje_y - 1][personaje_x] != 0) {
personaje_y--;
laberinto[personaje_y][personaje_x] = PERSONAJE;
laberinto[personaje_y + 1][personaje_x] = 0;
}
break;
case TECLA_ABAJO:
if (personaje_y < FILAS - 1 && laberinto[personaje_y + 1][personaje_x] != 0) {
personaje_y++;
laberinto[personaje_y][personaje_x] = PERSONAJE;
laberinto[personaje_y - 1][personaje_x] = 0;
}
break;
case TECLA_IZQUIERDA:
if (personaje_x > 0 && laberinto[personaje_y][personaje_x - 1] != 0) {
personaje_x--;
laberinto[personaje_y][personaje_x] = PERSONAJE;
laberinto[personaje_y][personaje_x + 1] = 0;
}
break;
case TECLA_DERECHA:
if (personaje_x < COLUMNAS - 1 && laberinto[personaje_y][personaje_x + 1] != 0) {
personaje_x++;
laberinto[personaje_y][personaje_x] = PERSONAJE;
laberinto[personaje_y][personaje_x - 1] = 0;
}
break;
}
// Comprueba si el personaje ha encontrado la llave
if (personaje_x == llave_x && personaje_y == llave_y) {
llave_recolectada = 1;
}
// Comprueba si el personaje ha sido atacado por un enemigo
if (personaje_x == enemigo1_x && personaje_y == enemigo1_y) {
vida--;
laberinto[personaje_y][personaje_x] = 0;
enemigo1_x = rand() % COLUMNAS;
enemigo1_y = rand() % FILAS;
laberinto[enemigo1_y][enemigo1_x] = ENEMIGO;
} else if (personaje_x == enemigo2_x && personaje_y == enemigo2_y) {
vida--;
laberinto[personaje_y][personaje_x] = 0;
enemigo2_x = rand() % COLUMNAS;
enemigo2_y = rand() % FILAS;
laberinto[enemigo2_y][enemigo2_x] = ENEMIGO;
}
// Comprueba si el personaje ha muerto
if (vida == 0) {
addstr("¡Game Over!");
refresh();
delay(2000);
break;
}
// Actualiza la pantalla
refresh();
delay(100);
}
// Termina la biblioteca ncurses
endwin();
return 0;
}
```
Este código crea un laberinto de 10x10 con un personaje, dos enemigos y una llave. El personaje se puede mover con las teclas `W`, `S`, `A` y `D`. El objetivo es encontrar la llave y regresar al punto de partida sin ser atacado por los enemigos. Si el personaje muere, el juego termina.
Aquí te muestro un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <cmath>
// Función para calcular el perímetro de un polígono regular
double calcularPerimetro(int lados, double lado) {
return lados * lado;
}
// Función para calcular la apotema de un polígono regular
double calcularApotema(int lados, double lado) {
return lado / (2 * std::tan(M_PI / lados));
}
// Función para calcular el área de un polígono regular
double calcularArea(int lados, double lado) {
double apotema = calcularApotema(lados, lado);
double perimetro = calcularPerimetro(lados, lado);
return (perimetro * apotema) / 2;
}
// Función para mostrar opciones de polígonos
void mostrarOpciones() {
std::cout << "Seleccione un polígono regular:" << std::endl;
std::cout << "1. Pentágono (5 lados)" << std::endl;
std::cout << "2. Hexágono (6 lados)" << std::endl;
std::cout << "3. Heptágono (7 lados)" << std::endl;
std::cout << "4. Octágono (8 lados)" << std::endl;
}
// Función principal
int main() {
int opcion;
double lado;
mostrarOpciones();
std::cout << "Ingrese la opción del polígono: ";
std::cin >> opcion;
switch (opcion) {
case 1:
std::cout << "Ingrese la longitud de un lado del pentágono: ";
std::cin >> lado;
std::cout << "El área del pentágono es: " << calcularArea(5, lado) << std::endl;
break;
case 2:
std::cout << "Ingrese la longitud de un lado del hexágono: ";
std::cin >> lado;
std::cout << "El área del hexágono es: " << calcularArea(6, lado) << std::endl;
break;
case 3:
std::cout << "Ingrese la longitud de un lado del heptágono: ";
std::cin >> lado;
std::cout << "El área del heptágono es: " << calcularArea(7, lado) << std::endl;
break;
case 4:
std::cout << "Ingrese la longitud de un lado del octágono: ";
std::cin >> lado;
std::cout << "El área del octágono es: " << calcularArea(8, lado) << std::endl;
break;
default:
std::cout << "Opción inválida" << std::endl;
break;
}
return 0;
}
```
Este programa define cuatro funciones: `calcularPerimetro`, `calcularApotema` y `calcularArea` para calcular el perímetro, la apotema y el área de un polígono regular, respectivamente. La función `mostrarOpciones` muestra las opciones de polígonos disponibles. La función principal `main` solicita al usuario que seleccione un polígono y luego solicita la longitud de un lado del polígono seleccionado. Finalmente, calcula y muestra el área del polígono seleccionado.
Aquí te muestro un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <cmath>
// Función para calcular el perímetro de un polígono regular
double calcularPerimetro(int lados, double lado) {
return lados * lado;
}
// Función para calcular la apotema de un polígono regular
double calcularApotema(int lados, double lado) {
return std::sqrt(std::pow(lado, 2) - std::pow(lado / 2, 2));
}
// Función para calcular el área de un polígono regular
double calcularArea(int lados, double lado) {
double apotema = calcularApotema(lados, lado);
double perimetro = calcularPerimetro(lados, lado);
return (perimetro * apotema) / 2;
}
// Función para mostrar opciones de polígonos
void mostrarOpciones() {
std::cout << "Seleccione un polígono regular:" << std::endl;
std::cout << "1. Pentágono" << std::endl;
std::cout << "2. Hexágono" << std::endl;
std::cout << "3. Heptágono" << std::endl;
std::cout << "4. Octágono" << std::endl;
}
// Función para obtener la longitud de un lado de un polígono regular
void obtenerLado(int &lados, double &lado) {
std::cout << "Ingrese la longitud de un lado del polígono: ";
std::cin >> lado;
std::cout << "Ingrese el número de lados del polígono: ";
std::cin >> lados;
}
// Función principal
int main() {
int lados;
double lado;
int opcion;
mostrarOpciones();
std::cout << "Ingrese su opción: ";
std::cin >> opcion;
switch (opcion) {
case 1:
lados = 5;
break;
case 2:
lados = 6;
break;
case 3:
lados = 7;
break;
case 4:
lados = 8;
break;
default:
std::cout << "Opción inválida" << std::endl;
return 1;
}
obtenerLado(lados, lado);
double area = calcularArea(lados, lado);
std::cout << "El área del polígono es: " << area << std::endl;
return 0;
}
```
Este programa define varias funciones para calcular el perímetro, la apotema y el área de un polígono regular. La función `mostrarOpciones` muestra las opciones de polígonos disponibles, y la función `obtenerLado` obtiene la longitud de un lado y el número de lados del polígono. La función `calcularArea` calcula el área del polígono utilizando las fórmulas dadas.
En la función principal, se muestra las opciones de polígonos y se obtiene la opción seleccionada por el usuario. Luego, se calcula el área del polígono utilizando la función `calcularArea` y se muestra el resultado.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname)
: nombre(nombre), telefono(telefono), mail(mail), numeroReo(numeroReo), nickname(nickname) {}
// Getter y setter para cada atributo
std::string getNombre() const { return nombre; }
void setNombre(const std::string& nombre) { this->nombre = nombre; }
std::string getTelefono() const { return telefono; }
void setTelefono(const std::string& telefono) { this->telefono = telefono; }
std::string getMail() const { return mail; }
void setMail(const std::string& mail) { this->mail = mail; }
std::string getNumeroReo() const { return numeroReo; }
void setNumeroReo(const std::string& numeroReo) { this->numeroReo = numeroReo; }
std::string getNickname() const { return nickname; }
void setNickname(const std::string& nickname) { this->nickname = nickname; }
// Método para validar el correo electrónico
bool validarMail(const std::string& mail) {
size_t posicionPunto = mail.find('.');
size_t posicionArroba = mail.find('@');
if (posicionPunto != std::string::npos && posicionArroba != std::string::npos) {
if (posicionPunto > posicionArroba) {
return false;
}
if (mail.find(".com") == mail.size() - 4) {
return true;
}
}
return false;
}
// Método para validar el número de reo
bool validarNumeroReo(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para validar el nombre
bool validarNombre(const std::string& nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para registrar un estudiante
void registrarEstudiante() {
std::string nombre, telefono, mail, numeroReo, nickname;
// Pedir los datos al usuario
std::cout << "Ingrese el nombre del estudiante: ";
std::getline(std::cin, nombre);
while (!validarNombre(nombre)) {
std::cout << "El nombre no puede contener números. Por favor, ingrese el nombre nuevamente: ";
std::getline(std::cin, nombre);
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::getline(std::cin, telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::getline(std::cin, mail);
while (!validarMail(mail)) {
std::cout << "El correo electrónico no es válido. Por favor, ingrese el correo electrónico nuevamente: ";
std::getline(std::cin, mail);
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::getline(std::cin, numeroReo);
while (!validarNumeroReo(numeroReo)) {
std::cout << "El número de reo no es válido. Por favor, ingrese el número de reo nuevamente: ";
std::getline(std::cin, numeroReo);
}
std::cout << "Ingrese el nickname del estudiante: ";
std::getline(std::cin, nickname);
// Crear un objeto Estudiante con los datos ingresados
Estudiante estudiante(nombre, telefono, mail, numeroReo, nickname);
// Mostrar los datos del estudiante
std::cout << "Estudiante registrado con éxito:" << std::endl;
std::cout << "Nombre: " << estudiante.getNombre() << std::endl;
std::cout << "Teléfono: " << estudiante.getTelefono() << std::endl;
std::cout << "Correo electrónico: " << estudiante.getMail() << std::endl;
std::cout << "Número de reo: " << estudiante.getNumeroReo() << std::endl;
std::cout << "Nickname: " << estudiante.getNickname() << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.registrarEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con atributos para nombre, teléfono, correo electrónico, número de reo y nickname. Los métodos `validarMail`, `validarNumeroReo` y `validarNombre` se utilizan para validar los datos ingresados por el usuario. El método `registrarEstudiante` se utiliza para registrar un estudiante y mostrar sus datos.
Aquí te dejo un ejemplo de cómo podrías implementar el programa en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
// Constructor
Estudiante(std::string nombre, std::string telefono, std::string mail, std::string numeroReo, std::string nickname)
: nombre(nombre), telefono(telefono), mail(mail), numeroReo(numeroReo), nickname(nickname) {}
// Getter y setter para cada atributo
std::string getNombre() const { return nombre; }
void setNombre(const std::string& nombre) { this->nombre = nombre; }
std::string getTelefono() const { return telefono; }
void setTelefono(const std::string& telefono) { this->telefono = telefono; }
std::string getMail() const { return mail; }
void setMail(const std::string& mail) { this->mail = mail; }
std::string getNumeroReo() const { return numeroReo; }
void setNumeroReo(const std::string& numeroReo) { this->numeroReo = numeroReo; }
std::string getNickname() const { return nickname; }
void setNickname(const std::string& nickname) { this->nickname = nickname; }
// Método para verificar si el correo electrónico es válido
bool esCorreoValido(const std::string& mail) {
size_t posicionPunto = mail.find('.');
size_t posicionArroba = mail.find('@');
if (posicionPunto != std::string::npos && posicionArroba != std::string::npos) {
if (posicionPunto > posicionArroba) {
return false;
}
if (posicionPunto == mail.size() - 1 || posicionArroba == mail.size() - 1) {
return false;
}
if (mail.find(".com") == mail.size() - 4) {
return true;
}
}
return false;
}
// Método para verificar si el número de reo es válido
bool esNumeroReoValido(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!isdigit(c)) {
return false;
}
}
return true;
}
// Método para verificar si el nombre es válido
bool esNombreValido(const std::string& nombre) {
for (char c : nombre) {
if (!isalpha(c)) {
return false;
}
}
return true;
}
// Método para verificar si el teléfono es válido
bool esTelefonoValido(const std::string& telefono) {
// Aquí podrías implementar una lógica para verificar si el teléfono es válido
// Por ejemplo, verificar si tiene 10 dígitos
return telefono.size() == 10;
}
// Método para verificar si todos los datos son válidos
bool esTodosDatosValidos() {
return esNombreValido(nombre) && esTelefonoValido(telefono) && esCorreoValido(mail) && esNumeroReoValido(numeroReo);
}
// Método para dar de alta al estudiante
void darDeAlta() {
if (esTodosDatosValidos()) {
std::cout << "Estudiante dado de alta con éxito." << std::endl;
} else {
std::cout << "Error: algunos datos no son válidos." << std::endl;
}
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::cin >> nombre;
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::cin >> telefono;
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::cin >> mail;
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::cin >> numeroReo;
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::cin >> nickname;
estudiante.setNickname(nickname);
estudiante.darDeAlta();
return 0;
}
```
Este programa crea una clase `Estudiante` con atributos para nombre, teléfono, correo electrónico, número de reo y nickname. Cada atributo tiene un método getter y setter para acceder y modificar su valor.
El programa también incluye métodos para verificar si el correo electrónico, el número de reo, el nombre y el teléfono son válidos. Estos métodos se utilizan en el método `darDeAlta` para verificar si todos los datos son válidos antes de dar de alta al estudiante.
En el `main`, se crea un objeto `Estudiante` y se solicita al usuario que ingrese los datos del estudiante. Luego, se llama al método `darDeAlta` para dar de alta al estudiante.
Aquí te dejo un ejemplo de cómo podrías implementar un programa en C++ que cumpla con tus requisitos:
```cpp
#include <iostream>
#include <string>
class Estudiante {
private:
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void setNombre(const std::string& nombre) {
for (char c : nombre) {
if (!std::isalpha(c)) {
std::cout << "El nombre no puede contener números." << std::endl;
return;
}
}
this->nombre = nombre;
}
void setTelefono(const std::string& telefono) {
for (char c : telefono) {
if (!std::isdigit(c)) {
std::cout << "El teléfono debe contener solo números." << std::endl;
return;
}
}
this->telefono = telefono;
}
void setMail(const std::string& mail) {
size_t posAt = mail.find('@');
size_t posDot = mail.find('.');
if (posAt == std::string::npos || posDot == std::string::npos) {
std::cout << "El correo electrónico debe contener '@' y '.'." << std::endl;
return;
}
if (posDot <= posAt + 1) {
std::cout << "El correo electrónico debe contener '.' después de '@'." << std::endl;
return;
}
if (mail.find(".com") == std::string::npos) {
std::cout << "El correo electrónico debe terminar en '.com'." << std::endl;
return;
}
this->mail = mail;
}
void setNumeroReo(const std::string& numeroReo) {
for (char c : numeroReo) {
if (!std::isdigit(c)) {
std::cout << "El número de reo debe contener solo números." << std::endl;
return;
}
}
this->numeroReo = numeroReo;
}
void setNickname(const std::string& nickname) {
this->nickname = nickname;
}
void darDeAlta() {
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
std::cout << "Ingrese el nombre del estudiante: ";
std::string nombre;
std::getline(std::cin, nombre);
estudiante.setNombre(nombre);
std::cout << "Ingrese el teléfono del estudiante: ";
std::string telefono;
std::getline(std::cin, telefono);
estudiante.setTelefono(telefono);
std::cout << "Ingrese el correo electrónico del estudiante: ";
std::string mail;
std::getline(std::cin, mail);
estudiante.setMail(mail);
std::cout << "Ingrese el número de reo del estudiante: ";
std::string numeroReo;
std::getline(std::cin, numeroReo);
estudiante.setNumeroReo(numeroReo);
std::cout << "Ingrese el nickname del estudiante: ";
std::string nickname;
std::getline(std::cin, nickname);
estudiante.setNickname(nickname);
estudiante.darDeAlta();
return 0;
}
```
Este programa define una clase `Estudiante` con métodos para establecer los atributos del estudiante y un método `darDeAlta` para mostrar la información del estudiante. En el método `main`, se solicita al usuario que ingrese la información del estudiante y se establece en los atributos correspondientes. Finalmente, se llama al método `darDeAlta` para mostrar la información del estudiante.
Aquí te muestro un ejemplo de cómo podrías implementar el programa que solicitas en C++:
```cpp
#include <iostream>
// Función para pedir los valores de la matriz
void pedirValores(int matriz[2][3]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
std::cout << "Ingrese el valor de la posición [" << i << "][" << j << "]: ";
std::cin >> matriz[i][j];
}
}
}
// Función para calcular la suma de los elementos de la matriz
int calcularSuma(int matriz[2][3]) {
int suma = 0;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
suma += matriz[i][j];
}
}
return suma;
}
// Función para mostrar la matriz
void mostrarMatriz(int matriz[2][3]) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
std::cout << matriz[i][j] << " ";
}
std::cout << std::endl;
}
}
int main() {
int matriz[2][3];
// Pedir los valores de la matriz
pedirValores(matriz);
// Mostrar la matriz
std::cout << "Matriz ingresada:" << std::endl;
mostrarMatriz(matriz);
// Calcular la suma de los elementos de la matriz
int suma = calcularSuma(matriz);
// Mostrar la suma
std::cout << "La suma de los elementos de la matriz es: " << suma << std::endl;
return 0;
}
```
En este programa, se define una matriz 2x3 llamada `matriz`. La función `pedirValores` pide al usuario que ingrese los valores de la matriz. La función `calcularSuma` calcula la suma de los elementos de la matriz. La función `mostrarMatriz` muestra la matriz en la consola.
En el `main`, se llama a las funciones `pedirValores`, `mostrarMatriz` y `calcularSuma` para obtener los valores de la matriz, mostrar la matriz y calcular la suma de los elementos de la matriz, respectivamente.
**Nota:** En este programa, se utiliza un ciclo `for` anidado para recorrer la matriz. Si deseas utilizar un ciclo `while` o `do-while`, debes modificar el programa para que se ajuste a la estructura de esos ciclos.
**Ejemplo de uso de ciclo while:**
```cpp
void pedirValores(int matriz[2][3]) {
int i = 0;
while (i < 2) {
int j = 0;
while (j < 3) {
std::cout << "Ingrese el valor de la posición [" << i << "][" << j << "]: ";
std::cin >> matriz[i][j];
j++;
}
i++;
}
}
```
**Ejemplo de uso de ciclo do-while:**
```cpp
void pedirValores(int matriz[2][3]) {
int i = 0;
do {
int j = 0;
do {
std::cout << "Ingrese el valor de la posición [" << i << "][" << j << "]: ";
std::cin >> matriz[i][j];
j++;
} while (j < 3);
i++;
} while (i < 2);
}
```
Recuerda que, en el caso de los ciclos `while` y `do-while`, debes incrementar la variable de control (`i` o `j`) dentro del cuerpo del ciclo para evitar un bucle infinito.
Aquí te muestro un ejemplo de código en C++ que calcula el área de un círculo utilizando la constante `pi` con un valor de 3.1416:
```cpp
#include <iostream>
// Constante pi con un valor de 3.1416
const float pi = 3.1416;
// Función para calcular el área de un círculo
float calcularArea(float radio) {
return pi * radio * radio;
}
int main() {
// Declarar variables
float radio;
// Pedir el radio al usuario
std::cout << "Ingrese el radio del círculo: ";
std::cin >> radio;
// Calcular el área del círculo
float area = calcularArea(radio);
// Mostrar el resultado
std::cout << "El área del círculo es: " << area << std::endl;
return 0;
}
```
En este código, la constante `pi` se define con un valor de 3.1416. La función `calcularArea` toma un radio como parámetro y devuelve el área del círculo utilizando la fórmula `pi * radio * radio`. En el `main`, se pide al usuario que ingrese el radio del círculo, se calcula el área utilizando la función `calcularArea` y se muestra el resultado.
Recuerda que el `using namespace std` no es necesario en este caso, ya que solo estamos utilizando la clase `std::cout` y `std::cin`, que están en el espacio de nombres `std` por defecto.
Aquí te dejo un ejemplo de cómo podrías implementar el programa que solicitas en C++:
```cpp
#include <iostream>
#include <string>
class Estudiante {
std::string nombre;
std::string telefono;
std::string mail;
std::string numeroReo;
std::string nickname;
public:
void altaEstudiante() {
std::cout << "Ingrese el nombre del estudiante: ";
std::cin >> nombre;
while (nombre.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ") == std::string::npos) {
std::cout << "El nombre no puede contener números. Ingrese el nombre del estudiante: ";
std::cin >> nombre;
}
std::cout << "Ingrese el teléfono del estudiante: ";
std::cin >> telefono;
std::cout << "Ingrese el correo electrónico del estudiante (debe terminar en .com): ";
std::cin >> mail;
while (mail.find('@') == std::string::npos || mail.find('.com') == std::string::npos) {
std::cout << "El correo electrónico debe terminar en .com. Ingrese el correo electrónico del estudiante: ";
std::cin >> mail;
}
std::cout << "Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
while (!std::all_of(numeroReo.begin(), numeroReo.end(), ::isdigit)) {
std::cout << "El número de reo solo puede contener números. Ingrese el número de reo del estudiante: ";
std::cin >> numeroReo;
}
std::cout << "Ingrese el nickname del estudiante: ";
std::cin >> nickname;
std::cout << "Estudiante dado de alta con éxito." << std::endl;
std::cout << "Nombre: " << nombre << std::endl;
std::cout << "Teléfono: " << telefono << std::endl;
std::cout << "Correo electrónico: " << mail << std::endl;
std::cout << "Número de reo: " << numeroReo << std::endl;
std::cout << "Nickname: " << nickname << std::endl;
}
};
int main() {
Estudiante estudiante;
estudiante.altaEstudiante();
return 0;
}
```
Este programa crea una clase `Estudiante` con un método `altaEstudiante()` que solicita la información del estudiante y la valida según las condiciones establecidas. Si la información no es válida, el programa solicita que se ingrese nuevamente. Finalmente, muestra la información del estudiante dado de alta con éxito.
Aquí te dejo un ejemplo de código en C++ que calcula el promedio general de 64 alumnos:
```c
#include <iostream>
#include <string>
using namespace std;
int main() {
const int NUM_ALUMNOS = 64;
double sumaCalificaciones = 0.0;
double promedioGeneral = 0.0;
for (int i = 0; i < NUM_ALUMNOS; i++) {
string nombreAlumno;
double calificacion;
cout << "Ingrese el nombre del alumno " << i + 1 << ": ";
getline(cin, nombreAlumno);
cout << "Ingrese la calificación del alumno " << i + 1 << ": ";
cin >> calificacion;
cin.ignore(); // Ignorar el salto de línea
sumaCalificaciones += calificacion;
}
promedioGeneral = sumaCalificaciones / NUM_ALUMNOS;
cout << "Promedio general de los " << NUM_ALUMNOS << " alumnos: " << promedioGeneral << endl;
return 0;
}
```
Este código utiliza un bucle `for` para recorrer los 64 alumnos y solicitar su nombre y calificación. La suma de las calificaciones se calcula utilizando la variable `sumaCalificaciones`, que se inicializa a 0.0. Finalmente, el promedio general se calcula dividiendo la suma de las calificaciones por el número de alumnos.
Nota que se utiliza `getline` para leer la cadena de texto del nombre del alumno, y `cin` para leer el valor numérico de la calificación. Después de leer la calificación, se utiliza `cin.ignore()` para ignorar el salto de línea que se produce al final de la entrada.
También se utiliza la función `getline` para leer la cadena de texto del nombre del alumno, ya que `cin` no puede leer cadenas de texto con espacios en blanco.
Recuerda que este código asume que las calificaciones son números enteros o decimales, y que no se pueden ingresar valores no numéricos. Si se desea agregar más funcionalidad, como la validación de la entrada, se pueden utilizar funciones adicionales como `isdigit` o `strtol`.
Aquí te muestro un ejemplo de código en C++ que realiza la suma de dos números:
```cpp
#include <iostream>
// Función que suma dos números
int suma(int num1, int num2) {
return num1 + num2;
}
int main() {
int num1, num2;
// Pide al usuario que ingrese los números
std::cout << "Ingrese el primer número: ";
std::cin >> num1;
std::cout << "Ingrese el segundo número: ";
std::cin >> num2;
// Llama a la función suma y muestra el resultado
int resultado = suma(num1, num2);
std::cout << "La suma de " << num1 << " y " << num2 << " es: " << resultado << std::endl;
return 0;
}
```
Este código define una función `suma` que toma dos números enteros como parámetros y devuelve su suma. En el `main`, se pide al usuario que ingrese dos números, se llama a la función `suma` con esos números y se muestra el resultado.
Recuerda que debes compilar y ejecutar el código en un entorno de desarrollo como Visual Studio o en la terminal con el comando `g++` para ver el resultado.
Aquí te muestro un ejemplo de código en C++ que calcula el precio total de entradas para un grupo y agrega funciones para realizar operaciones adicionales:
```cpp
#include <iostream>
// Clase para representar un grupo de personas
class Grupo {
private:
int cantidadPersonas;
double precioEntrada;
public:
// Constructor para inicializar la cantidad de personas y el precio de la entrada
Grupo(int cantidadPersonas, double precioEntrada) : cantidadPersonas(cantidadPersonas), precioEntrada(precioEntrada) {}
// Método para calcular el precio total de las entradas
double calcularPrecioTotal() {
return cantidadPersonas * precioEntrada;
}
// Método para agregar más personas al grupo
void agregarPersona() {
cantidadPersonas++;
}
// Método para restar personas del grupo
void restarPersona() {
if (cantidadPersonas > 0) {
cantidadPersonas--;
}
}
// Método para cambiar el precio de la entrada
void cambiarPrecioEntrada(double nuevoPrecio) {
precioEntrada = nuevoPrecio;
}
// Método para mostrar la información del grupo
void mostrarInformacion() {
std::cout << "Cantidad de personas: " << cantidadPersonas << std::endl;
std::cout << "Precio de la entrada: $" << precioEntrada << std::endl;
std::cout << "Precio total: $" << calcularPrecioTotal() << std::endl;
}
};
int main() {
// Crear un grupo de 5 personas con un precio de entrada de $5
Grupo grupo(5, 5.0);
// Mostrar la información inicial del grupo
grupo.mostrarInformacion();
// Agregar 2 personas al grupo
grupo.agregarPersona();
grupo.agregarPersona();
// Mostrar la información actualizada del grupo
grupo.mostrarInformacion();
// Restar 1 persona del grupo
grupo.restarPersona();
// Mostrar la información actualizada del grupo
grupo.mostrarInformacion();
// Cambiar el precio de la entrada a $10
grupo.cambiarPrecioEntrada(10.0);
// Mostrar la información actualizada del grupo
grupo.mostrarInformacion();
return 0;
}
```
Este código define una clase `Grupo` con los siguientes métodos:
* `calcularPrecioTotal()`: Calcula el precio total de las entradas multiplicando la cantidad de personas por el precio de la entrada.
* `agregarPersona()`: Agrega una persona al grupo incrementando la cantidad de personas.
* `restarPersona()`: Resta una persona del grupo decrementando la cantidad de personas, siempre y cuando no se llegue a 0.
* `cambiarPrecioEntrada()`: Cambia el precio de la entrada a un valor nuevo.
* `mostrarInformacion()`: Muestra la información del grupo, incluyendo la cantidad de personas, el precio de la entrada y el precio total.
En el `main()`, se crea un grupo de 5 personas con un precio de entrada de $5 y se muestran las operaciones adicionales que se pueden realizar con el grupo.
