La idea de estos ejercicios es que practiques y te des la oportunidad de pensar antes de buscar una respuesta.
Si un ejercicio no sale a la primera, eso hace parte del proceso normal de aprender a programar. Programar se aprende intentando construir una solución, encontrando errores, revisando qué ocurrió, haciendo cambios y volviendo a probar. Cada intento ayuda a desarrollar la forma de pensar que se necesita para resolver nuevos problemas.
Esa dificultad puede ser útil. Cuando tienes que recordar cómo funciona un ciclo, decidir qué variable necesitas, identificar qué cambia en cada repetición o seguir paso a paso lo que ocurre en un arreglo, estás haciendo un esfuerzo que fortalece el aprendizaje.
Por eso, intenta primero cada ejercicio por tu cuenta. Si algo falla, revisa el código, sigue algunas iteraciones del ciclo y piensa qué podría estar pasando.
Si después de intentarlo necesitas ayuda, puedes usar el prompt para revisar tu solución. Este prompt no te entrega el código corregido, pero te hace preguntas y te da pistas para que encuentres el problema y hagas tú mismo los cambios.
La meta es practicar lo suficiente para que cada vez te resulte más natural reconocer estos patrones, detectar errores y construir tus propias soluciones.
Estos ejercicios permiten practicar ciclos for con arreglos estáticos de enteros en C++. El foco está en dos patrones frecuentes:
- Acumulación: recorrer un arreglo y construir un único resultado, por ejemplo una suma, un conteo o un valor máximo.
- Transformación: recorrer un arreglo y producir nuevos valores a partir de los elementos originales, generalmente almacenándolos en otro arreglo.
Cada ejercicio es independiente. No es necesario conservar variables ni resultados de ejercicios anteriores.
HAGALOS EN PAPEL Para todos los ejercicios se recomienda trabajar con arreglos estáticos de tipo
inty ciclosfor.
Actúa como tutor socrático de programación en C++.
Estoy aprendiendo a trabajar con ciclos `for` de repetición definida y arreglos estáticos de enteros. Estoy practicando especialmente dos patrones:
1. Acumulación: recorrer un arreglo para construir un resultado, como una suma, un conteo, un máximo o un mínimo.
2. Transformación: recorrer un arreglo para producir valores modificados y almacenarlos en otro arreglo.
Voy a adjuntar una fotografía o captura de pantalla de mi solución a un ejercicio.
Tu tarea es ayudarme a revisar y corregir mi propio código mediante preguntas. No debes resolver el ejercicio por mí.
Sigue estas reglas:
- Lee el código de la imagen antes de comenzar.
- Pideme que te diga cuál era el ejercicio
- Si alguna parte de la imagen no se puede leer con suficiente claridad, pregúntame qué dice esa parte. No inventes código.
- Identifica qué intenta hacer mi solución y qué patrón parece utilizar.
- No escribas inmediatamente una versión corregida del código.
- No me digas directamente cuál es el error si puedo descubrirlo mediante una pregunta.
- Haz UNA pregunta a la vez y espera mi respuesta antes de continuar.
- Empieza por preguntas generales y avanza hacia preguntas más específicas solamente si lo necesito.
- Cuando encuentres un posible error, dirige mi atención hacia esa parte del código y pregúntame qué creo que sucede allí.
- Puedes pedirme que haga una traza manual de una o dos iteraciones del ciclo.
- Puedes preguntarme por el valor que tendría una variable en un momento determinado.
- Puedes pedirme que compare lo que esperaba obtener con lo que produce el código.
- Si respondo incorrectamente, no reveles inmediatamente la respuesta. Dame una pista pequeña y vuelve a preguntarme.
- Si después de varias pistas sigo sin encontrar el problema, explícame el concepto que necesito, pero deja que yo proponga el cambio en el código.
- No introduzcas `vector`, arreglos dinámicos, ciclos `while`, funciones o herramientas más avanzadas para reemplazar mi solución.
- Trabaja con los conceptos del ejercicio: arreglos estáticos de `int`, posiciones del arreglo, ciclo `for`, condiciones, acumuladores, contadores y arreglos de transformación.
- No cambies mi estrategia si puede corregirse con los conceptos que estoy practicando.
Cuando yo crea que terminé, revisa nuevamente toda mi solución.
Si todavía existe un problema, continúa con preguntas.
Si la solución ya es correcta, indícamelo y hazme una última pregunta para comprobar que entiendo por qué funciona.
Comienza observando mi imagen y dime brevemente qué entiendes que intenta hacer mi código. Después hazme solamente la primera pregunta.
- Resuelva primero el ejercicio por su cuenta.
- Tome una foto o captura clara de su código.
- Copie el prompt y adjunte la imagen.
- Responda una a una las preguntas que haga el tutor.
- Corrija usted mismo el código y vuelva a compartirlo si es necesario.
Dado el siguiente arreglo:
int numeros[6] = {4, 7, 2, 9, 5, 3};Escriba un funcion/procedimiento que recorra el arreglo y calcule la suma de todos sus elementos.
El resultado esperado es:
La suma es: 30
Dado el siguiente arreglo:
int numeros[8] = {5, 8, 12, 3, 7, 10, 4, 9};Escriba un funcion/procedimiento que recorra el arreglo y cuente cuántos números pares contiene.
El resultado esperado es:
Cantidad de numeros pares: 4
Dado el siguiente arreglo:
int valores[7] = {-4, 6, -2, 9, 3, -5, 8};Escriba un funcion/procedimiento que calcule la suma únicamente de los valores mayores que cero.
El resultado esperado es:
Suma de positivos: 26
Dado el siguiente arreglo:
int edades[8] = {14, 21, 18, 25, 16, 30, 19, 17};Escriba un funcion/procedimiento que cuente cuántos valores son mayores o iguales a 18.
El resultado esperado es:
Cantidad de valores mayores o iguales a 18: 5
Dado el siguiente arreglo:
int numeros[7] = {13, 5, 21, 8, 17, 4, 19};Escriba un funcion/procedimiento que recorra el arreglo y determine cuál es el valor más grande.
Para resolverlo, se debe utilizar una variable acumuladora que conserve el mayor valor encontrado hasta cada posición del recorrido.
El resultado esperado es:
El valor mayor es: 21
Dado el siguiente arreglo:
int numeros[5] = {3, 6, 2, 8, 4};Cree un segundo arreglo del mismo tamaño. Recorra el arreglo original y almacene en el nuevo arreglo cada valor multiplicado por dos.
El arreglo transformado debe contener:
6 12 4 16 8
Dado el siguiente arreglo:
int valores[6] = {-3, 7, -5, 2, -9, 4};Cree un segundo arreglo que contenga los mismos valores, pero transformando los números negativos en positivos.
No se debe modificar el arreglo original.
El arreglo transformado debe contener:
3 7 5 2 9 4
Dado el siguiente arreglo:
int puntajes[6] = {50, 70, 65, 80, 90, 55};Cree un segundo arreglo en el que cada puntaje tenga un aumento de 5 puntos.
Si el resultado supera 100, el valor almacenado debe ser 100.
El arreglo transformado debe contener:
55 75 70 85 95 60
Dado el siguiente arreglo:
int temperaturas[7] = {18, 22, 15, 30, 27, 12, 25};Cree un segundo arreglo siguiendo esta regla:
- si la temperatura es menor que 20, almacenar
0; - si la temperatura es mayor o igual a 20, conservar el valor original.
El arreglo transformado debe contener:
0 22 0 30 27 0 25
Dado el siguiente arreglo:
int notas[8] = {45, 72, 88, 59, 91, 67, 50, 76};Cree un segundo arreglo usando las siguientes reglas:
- almacenar
0si la nota es menor que 60; - almacenar
1si la nota está entre 60 y 79; - almacenar
2si la nota es mayor o igual a 80.
El arreglo resultante debe contener:
0 1 2 0 2 1 0 1
Dado el siguiente arreglo:
int ventas[8] = {120, 80, 150, 60, 200, 95, 140, 75};En un mismo recorrido del arreglo, calcule:
- la suma total de las ventas;
- la cantidad de ventas mayores o iguales a 100.
Resultados esperados:
Total de ventas: 920
Ventas mayores o iguales a 100: 4
Dado el siguiente arreglo:
int precios[6] = {100, 200, 150, 80, 120, 250};Cree un segundo arreglo aplicando un aumento de 10 unidades a cada precio.
Durante el mismo recorrido, calcule también la suma de los valores transformados.
El nuevo arreglo debe contener:
110 210 160 90 130 260
La suma esperada es:
Total transformado: 960
En cada ejercicio se debe identificar primero qué papel cumple cada variable dentro del ciclo.
En los ejercicios de acumulación suele aparecer una variable que conserva un resultado parcial, por ejemplo:
int acumulador = 0;En los ejercicios de transformación suele utilizarse un segundo arreglo para almacenar los valores producidos durante el recorrido:
int resultado[6];El ciclo de repetición definida mantiene una estructura similar:
for (int i = 0; i < TAMANIO; i++) {
// operación con arreglo[i]
}La variable i representa la posición que se está recorriendo. El límite del ciclo debe coincidir con la cantidad de posiciones disponibles en el arreglo.