(Cantidad de ejercicios propuestos en esta versión del curso: 444)
1.2.1: Crea un programa en C# que te salude por tu nombre (por ejemplo, "Hola, Nacho").
1.3.1.1: Desde Linux, crea y prueba un programa en C# que escriba en pantalla "Bienvenido a Linux".
1.4.1: Crea un programa que diga el resultado de sumar 118 y 56.
1.4.2: Crea un programa que diga el resultado de sumar 12345 y 67890.
1.5.1.1: Hacer un programa que calcule el producto de los números 12 y 13.
1.5.1.2: Hacer un programa que calcule la diferencia (resta) entre 321 y 213.
1.5.1.3: Hacer un programa que calcule el resultado de dividir 301 entre 3.
1.5.1.4: Hacer un programa que calcule el resto de la división de 301 entre 3.
1.5.2.1: Calcular el resultado de -2 + 3 * 5
1.5.2.2: Calcular el resultado de (20+5) % 6
1.5.2.3: Calcular el resultado de 15 + -5*6 / 10
1.5.2.4: Calcular el resultado de 2 + 10 / 5 * 2 - 7 % 1
1.6.1.1: Amplía el "ejemplo 01.05.02a" para declarar tres variables, llamadas n1, n2, n3.
1.6.2.1: Amplía el ejercicio 1.6.1.1, para que las tres variables n1, n2, n3 estén declaradas en la misma línea y tengan valores iniciales.
1.6.3.1: Crea un programa que calcule el producto de los números 121 y 132, usando variables.
1.6.3.2: Crea un programa que calcule la suma de 285 y 1396, usando variables.
1.6.3.3: Crea un programa que calcule el resto de dividir 3784 entre 16, usando variables.
1.6.3.4: Amplía el ejercicio 1.6.2.1, para que se muestre el resultado de la operación n1+n2*n3.
1.7.1: Crea un programa que calcule el producto de los números 87 y 94, usando variables llamadas "numero1" y "numero2".
1.7.2: Intenta crear una nueva versión del programa que calcula el producto de los números 87 y 94, usando esta vez variables llamadas "1numero" y "2numero".
1.7.3: Intenta crear una nueva versión del programa que calcula el producto de los números 87 y 94, usando esta vez variables llamadas "numero 1" y "numero 2".
1.7.4: Crea una nueva versión del programa que calcula el producto de los números 87 y 94, usando esta vez variables llamadas "número1" y "número2".
1.8.1: Crea un programa que convierta una cantidad prefijada de metros (por ejemplo, 3000) a millas. La equivalencia es 1 milla = 1609 metros. Usa comentarios donde te parezca adecuado.
1.9.1: Crea un programa que calcule el producto de dos números introducidos por el usuario.
1.9.2: Crea un programa que calcule la división de dos números introducidos por el usuario, así como el resto de esa división.
1.9.3: Suma tres números tecleados por usuario.
1.9.4: Pide al usuario una cantidad de "millas náuticas" y muestra la equivalencia en metros, usando: 1 milla náutica = 1852 metros.
1.10.1: Crea una nueva versión del programa que calcula el producto de dos números introducidos por el usuario (1.9.1), empleando "using System". El programa deberá contener un comentario al principio, que recuerde cual es su objetivo.
1.10.2: Crea una nueva versión del programa que calcula la división de dos números introducidos por el usuario, así como el resto de esa división (1.9.2), empleando "using System". Deberás incluir un comentario con tu nombre y la fecha en que has realizado el programa.
1.11.1: El usuario tecleará dos números (a y b), y el programa mostrará el resultado de la operación (a+b)*(a-b) y el resultado de la operación a2-b2. Ambos resultados se deben mostrar en la misma línea.
1.11.2: Pedir al usuario un número y mostrar su tabla de multiplicar, usando {0},{1} y {2}. Por ejemplo, si el número es el 3, debería escribirse algo como
3 x 0 = 0
3 x 1 = 3
3 x 2 = 6
…
3 x 10 = 30
1.11.3: Crea una variante del programa anterior, que pide al usuario un número y muestra su tabla de multiplicar. Esta vez no deberás utilizar {0}, {1}, {2}, sino "Write".
1.11.4: Crea un programa que convierta de grados Celsius (centígrados) a Kelvin y a Fahrenheit: pedirá al usuario la cantidad de grados centígrados y usará las siguiente tablas de conversión: kelvin = celsius + 273 ; fahrenheit = celsius x 18 / 10 + 32. Emplea "Write" en vez de "{0}" cuando debas mostrar varios datos en la misma línea.
2.1.1.1: Crea un programa que pida al usuario un número entero y diga si es par (pista: habrá que comprobar si el resto que se obtiene al dividir entre dos es cero: if (x % 2 == 0) ...).
2.1.1.2: Crea un programa que pida al usuario dos números enteros y diga cuál es el mayor de ellos.
2.1.1.3: Crea un programa que pida al usuario dos números enteros y diga si el primero es múltiplo del segundo (pista: igual que antes, habrá que ver si el resto de la división es cero: a % b == 0).
2.1.2.1: Crea un programa que pida al usuario un número entero. Si es múltiplo de 10, informará al usuario y pedirá un segundo número, para decir a continuación si este segundo número también es múltiplo de 10.
2.1.3.1: Crea un programa que multiplique dos números enteros de la siguiente forma: pedirá al usuario un primer número entero. Si el número que se que teclee es 0, escribirá en pantalla "El producto de 0 por cualquier número es 0". Si se ha tecleado un número distinto de cero, se pedirá al usuario un segundo número y se mostrará el producto de ambos.
2.1.3.2: Crea un programa que pida al usuario dos números enteros. Si el segundo no es cero, mostrará el resultado de dividir ###el primero entre el segundo###. Por el contrario, si el segundo número es cero, escribirá "Error: No se puede dividir entre cero".
2.1.4.1: Mejora la solución al ejercicio 2.1.3.1, usando "else".
2.1.4.2: Mejora la solución al ejercicio 2.1.3.2, usando "else".
2.1.5.1: Crea un programa que pida al usuario un número entero y responda si es múltiplo de 2 o de 3.
2.1.5.2: Crea un programa que pida al usuario un número entero y responda si es múltiplo de 2 y de 3 simultáneamente.
2.1.5.3: Crea un programa que pida al usuario un número entero y responda si es múltiplo de 2 pero no de 3.
2.1.5.4: Crea un programa que pida al usuario un número entero y responda si no es múltiplo de 2 ni de 3.
2.1.5.5: Crea un programa que pida al usuario dos números enteros y diga si ambos son pares.
2.1.5.6: Crea un programa que pida al usuario dos números enteros y diga si (al menos) uno es par.
2.1.5.7: Crea un programa que pida al usuario dos números enteros y diga si uno y sólo uno es par.
2.1.5.8: Crea un programa que pida al usuario dos números enteros y diga "Uno de los números es positivo", "Los dos números son positivos" o bien "Ninguno de los números es positivo", según corresponda.
2.1.5.9: Crea un programa que pida al usuario tres números y muestre cuál es el mayor de los tres.
2.1.5.10: Crea un programa que pida al usuario dos números enteros y diga si son iguales o, en caso contrario, cuál es el mayor de ellos.
2.1.6.1: Crea una variante del ejemplo 02_01_06a, en la que la comparación de igualdad sea correcta y en la que las variables aparezcan en el lado derecho de la comparación y los números en el lado izquierdo.
2.1.7.1: Crea el diagrama de flujo para el programa que pide dos números al usuario y dice cuál es el mayor de los dos.
2.1.7.2: Crea el diagrama de flujo para el programa que pide al usuario dos números y dice si uno de ellos es positivo, si lo son los dos o si no lo es ninguno.
2.1.7.3: Crear el diagrama de flujo para el programa que pide tres números al usuario y dice cuál es el mayor de los tres.
2.1.8.1: Crea un programa que use el operador condicional para mostrar un el valor absoluto de un número de la siguiente forma: si el número es positivo, se mostrará tal cual; si es negativo, se mostrará cambiado de signo.
2.1.8.2: Usa el operador condicional para calcular el menor de dos números.
2.1.9.1: Crea un programa que pida un número del 1 al 5 al usuario, y escriba el nombre de ese número, usando "switch" (por ejemplo, si introduce "1", el programa escribirá "uno").
2.1.9.2: Crea un programa que lea una letra tecleada por el usuario y diga si se trata de un signo de puntuación (. , ; :), una cifra numérica (del 0 al 9) o algún otro carácter, usando "switch" (pista: habrá que usar un dato de tipo "char").
2.1.9.3: Crea un programa que lea una letra tecleada por el usuario y diga si se trata de una vocal, una cifra numérica o una consonante, usando "switch"
2.1.9.4: Repite el ejercicio 2.1.9.1, empleando "if" en lugar de "switch".
2.1.9.5: Repite el ejercicio 2.1.9.2, empleando "if" en lugar de "switch" (pista: como las cfras numéricas del 0 al 9 están ordenadas, no hace falta comprobar los 10 valores, sino que se puede hacer con "if ((simbolo >= '0') && (simbolo <='9'))").
2.1.9.6: Repite el ejercicio 2.1.9.3, empleando "if" en lugar de "switch".
2.2.1.1.1: Crea un programa que pida al usuario su contraseña (numérica). Deberá terminar cuando introduzca como contraseña el número 1111, pero volvérsela a pedir tantas veces como sea necesario.
2.2.1.1.2: Crea un "calculador de cuadrados": pedirá al usuario un número y mostrará su cuadrado. Se repetirá mientras el número introducido no sea cero (usa "while" para conseguirlo).
2.2.1.1.3: Crea un programa que pida de forma repetitiva pares de números al usuario. Tras introducir cada par de números, responderá si el primero es múltiplo del segundo.
2.2.1.1.4: Crea una versión mejorada del programa anterior, que, tras introducir cada par de números, responderá si el primero es múltiplo del segundo, o el segundo es múltiplo del primero, o ninguno de ellos es múltiplo del otro.
2.2.1.2.1: Crea un programa que escriba en pantalla los números del 1 al 10, usando "while".
2.2.1.2.2: Crea un programa que escriba en pantalla los números pares del 26 al 10 (descen-diendo), usando "while".
2.2.1.2.3: Crea un programa calcule cuantas cifras tiene un número entero positivo (pista: se puede hacer dividiendo varias veces entre 10).
2.2.1.2.4: Crea el diagrama de flujo y la versión en C# de un programa que dé al usuario tres oportunidades para adivinar un número del 1 al 10.
2.2.2.1: Crear un programa que pida números positivos al usuario, y vaya calculando y mostrando la suma de todos ellos (terminará cuando se teclea un número negativo o cero).
2.2.2.2: Crea un programa que escriba en pantalla los números del 1 al 10, usando "do..while".
2.2.2.3: Crea un programa que escriba en pantalla los números pares del 26 al 10 (descen-diendo), usando "do..while".
2.2.2.4: Crea un programa que pida al usuario su identificador y su contraseña (ambos numéricos), y no le permita seguir hasta que introduzca como identificador "1234" y como contraseña "1111".
2.2.2.5: Crea un programa que pida al usuario su identificador y su contraseña, y no le permita seguir hasta que introduzca como nombre "Pedro" y como contraseña "Peter".
2.2.3.1: Crea un programa que muestre los números del 10 al 20, ambos incluidos.
2.2.3.2: Crea un programa que escriba en pantalla los números del 1 al 50 que sean múltiplos de 3 (pista: habrá que recorrer todos esos números y ver si el resto de la división entre 3 resulta 0).
2.2.3.3: Crea un programa que muestre los números del 100 al 200 (ambos incluidos) que sean divisibles entre 7 y a la vez entre 3.
2.2.3.4: Crea un programa que muestre la tabla de multiplicar del 9.
2.2.3.5: Crea un programa que muestre los primeros ocho números pares: 2 4 6 8 10 12 14 16 (pista: en cada pasada habrá que aumentar de 2 en 2, o bien mostrar el doble del valor que hace de contador).
2.2.3.6: Crea un programa que muestre los números del 15 al 5, descendiendo (pista: en cada pasada habrá que descontar 1, por ejemplo haciendo i=i-1, que se puede abreviar i--).
2.2.4.1: Crea un programa que contenga un bucle sin fin que escriba "Hola " en pantalla, sin avanzar de línea.
2.2.4.2: Crea un programa que contenga un bucle sin fin que muestre los números enteros positivos a partir del uno.
2.2.5.1: Crea un programa escriba 4 veces los números del 1 al 5, en una misma línea, usando "for": 12345123451234512345.
2.2.5.2: Crea un programa escriba 4 veces los números del 1 al 5, en una misma línea, usando "while": 12345123451234512345.
2.2.5.3: Crea un programa que, para los números entre el 10 y el 20 (ambos incluidos) diga si son divisibles entre 5, si son divisibles entre 6 y si son divisibles entre 7.
2.2.6.1: Crea un programa que escriba 4 líneas de texto, cada una de las cuales estará formada por los números del 1 al 5.
2.2.6.2: Crea un programa que pida al usuario el ancho (por ejemplo, 4) y el alto (por ejemplo, 3) y escriba un rectángulo formado por esa cantidad de asteriscos: **** **** ****
2.2.7.1: Crea un programa que muestre las letras de la Z (mayúscula) a la A (mayúscula, descendiendo).
2.2.7.2: Crea un programa que muestre 5 veces las letras de la L (mayúscula) a la N (mayúscula), en la misma línea.
2.2.8.1: Crea un programa que escriba 6 líneas de texto, cada una de las cuales estará formada por los números del 1 al 7. Debes usar dos variables llamadas "linea" y "numero", y ambas deben estar declaradas en el "for".
2.2.8.2: Crea un programa que pida al usuario el ancho (por ejemplo, 4) y el alto (por ejemplo, 3) y escriba un rectángulo formado por esa cantidad de asteriscos, como en el ejercicio 2.2.6.2. Deberás usar las variables "ancho" y "alto" para los datos que pidas al usuario, y las variables "filaActual" y "columnaActual" (declaradas en el "for") para el bloque repetitivo.
2.2.9.1: Crea un programa que pida un número al usuario y escriba los múltiplos de 9 que haya entre 1 ese número. Debes usar llaves en todas las estructuras de control, aunque sólo incluyan una sentencia.
2.2.9.2: Crea un programa que pida al usuario dos números y escriba sus divisores comunes. Debes usar llaves en todas las estructuras de control, aunque sólo incluyan una sentencia.
2.2.10.1: Crea un programa que pida al usuario dos números y escriba su máximo común divisor (pista: una solución lenta pero sencilla es probar con un "for" todos los números descendiendo a partir del menor de ambos, hasta llegar a 1; cuando encuentres un número que sea divisor de ambos, interrumpes la búsqueda).
2.2.10.2: Crea un programa que pida al usuario dos números y escriba su mínimo común múltiplo (pista: una solución lenta pero sencilla es probar con un "for" todos los números a partir del mayor de ambos, de forma creciente; cuando encuentres un número que sea múltiplo de ambos, interrumpes la búsqueda).
2.2.11.1: Crea un programa que escriba los números del 20 al 10, descendiendo, excepto el 13, usando "continue".
2.2.11.2: Crea un programa que escriba los números pares del 2 al 106, excepto los que sean múltiplos de 10, usando "continue".
2.2.12.1: Crea un programa que escriba los números del 100 al 200, separados por un espacio, sin avanzar de línea, usando "for". En la siguiente línea, vuelve a escribirlos usando "while".
2.2.12.2: Crea un programa que escriba los números pares del 20 al 10, descendiendo, excepto el 14, primero con "for" y luego con "while".
2.3.1: Crea un programa que escriba los números del 1 al 10, separados por un espacio, sin avanzar de línea. No puedes usar "for", ni "while", ni "do..while", sólo "if" y "goto".
2.5.1: Crea un programa que cuente cuantas veces aparece la letra 'a' en una frase que teclee el usuario, utilizando "foreach".
2.6.1: Crear un programa que dé al usuario la oportunidad de adivinar un número del 1 al 100 (prefijado en el programa) en un máximo de 6 intentos. En cada pasada deberá avisar de si se ha pasado o se ha quedado corto.
2.6.2: Crear un programa que descomponga un número (que teclee el usuario) como producto de su factores primos. Por ejemplo, 60 = 2 · 2 · 3 · 5
2.6.3: Crea un programa que calcule un número elevado a otro, usando multiplicaciones sucesivas.
2.6.4: Crea un programa que "dibuje" un rectángulo formado por asteriscos, con el ancho y el alto que indique el usuario, usando dos "for" anidados. Por ejemplo, si desea anchura 4 y altura 3, el rectángulo sería así: **** **** ****
2.6.5: Crea un programa que "dibuje" un triángulo decreciente, con la altura que indique el usuario. Por ejemplo, si el usuario dice que desea 4 caracteres de alto, el triángulo sería así: **** *** ** *
2.6.6: Crea un programa que "dibuje" un rectángulo hueco, cuyo borde sea una fila (o columna) de asteriscos y cuyo interior esté formado por espacios en blanco, con el ancho y el alto que indique el usuario. Por ejemplo, si desea anchura 4 y altura 3, el rectángulo sería así: **** * * ****
2.6.7: Crea un programa que "dibuje" un triángulo creciente, alineado a la derecha, con la altura que indique el usuario. Por ejemplo, si el usuario dice que desea 4 caracteres de alto, el triángulo sería así: * ** *** ****
2.6.8: Crea un programa que devuelva el cambio de una compra, utilizando monedas (o billetes) del mayor valor posible. Supondremos que tenemos una cantidad ilimitada de monedas (o billetes) de 100, 50, 20, 10, 5, 2 y 1, y que no hay decimales. La ejecución podría ser algo como: Precio? 44 Pagado? 100 Su cambio es de 56: 50 5 1 Precio? 1 Pagado? 100 Su cambio es de 99: 50 20 20 5 2 2
2.6.9: Crea un programa que "dibuje" un cuadrado formado por cifras sucesivas, con el tamaño que indique el usuario, hasta un máximo de 9. Por ejemplo, si desea tamaño 5, el cuadrado sería así: 11111 22222 33333 44444 55555
2.7.1: Crea un programa que pregunte al usuario su edad y su año de nacimiento. Si la edad que introduce no es un número válido, mostrará un mensaje de aviso. Lo mismo ocurrirá si el año de nacimiento no es un número válido.
2.7.2: Crea un programa que pregunte al usuario su edad y su año de nacimiento. Si la edad que introduce no es un número válido, mostrará un mensaje de aviso, pero aun así le preguntará su año de nacimiento.
3.1.1.1: Calcula el producto de 1.000.000 por 1.000.000, usando una variable llamada "producto", de tipo "long". Prueba también a calcularlo usando una variable de tipo "int".
3.1.2.1: Pregunta al usuario su edad, que se guardará en un "byte". A continuación, le deberás decir que no aparenta tantos años (por ejemplo, "No aparentas 20 años").
3.1.2.2: Pide al usuario dos números de dos cifras ("byte"), calcula su multiplicación, que se deberá guardar en un "ushort", y muestra el resultado en pantalla.
3.1.2.3: Pide al usuario dos números enteros largos ("long") y muestra su suma, su resta y su producto.
3.1.3.1: Crea un programa que use tres variables x,y,z. Sus valores iniciales serán 15, -10, 2.147.483.647. Se deberá incrementar el valor de estas variables. ¿Qué valores esperas que se obtengan? Contrástalo con el resultado obtenido por el programa.
3.1.3.2: ¿Cuál sería el resultado de las siguientes operaciones? a=5; b=++a; c=a++; b=b*5; a=a*2; Calcúlalo a mano y luego crea un programa que lo resuelva, para ver si habías hallado la solución correcta.
3.1.4.1: Crea un programa que use tres variables x,y,z. Sus valores iniciales serán 15, -10, 214. Deberás incrementar el valor de estas variables en 12, usando el formato abreviado. ¿Qué valores esperas que se obtengan? Contrástalo con el resultado obtenido por el programa.
3.1.4.2: ¿Cuál sería el resultado de las siguientes operaciones? a=5; b=a+2; b-=3; c=-3; c*=2; ++c; a*=b; Crea un programa que te lo muestre.
3.2.1.1: Crea un programa que muestre el resultado de dividir 3 entre 4 usando números enteros y luego usando números de coma flotante.
3.2.1.2: ¿Cuál sería el resultado de las siguientes operaciones, usando números reales? a=5; a/=2; a+=1; a*=3; --a;
3.2.2.1: Crea un programa que muestre el resultado de dividir 13 entre 6 usando números enteros, luego usando números de coma flotante de simple precisión y luego con números de doble precisión.
3.2.2.2: Calcula el área de un círculo, dado su radio, que será un número entero (área = pi * radio al cuadrado)
3.2.3.1: Calcula el volumen de una esfera, dado su radio, que será un número de doble precisión (volumen = pi * radio al cubo * 4/3)
3.2.3.2: Crea un programa que pida al usuario a una distancia (en metros) y el tiempo necesario para recorrerla (como tres números: horas, minutos, segundos), y muestre la velocidad, en metros por segundo, en kilómetros por hora y en millas por hora (pista: 1 milla = 1.609 metros).
3.2.3.3: Halla las soluciones de una ecuación de segundo grado del tipo y = Ax2 + Bx + C. Pista: la raíz cuadrada de un número x se calcula con Math.Sqrt(x)
3.2.3.4: Si se ingresan E euros en el banco a un cierto interés I durante N años, el dinero obtenido viene dado por la fórmula del interés compuesto: Resultado = e (1+ i)n Aplicarlo para calcular en cuanto se convierten 1.000 euros al cabo de 10 años al 3% de interés anual.
3.2.3.5: Crea un programa que muestre los primeros 20 valores de la función y = x2 - 1
3.2.3.6: Crea un programa que "dibuje" la gráfica de y = (x-5)2 para valores de x entre 1 y 10. Deberá hacerlo dibujando varios espacios en pantalla y luego un asterisco. La cantidad de espacios dependerá del valor obtenido para "y".
3.2.3.7: Escribe un programa que calcule una aproximación de PI mediante la expresión: pi/4 = 1/1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + 1/13 ... El usuario deberá indicar la cantidad de términos a utilizar, y el programa mostrará todos los resultados hasta esa cantidad de términos. Debes hacer todas las operacion con "double".
3.2.4.1: Crea un programa que calcule la raíz cuadrada del número que introduzca el usuario. La raíz se deberá calcular como "double", pero el resultado se mostrará como "float"
3.2.4.2: Crea una nueva versión del un programa que calcula una aproximación de PI mediante la expresión: pi/4 = 1/1 - 1/3 + 1/5 - 1/7 + 1/9 - 1/11 + 1/13 (...) con tantos términos como indique el usuario. Debes hacer todas las operacion con "double", pero mostrar el resultado como "float".
3.2.5.1: El usuario de nuestro programa podrá teclear dos números de hasta 12 cifras significativas. El programa deberá mostrar el resultado de dividir el primer número entre el segundo, utilizando tres cifras decimales.
3.2.5.2: Crea un programa que use tres variables x,y,z. Las tres serán números reales, y nos bastará con dos cifras decimales. Se deberá pedir al usuario los valores para las tres variables y mostrar en pantalla el valor de x2 + y - z (con exactamente dos cifras decimales).
3.2.5.3: Calcula el perímetro, área y diagonal de un rectángulo, a partir de su ancho y alto (perímetro = suma de los cuatro lados; área = base x altura; diagonal, usando el teorema de Pitágoras). Muestra todos ellos con una cifra decimal.
3.2.5.4: Calcula la superficie y el volumen de una esfera, a partir de su radio (superficie = 4 * pi * radio al cuadrado; volumen = 4/3 * pi * radio al cubo). Usa datos "doble" y muestra los resultados con 5 cifras decimales.
3.2.6.1: Crea un programa que pida números (en base 10) al usuario y muestre su equivalente en sistema binario y en hexadecimal. Debe repetirse hasta que el usuario introduzca el número 0.
3.2.6.2: Crea un programa que pida al usuario la cantidad de rojo (por ejemplo, 255), verde (por ejemplo, 160) y azul (por ejemplo, 0) que tiene un color, y que muestre ese color RGB en notación hexadecimal (por ejemplo, FFA000).
3.2.6.3: Crea un programa para mostrar los números del 0 a 255 en hexadecimal, en 16 filas de 16 columnas cada una (la primera fila contendrá los números del 0 al 15 –decimal-, la segunda del 16 al 31 –decimal- y así sucesivamente).
3.2.6.4: Crea un programa que pida números binarios al usuario y muestre su equivalente en sistema hexadecimal y en decimal. Debe repetirse hasta que el usuario introduzca la palabra "fin".
3.3.1.1: Crea un programa que pida una letra al usuario y diga si se trata de una vocal.
3.3.1.2: Crea un programa que muestre una de cada dos letras entre la que teclee el usuario y la "z". Por ejemplo, si el usuario introduce una "a", se escribirá "aceg...".
3.3.1.3: Crea un programa que pida al usuario el ancho (por ejemplo, 4) y el alto (por ejemplo, 3) y una letra (por ejemplo, X) y escriba un rectángulo formado por esa cantidad de letras: XXXX XXXX XXXX
3.3.2.1: Crea un programa que pida al usuario que teclee cuatro letras y las muestre en pantalla juntas, pero en orden inverso, y entre comillas dobles. Por ejemplo si las letras que se teclean son a, l, o, h, escribiría "hola".
3.4.1: Crea un programa que pida al usuario su nombre, y le diga "Hola" si se llama "Juan", o bien le diga "No te conozco" si teclea otro nombre.
3.4.2: Crea un programa que pida al usuario un nombre y una contraseña. La contraseña se debe introducir dos veces. Si las dos contraseñas no son iguales, se avisará al usuario y se le volverán a pedir las dos contraseñas.
3.5.1: Crea un programa que use el operador condicional para dar a una variable llamada "iguales" (booleana) el valor "true" si los dos números que ha tecleado el usuario son iguales, o "false" si son distintos.
3.5.2: Crea una versión alternativa del ejercicio 3.5.1, que use "if" en vez del operador condicional.
3.5.3: Crea un programa que use el operador condicional para dar a una variable llamada "ambosPares" (booleana) el valor "true" si dos números introducidos por el usuario son pares, o "false" si alguno es impar.
3.5.4: Crea una versión alternativa del ejercicio 3.5.3, que use "if" en vez del operador condicional.
4.1.1.1: Un programa que pida al usuario 4 números, los memorice (utilizando un array), calcule su media aritmética y después muestre en pantalla la media y los datos tecleados.
4.1.1.2: Un programa que pida al usuario 5 números reales (pista: necesitarás un array de "float") y luego los muestre en el orden contrario al que se introdujeron.
4.1.2.1: Un programa que almacene en una tabla el número de días que tiene cada mes (su¬pon-dremos que es un año no bisiesto), pida al usuario que le indique un mes (1=enero, 12=diciembre) y muestre en pantalla el número de días que tiene ese mes.
4.1.3.1: Crea un programa que pida al usuario 6 números enteros cortos y luego los muestre en orden inverso (pista: usa un array para almacenarlos y "for" para mostrarlos).
4.1.3.2: Crea un programa que pregunte al usuario cuántos números enteros va a introducir (por ejemplo, 10), le pida todos esos números, los guarde en un array y finalmente calcule y muestre la media de esos números.
4.1.3.3: Un programa que pida al usuario 10 reales de doble precisión, calcule su media y luego muestre los que están por encima de la media.
4.1.3.4: Un programa que almacene en una tabla el número de días que tiene cada mes (de un año no bisiesto), pida al usuario que le indique un mes (ej. 2 para febrero) y un día (ej. el día 15) y diga qué número de día es dentro del año (por ejemplo, el 15 de febrero sería el día número 46, el 31 de diciembre sería el día 365).
4.1.3.5: A partir del ejercicio anterior, crea otro que pida al usuario que le indique la fecha, formada por día (1 al 31) y el mes (1=enero, 12=diciembre), y como respuesta muestre en pantalla el número de días que quedan hasta final de año.
4.1.3.6: Un programa que pida 10 nombres y los memorice (pista: esta vez se trata de un array de "string"). Después deberá pedir que se teclee un nombre y dirá si se encuentra o no entre los 10 que se han tecleado antes. Volverá a pedir otro nombre y a decir si se encuentra entre ellos, y así sucesivamente hasta que se teclee "fin".
4.1.3.7: Un programa que prepare espacio para guardar un máximo de 100 nombres. El usuario deberá ir introduciendo un nombre cada vez, hasta que se pulse Intro sin teclear nada, momento en el que dejarán de pedirse más nombres y se mostrará en pantalla la lista de los nombres que se han introducido.
4.1.3.8: Un programa que reserve espacio para un vector de 3 componentes, pida al usuario valores para dichas componentes (por ejemplo [2, -5, 7]) y muestre su módulo (raíz cuadrada de la suma de sus componentes al cuadrado).
4.1.3.9: Un programa que reserve espacio para dos vectores de 3 componentes, pida al usuario sus valores y calcule la suma de ambos vectores (su primera componente será x1+y1, la segunda será x2+y2 y así sucesivamente).
4.1.3.10: Un programa que reserve espacio para dos vectores de 3 componentes, pida al usuario sus valores y calcule su producto escalar (x1•y1+ x2•y2+x3•y3).
4.1.3.11: Un programa que pida al usuario 4 números enteros y calcule (y muestre) cuál es el mayor de ellos. Nota: para calcular el mayor valor de un array, hay que comparar cada uno de los valores que tiene almacenados el array con el que hasta ese momento es el máximo provisional. El valor inicial de este máximo provisional no debería ser cero (porque el resultado sería incorrecto si todos los números son negativos), sino el primer elemento del array.
4.1.4.1: Crea una variante del ejemplo anterior (04_01_04a) que pida al usuario el dato a buscar, avise si ese dato no aparece, y que diga cuántas veces se ha encontrado en caso contrario.
4.1.4.2: Crea una variante del ejemplo anterior (04_01_04a) que añada un dato introducido por el usuario al final de los datos existentes.
4.1.4.3: Crea una variante del ejemplo anterior (04_01_04a) que inserte un dato introducido por el usuario en la posición que elija el usuario. Debe avisar si la posición escogida es incorrecta (porque esté más allá del final de los datos).
4.1.4.4: Crea una variante del ejemplo anterior (04_01_04a) que borre el dato que se encuentre en la posición que elija el usuario. Debe avisar si la posición escogida no es válida.
4.1.4.5: Crea un programa que prepare espacio para un máximo de 10 nombres. Deberá mostrar al usuario un menú que le permita realizar las siguientes operaciones:
Añadir un dato al final de los ya existentes.
Insertar un dato en una cierta posición (como ya se ha comentado, los que quedén detrás deberán desplazarse "a la derecha" para dejarle hueco; por ejemplo, si el array contiene "hola", "adios" y se pide insertar "bien" en la segunda posición, el array pasará a contener "hola", "bien", "adios".
Borrar el dato que hay en una cierta posición (como se ha visto, lo que estaban detrás deberán desplazarse "a la izquierda" para que no haya huecos; por ejemplo, si el array contiene "hola", "bien", "adios" y se pide borrar el dato de la segunda posición, el array pasará a contener "hola", "adios"
Mostrar los datos que contiene el array.
Salir del programa.
4.1.5.1: Crea un programa que contenga un array con los nombres de los meses del año. El usuario podrá elegir entre verlos en orden natural (de Enero a Diciembre) o en orden inverso (de Diciembre a Enero). Usa constantes para el valor máximo del array en ambos recorridos.
4.2.1: Un programa que pida al usuario dos bloques de 10 números enteros (usando un array de dos dimensiones). Después deberá mostrar el mayor dato que se ha introducido en cada uno de ellos.
4.2.2: Un programa que pida al usuario dos bloques de 6 cadenas de texto. Después pedirá al usuario una nueva cadena y comprobará si aparece en alguno de los dos bloques de información anteriores.
4.2.3: Un programa que pregunte al usuario el tamaño que tendrán dos bloques de números enteros (por ejemplo, uno de 10 elementos y otro de 12). Luego pedirá los datos para ambos bloques de datos. Finalmente deberá mostrar el mayor dato que se ha introducido en cada uno de ellos.
4.2.4: Un programa que calcule el determinante de una matriz de 2x2.
4.2.5: Un programa que calcule el determinante de una matriz de 3x3.
4.2.6: Un programa que calcule si las filas de una matriz son linealmente dependientes.
4.2.7: Un programa que use matrices para resolver un sistema de ecuaciones lineales mediante el método de Gauss.
4.3.1.1: Crea un "struct" que almacene datos de una canción en formato MP3: Artista, Título, Duración (en segundos), Tamaño del fichero (en KB). Un programa debe pedir los datos de una canción al usuario, almacenarlos en dicho "struct" y después mostrarlos en pantalla.
4.3.2.1: Amplia el programa del ejercicio 4.3.1.1, para que almacene datos de hasta 100 canciones. Deberá tener un menú que permita las opciones: añadir una nueva canción, mostrar el título de todas las canciones, buscar la canción que contenga un cierto texto (en el artista o en el título).
4.3.2.2: Crea un programa que permita guardar datos de "imágenes" (ficheros de ordenador que contengan fotografías o cualquier otro tipo de información gráfica). De cada imagen se debe guardar: nombre (texto), ancho en píxeles (por ejemplo 2000), alto en píxeles (por ejemplo, 3000), tamaño en Kb (por ejemplo 145,6). El programa debe ser capaz de almacenar hasta 700 imágenes (deberá avisar cuando su capacidad esté llena). Debe permitir las opciones: añadir una ficha nueva, ver todas las fichas (número y nombre de cada imagen), buscar la ficha que tenga un cierto nombre.
4.3.3.1: Amplia el programa 4.3.2.1, para que el campo "duración" se almacene como minutos y segundos, usando un "struct" anidado que contenga a su vez estos dos campos.
4.4.1.1: Crea un programa que te pida tu nombre y lo escriba 5 veces.
4.4.1.2: Crea un programa que pida al usuario su nombre. Si se llama como tú (por ejemplo, "Nacho"), responderá "Bienvenido, jefe". En caso contrario, le saludará por su nombre.
4.4.1.3: Un programa que pida tu nombre, tu día de nacimiento y tu mes de nacimiento y lo junte todo en una cadena, separando el nombre de la fecha por una coma y el día del mes por una barra inclinada, así: "Juan, nacido el 31/12".
4.4.1.4: Crea un programa que pida al usuario dos números enteros y después una operación que realizar con ellos. La operación podrá ser "suma", "resta", multiplicación" y "división", que también se podrán escribir de forma abreviado con los operadores matemáticos "+", "-", "*" y "/". Para multiplicar también se podrá usar una "x", minúscula o mayúscula. A continuación se mostrará el resultado de esa operación (por ejemplo, si los números son 3 y 6 y la operación es "suma", el resultado sería 9). La operación debes tomarla como una cadena de texto y analizarla con un "switch".
4.4.2.1: Crea un programa que pregunte al usuario su nombre y le responda cuál es su inicial.
4.4.3.1: Un programa que te pida tu nombre y lo muestre en pantalla separando cada letra de la siguiente con un espacio. Por ejemplo, si tu nombre es "Juan", debería aparecer en pantalla "J u a n".
4.4.3.2: Un programa que pida una frase al usuario y la muestra en orden inverso (de la última letra a la primera).
4.4.3.3: Un programa que pida al usuario una frase, después una letra y finalmente diga si aparece esa letra como parte de esa frase o no.
4.4.3.4: Un programa capaz de sumar dos números enteros muy grandes (por ejemplo, de 30 cifras), que se deberán pedir como cadena de texto y analizar letra a letra.
4.4.3.5: Un programa capaz de multiplicar dos números enteros muy grandes (por ejemplo, de 30 cifras), que se deberán pedir como cadena de texto y analizar letra a letra.
4.4.4.1: Un programa que te pida tu nombre y lo muestre en pantalla separando cada letra de la siguiente con un espacio, similar al 4.4.3.1, pero esta vez usando "Substring". Por ejemplo, si tu nombre es "Juan", debería aparecer en pantalla "J u a n".
4.4.4.2: Un programa que te pida tu nombre y lo muestre en pantalla como un triángulo creciente. Por ejemplo, si tu nombre es "Juan", debería aparecer en pantalla: J Ju Jua Juan
4.4.5.1: Un programa que te pida tu nombre y lo muestre en pantalla separando cada letra de la siguiente con un espacio, similar al 4.4.3.1, pero esta vez usando "Substring". Por ejemplo, si tu nombre es "Juan", debería aparecer en pantalla "J u a n".
4.4.5.2: Un programa que te pida tu nombre y lo muestre en pantalla como un triángulo creciente. Por ejemplo, si tu nombre es "Juan", debería aparecer en pantalla: J Ju Jua Juan
4.4.6.1: Una variante del ejercicio 4.4.5.2, que no distinga entre mayúsculas y minúsculas a la hora de buscar.
4.4.6.2: Un programa que pida al usuario una frase y elimine todos los espacios redundantes que contenga (debe quedar sólo un espacio entre cada palabra y la siguiente).
4.4.7.1: Un programa que pida al usuario una frase y muestre sus palabras en orden inverso.
4.4.7.2: Un programa que pida al usuario varios números separados por espacios y muestre su suma.
4.4.8.1: Un programa que pida al usuario dos frases y diga cual sería la "mayor" de ellas (la que aparecería en último lugar en un diccionario).
4.4.8.2: Un programa que pida al usuario cinco frases, las guarde en un array y muestre la "mayor" de ellas.
4.4.9.1: Un programa que pida una cadena al usuario y la modifique, de modo que todas las vocales se conviertan en "o".
4.4.9.2: Un programa que pida una cadena al usuario y la modifique, de modo que las letras de las posiciones impares (primera, tercera, etc.) estén en minúsculas y las de las posiciones pares estén en mayúsculas, mostrando el resultado en pantalla. Por ejemplo, a partir de un nombre como "Nacho", la cadena resultante sería "nAcHo".
4.4.9.3: Crea un juego del ahorcado, en el que un primer usuario introduzca la palabra a adivinar, se muestre ésta oculta con guiones (-----) y el programa acepte las letras que introduzca el segundo usuario, cambiando los guiones por letras correctas cada vez que acierte (por ejemplo, a---a-t-). La partida terminará cuando se acierte la palabra por completo o el usuario agote sus 8 intentos.
4.5.1: Un programa que pida tu nombre y lo muestre con un espacio entre cada par de letras, usando "foreach".
4.5.2: Un programa que pida al usuario una frase y la descomponga en subcadenas separadas por espacios, usando "Split". Luego debe mostrar cada subcadena en una línea nueva, usando "foreach".
4.5.3: Un programa que pida al usuario varios números separados por espacios y muestre su suma (como el del ejercicio 4.4.7.2), pero empleando "foreach".
4.6.1: Un programa que pida el nombre, el apellido y la edad de una persona, los almacene en un "struct" y luego muestre los tres datos en una misma línea, separados por comas.
4.6.2: Un programa que pida datos de 8 personas: nombre, dia de nacimiento, mes de nacimiento, y año de nacimiento (que se deben almacenar en un array de structs). Después deberá repetir lo siguiente: preguntar un número de mes y mostrar en pantalla los datos de las personas que cumplan los años durante ese mes. Terminará de repetirse cuando se teclee 0 como número de mes.
4.6.3: Un programa que sea capaz de almacenar los datos de 50 personas: nombre, dirección, teléfono, edad (usando una tabla de structs). Deberá ir pidiendo los datos uno por uno, hasta que un nombre se introduzca vacío (se pulse Intro sin teclear nada). Entonces deberá aparecer un menú que permita:
Mostrar la lista de todos los nombres
Mostrar las personas de una cierta edad
Mostrar las personas cuya inicial sea la que el usuario indique
Salir del programa
(lógicamente, este menú debe repetirse hasta que se escoja la opción de "salir").
4.6.4: Mejorar la base de datos de ficheros (ejemplo 04_06a) para que no permita introducir tamaños incorrectos (números negativos) ni nombres de fichero vacíos.
4.6.5: Ampliar la base de datos de ficheros (ejemplo 04_06a) para que incluya una opción de búsqueda parcial, en la que el usuario indique parte del nombre y se muestre todos los ficheros que contienen ese fragmento (usando "Contains" o "IndexOf"). Esta búsqueda no debe distinguir mayúsculas y minúsculas (con la ayuda de ToUpper o ToLower).
4.6.6: Ampliar el ejercicio anterior (4.6.5) para que la búsqueda sea incremental: el usuario irá indicando letra a letra el texto que quiere buscar, y se mostrará todos los datos que lo contienen (por ejemplo, primero los que contienen "j", luego "ju", después "jua" y finalmente "juan").
4.6.7: Ampliar la base de datos de ficheros (ejemplo 04_06a) para que se pueda borrar un cierto dato (habrá que "mover hacia atrás" todos los datos que había después de ese, y disminuir el contador de la cantidad de datos que tenemos).
4.6.8: Mejorar la base de datos de ficheros (ejemplo 04_06a) para que se pueda modificar un cierto dato a partir de su número (por ejemplo, el dato número 3). En esa modificación, se deberá permitir al usuario pulsar Intro sin teclear nada, para indicar que no desea modificar un cierto dato, en vez de reemplazarlo por una cadena vacía.
4.6.9: Ampliar la base de datos de ficheros (ejemplo 04_06a) para que se permita ordenar los datos por nombre. Para ello, deberás buscar información sobre algún método de ordenación sencillo, como el "método de burbuja" (en el siguiente apartado tienes algunos), y aplicarlo a este caso concreto.
4.7.1: Un programa que pida al usuario 6 números en coma flotante y los muestre ordenados de menor a mayor. Escoge el método de ordenación que prefieras.
4.7.2: Un programa que pida al usuario 5 nombres y los muestre ordenados alfabéticamente (recuerda que para comparar cadenas no podrás usar el símbolo ">", sino "CompareTo").
4.7.3: Un programa que pida al usuario varios números, los vaya añadiendo a un array, mantenga el array ordenado continuamente y muestre el resultado tras añadir cada nuevo dato (todos los datos se mostrarán en la misma línea, separados por espacios en blanco). Terminará cuando el usuario teclee "fin".
4.7.4: Amplia el ejercicio anterior, para añadir una segunda fase en la que el usuario pueda "preguntar" si un cierto valor está en el array. Como el array está ordenado, la búsqueda no se hará hasta el final de los datos, sino hasta que se encuentre el dato buscado o un un dato mayor que él.
4.7.5: Realiza una variante del ejercicio 4.7.4, que en vez de hacer una búsqueda lineal (desde el principio), use "búsqueda binaria": se comenzará a comparar con el punto medio del array; si nuestro dato es menor, se vuelve a probar en el punto medio de la mitad inferior del array, y así sucesivamente.
4.7.6: Crea una variante del ejercicio 4.7.3, pero usando esta vez Array.Sort para ordenar: un programa que pida al usuario varios números, los vaya añadiendo a un array, mantenga el array ordenado continuamente y muestre el resultado tras añadir cada nuevo dato (todos los datos se mostrarán en la misma línea, separados por espacios en blanco). Terminará cuando el usuario teclee "fin".
5.2.1: Crea una función llamada "BorrarPantalla", que borre la pantalla dibujando 25 líneas en blanco. Crea también un "Main" que permita probarla.
5.2.2: Crea una función llamada "DibujarCuadrado3x3", que dibuje un cuadrado formato por 3 filas con 3 asteriscos cada una. Incluye un "Main" para probarla.
5.2.3: Descompón en funciones la base de datos de ficheros (ejemplo 04_06a), de modo que el "Main" sea breve y más legible (Pista: las variables que se compartan entre varias funciones deberán estar fuera de todas ellas, y deberán estar precedidas por la palabra "static").
5.3.1: Crea una función "DibujarCuadrado" que dibuje en pantalla un cuadrado del ancho (y alto) que se indique como parámetro. Completa el programa con un Main que permita probarla.
5.3.2: Crea una función "DibujarRectangulo" que dibuje en pantalla un rectángulo del ancho y alto que se indiquen como parámetros. Incluye un Main para probarla.
5.3.3: Crea una función "DibujarRectanguloHueco" que dibuje en pantalla un rectángulo hueco del ancho y alto que se indiquen como parámetros, formado por una letra que también se indique como parámetro. Completa el programa con un Main que pida esos datos al usuario y dibuje el rectángulo.
5.4.1: Crea una función "Cubo" que calcule el cubo de un número real (float) que se indique como parámetro. El resultado deberá ser otro número real. Prueba esta función para calcular el cubo de 3.2 y el de 5.
5.4.2: Crea una función "Menor" que calcule el menor de dos números enteros que recibirá como parámetros. El resultado será otro número entero.
5.4.3: Crea una función llamada "Signo", que reciba un número real, y devuelva un número entero con el valor: -1 si el número es negativo, 1 si es positivo o 0 si es cero.
5.4.4: Crea una función "Inicial", que devuelva la primera letra de una cadena de texto. Prueba esta función para calcular la primera letra de la frase "Hola".
5.4.5: Crea una función "UltimaLetra", que devuelva la última letra de una cadena de texto. Prueba esta función para calcular la última letra de la frase "Hola".
5.4.6: Crea una función "MostrarPerimSuperfCuadrado" que reciba un número entero y calcule y muestre en pantalla el valor del perímetro y de la superficie de un cuadrado que tenga como lado el número que se ha indicado como parámetro.
5.5.1: Crea una función "PedirEntero", que reciba como parámetros el texto que se debe mostrar en pantalla, el valor mínimo aceptable y el valor máximo aceptable. Deberá pedir al usuario que introduzca el valor tantas veces como sea necesario, volvérselo a pedir en caso de error, y devolver un valor correcto. Pruébalo con un programa que pida al usuario un año entre 1800 y 2100.
5.5.2: Crea una función "EscribirTablaMultiplicar", que reciba como parámetro un número entero, y escriba la tabla de multiplicar de ese número (por ejemplo, para el 3 deberá llegar desde "3x0=0" hasta "3x10=30").
5.5.3: Crea una función "EsPrimo", que reciba un número y devuelva el valor booleano "true" si es un número primo o "false" en caso contrario.
5.5.4: Crea una función "ContarLetra", que reciba una cadena y una letra, y devuelva la cantidad de veces que dicha letra aparece en la cadena. Por ejemplo, si la cadena es "Barcelona" y la letra es "a", debería devolver 2 (porque la "a" aparece 2 veces).
5.5.5: Crea una función "SumaCifras" que reciba un numero cualquiera y que devuelva como resultado la suma de sus dígitos. Por ejemplo, si el número fuera 123 la suma sería 6.
5.5.6: Crea una función "Triángulo" que reciba una letra y un número, y escriba un "triángulo" formado por esa letra, que tenga como anchura inicial la que se ha indicado. Por ejemplo, si la letra es * y la anchura es 4, debería escribir **** *** ** *
5.7.1: Crea una función "Intercambiar", que intercambie el valor de los dos números enteros que se le indiquen como parámetro. Crea también un programa que la pruebe.
5.7.2: Crea una función "Iniciales", que reciba una cadena como "Nacho Cabanes" y devuelva las letras N y C (primera letra, y letra situada tras el primer espacio), usando parámetros por referencia. Crea un "Main" que te permita comprobar que funciona correctamente.
5.9.1.1: Crea un programa que imite el lanzamiento de un dado, generando un número al azar entre 1 y 6.
5.9.1.2: Crea un programa que genere un número al azar entre 1 y 100. El usuario tendrá 6 oportunidades para acertarlo.
5.9.1.3: Mejora el programa del ahorcado (4.4.9.3), para que la palabra a adivinar no sea tecleada por un segundo usuario, sino que se escoja al azar de un "array" de palabras prefijadas (por ejemplo, nombres de ciudades).
5.9.1.4: Crea un programa que genere un array relleno con 100 números reales al azar entre -1000 y 1000. Luego deberá calcular y mostrar su media.
5.9.1.5: Crea un programa que "dibuje" asteriscos en 100 posiciones al azar de la pantalla. Para ayudarte para escribir en cualquier coordenada, puedes usar un array de dos dimensiones (con tamaños 24 para el alto y 79 para el ancho), que primero rellenes y luego dibujes en pantalla.
5.9.2.1: Crea un programa que halle (y muestre) la raíz cuadrada del número que introduzca el usuario. Se repetirá hasta que introduzca 0.
5.9.2.2: Crea un programa que halle cualquier raíz (de cualquier orden) de un número. El usuario deberá indicar el número (por ejemplo, 2) y el índice de la raíz (por ejemplo, 3 para la raíz cúbica). Pista: hallar la raíz cúbica de 2 es lo mismo que elevar 2 a 1/3.
5.9.2.3: Haz un programa que resuelva ecuaciones de segundo grado, del tipo ax2 + bx + c = 0. El usuario deberá introducir los valores de a, b y c. Se deberá crear una función "CalcularRaicesSegundoGrado", que recibirá como parámetros los coeficientes a, b y c (por valor), así como las soluciones x1 y x2 (por referencia). Deberá devolver los valores de las dos soluciones x1 y x2. Si alguna solución no existe, se devolverá como valor 100.000 para esa solución. Pista: la solución se calcula con x = -b ± raíz (b2 – 4•a•c) / (2•a)
5.9.2.4: Haz un programa que pida al usuario 5 datos numéricos enteros, los guarde en un array, pida un nuevo dato y muestre el valor del array que se encuentra más cerca de ese dato, siendo mayor que él, o el texto "Ninguno es mayor" si ninguno lo es.
5.9.2.5: Crea un programa que pida al usuario 5 datos numéricos reales, los guarde en un array, pida un nuevo dato y muestre el valor del array que se encuentra más cerca de ese dato en valor absoluto (es decir, el más próximo, sea mayor que él o menor que él).
5.9.2.6: Crea una función "Distancia", que calcule la distancia entre dos puntos (x1,y1) y (x2,y2), usando la expresión d = raíz [ (x1-x2)2 + (y1-y2)2 ].
5.9.2.7: Crea un programa que pida al usuario un ángulo (en grados) y muestre su seno, coseno y tangente. Recuerda que las funciones trigonométricas esperan que el ángulo se indique en radianes, no en grados. La equivalencia es que 360 grados son 2*PI radianes.
5.9.2.8: Crea un programa que muestre los valores de la función y = 10 * seno(x*5), para valores de x entre 0 y 72 grados.
5.9.2.9: Crea un programa que "dibuje" la gráfica de la función y = 10 * seno(x*5), para valores de x entre 0 y 72 grados. Para ayudarte para escribir en cualquier coordenada, puedes usar un array de dos dimensiones, que primero rellenes y luego dibujes en pantalla (mira el ejercicio 5.9.1.5).
5.9.2.10: Crea un programa que "dibuje" un círculo dentro de un array de dos dimensiones, usando las ecuaciones x = xCentro + radio * coseno(ángulo), y = yCentro + radio * seno(ángulo). Si tu array es de 24x79, las coordenadas del centro serían (12,40). Recuerda que el ángulo se debe indicar en radianes (mira el ejercicio 5.9.1.5 y el 5.9.2.9).
5.10.1: Crea una función que calcule el valor de elevar un número entero a otro número entero (por ejemplo, 5 elevado a 3 = 53 = 5 • 5 • 5 = 125). Esta función se debe crear de forma recursiva. Piensa cuál será el caso base (qué potencia se puede calcular de forma trivial) y cómo pasar del caso "n-1" al caso "n" (por ejemplo, si sabes el valor de 54, cómo hallarías el de 55 a partir de él).
5.10.2: Como alternativa, crea una función que calcule el valor de elevar un número entero a otro número entero de forma NO recursiva (lo que llamaremos "de forma iterativa"), usando la orden "for".
5.10.3: Crea un programa que emplee recursividad para calcular un número de la serie Fibonacci (en la que los dos primeros elementos valen 1, y para los restantes, cada elemento es la suma de los dos anteriores).
5.10.4: Crea un programa que emplee recursividad para calcular la suma de los elementos de un vector de números enteros, desde su posición inicial a la final, usando una función recursiva que tendrá la apariencia: SumaVector(v, desde, hasta). Nuevamente, piensa cuál será el caso base (cuántos elementos podrías sumar para que dicha suma sea trivial) y cómo pasar del caso "n-1" al caso "n" (por ejemplo, si conoces la suma de los 6 primeros elementos y el valor del séptimo elemento, cómo podrías emplear esta información para conocer la suma de los 7 primeros).
5.10.5: Crea un programa que emplee recursividad para calcular el mayor de los elementos de un vector. El planteamiento será muy similar al del ejercicio anterior.
5.10.6: Crea un programa que emplee recursividad para dar la vuelta a una cadena de caracteres (por ejemplo, a partir de "Hola" devolvería "aloH"). La función recursiva se llamará "Invertir(cadena)". Como siempre, analiza cuál será el caso base (qué longitud debería tener una cadena para que sea trivial darle la vuelta) y cómo pasar del caso "n-1" al caso "n" (por ejemplo, si ya has invertido las 5 primeras letras, que ocurriría con la de la sexta posición).
5.10.7: Crea, tanto de forma recursiva como de forma iterativa, una función diga si una cadena de caracteres es simétrica (un palíndromo). Por ejemplo, "DABALEARROZALAZORRAELABAD" es un palíndromo.
5.10.8: Crear un programa que encuentre el máximo común divisor de dos números usando el algoritmo de Euclides: Dados dos números enteros positivos m y n, tal que m > n, para encontrar su máximo común divisor, es decir, el mayor entero positivo que divide a ambos: - Dividir m por n para obtener el resto r (0 ≤ r < n) ; - Si r = 0, el MCD es n.; - Si no, el máximo común divisor es MCD(n,r).
5.10.9: Crea dos funciones que sirvan para saber si un cierto texto es subcadena de una cadena. No puedes usar "Contains" ni "IndexOf", sino que debes analizar letra a letra. Una función debe ser iterativa y la otra debe ser recursiva.
5.10.10: Crea una función que reciba una cadena de texto, y una subcadena, y devuelva cuántas veces aparece la subcadena en la cadena, como subsecuencia formada a partir de sus letras en orden. Por ejemplo, si recibes la palabra "Hhoola" y la subcadena "hola", la respuesta sería 4, porque se podría tomar la primera H con la primera O (y con la L y con la A), la primera H con la segunda O, la segunda H con la primera O, o bien la segunda H con la segunda O. Si recibes "hobla", la respuesta sería 1. Si recibes "ohla", la respuesta sería 0, porque tras la H no hay ninguna O que permita completar la secuencia en orden.
5.11.1: Crea un programa llamado "suma", que calcule (y muestre) la suma de dos números que se le indiquen como parámetros en línea de comandos. Por ejemplo, si se teclea "suma 2 3" deberá responder "5", si se teclea "suma 2" responderá "2" y si se teclea únicamente "suma" deberá responder "no hay suficientes datos" y devolver un código de error 1.
5.11.2: Crea una calculadora básica, llamada "calcula", que deberá sumar, restar, multiplicar o dividir los dos números que se le indiquen como parámetros. Ejemplos de su uso sería "calcula 2 + 3" o "calcula 5 * 60".
5.11.3: Crea una variante del ejercicio 5.11.2, en la que Main devuelva el código 1 si la operación indicada no es válida o 0 cuando sí sea una operación aceptable.
5.11.4: Crea una variante del ejercicio 5.11.3, en la que Main devuelva también el código 2 si alguno de los dos números con los que se quiere operar no tiene un valor numérico válido.
6.2.1: Crea una clase llamada Persona, en el fichero "persona.cs". Esta clase deberá tener un atributo "nombre", de tipo string. También deberá tener un método "SetNombre", de tipo void y con un parámetro string, que permita cambiar el valor del nombre. Finalmente, también tendrá un método "Saludar", que escribirá en pantalla "Hola, soy " seguido de su nombre. Crea también una clase llamada PruebaPersona. Esta clase deberá contener sólo la función Main, que creará dos objetos de tipo Persona, les asignará un nombre a cada uno y les pedirá que saluden.
6.2.2: Tras leer la descripción de Space Invaders que vimos en el apartado anterior, crea una clase Juego,que sólo contenga un método Lanzar, void, sin parámetros, que escriba en pantalla "Bienvenido a Console Invaders. Pulse Intro para salir" y se parará hasta que el usuario pulse Intro. Prepara también un Main (en la misma clase), que cree un objeto de la clase juego y lo lance.
6.2.3: Para guardar información sobre libros, vamos a comenzar por crear una clase "Libro", que contendrá atributos "autor", "titulo", "ubicacion" (todos ellos strings) y métodos Get y Set adecuados para leer su valor y cambiarlo. Prepara también un Main (en la misma clase), que cree un objeto de la clase Libro, dé valores a sus tres atributos y luego los muestre.
6.2.4: Crea una clase "Coche", con atributos "marca" (texto), "modelo" (texto), "cilindrada" (número entero), potencia (número real). No hace falta que crees un Main de prueba.
6.3.1: Crea un proyecto con las clases Puerta y Ejemplo_06_03a. Comprueba que todo funciona correctamente.
6.3.2: Modifica el fuente del ejercicio 6.2.1 (clase Persona), para dividirlo en dos ficheros: Crea una clase llamada Persona, en el fichero "persona.cs". Esta clase deberá tener un atributo "nombre", de tipo string. También deberá tener un método "SetNombre", de tipo void y con un parámetro string, que permita cambiar el valor del nombre. Finalmente, también tendrá un método "Saludar", que escribirá en pantalla "Hola, soy " seguido de su nombre. Crea también una clase llamada PruebaPersona, en el fichero "pruebaPersona.cs". Esta clase deberá contener sólo la función Main, que creará dos objetos de tipo Persona, les asignará un nombre y les pedirá que saluden.
6.3.3: Crea un proyecto a partir de la clase Libro (ejercicio 6.2.3). El "Main" pasará a una segunda clase llamada "PruebaDeLibro" y desaparecerá de la clase Libro.
6.3.4: Amplía el esqueleto del ConsoleInvaders (ejercicio 6.2.2): crea un proyecto para Visual Studio o SharpDevelop. Además de la clase "Juego", crea una clase "Bienvenida" y una clase "Partida". El método "Lanzar" de la clase Juego, ya no escribirá nada en pantalla, sino que creará un objeto de la clase "Bienvenida" y lo lanzará y luego un objeto de la clase "Partida" y lo lanzará. El método Lanzar de la clase Bienvenida escribirá en pantalla "Bienvenido a Console Invaders. Pulse Intro para jugar". El método Lanzar de la clase Partida escribirá en pantalla "Ésta sería la pantalla de juego. Pulse Intro para salir" y se parará hasta que el usuario pulse Intro.
6.3.5: Amplía el esqueleto del ConsoleInvaders (ejercicio 6.3.4): El método Lanzar de la clase Bienvenida escribirá en pantalla "Bienvenido a Console Invaders. Pulse Intro para jugar o ESC para salir". Puedes comprobar si se pulsa ESC con "ConsoleKeyInfo tecla = Console.ReadKey(); if (tecla.Key == ConsoleKey.Escape) salir = true;". El código de la tecla Intro es " ConsoleKey.Enter". También puedes usar "Console.Clear();" si quieres borrar la pantalla. Añade un método "GetSalir" a la clase Bienvenida, que devuelva "true" si el usuario ha escogido Salir o "false" si ha elegido Jugar. El método Lanzar de la clase Juego repetirá la secuencia Bienvenida-Partida hasta que el usuario escoja Salir.
6.3.6: Amplía el esqueleto del ConsoleInvaders (ejercicio 6.3.5): Crea una clase Nave, con atributos "x" e "y" (números enteros, "x" de 0 a 1023 e "y" entre 0 y 767, pensando en una pantalla de 1024x768), e imagen (un string formado por dos caracteres, como "/\"). También tendrá un método MoverA(nuevaX, nuevaY) que lo mueva a una nueva posición, y un método Dibujar, que muestre esa imagen en pantalla (como esta versión es para consola, la X tendrá que rebajarse para que tenga un valor entre 0 y 79, y la Y entre 0 y 24). Puedes usar Console.SetCursorPosition(x,y) para situarte en unas coordenadas de pantalla. Crea también clase Enemigo, con los mismos atributos. Su imagen podría ser "][". El método Lanzar de la clase Partida creará una nave en las coordenadas (500, 600) y la dibujará, creará un enemigo en las coordenadas (100, 80) y lo dibujará, y finalmente esperará a que el usuario pulse Intro para terminar la falsa sesión de juego.
6.3.7: Crea un proyecto a partir de la clase Coche (ejercicio 6.2.4): además de la clase Coche, existirá una clase PruebaDeCoche, que contendrá la función "Main", que creará un objeto de tipo coche, pedirá al usuario su marca, modelo, cilindrada y potencia, y luego mostrará en pantalla el valor de esos datos.
6.4.1: Crea un proyecto con las clases Puerta, Portón y Ejemplo_06_04a. Prueba que todo funciona correctamente.
6.4.2: Crea una variante ampliada del ejercicio 6.3.2. En ella, la clase Persona no cambia. Se creará una nueva clase PersonaInglesa, en el fichero "personaInglesa.cs". Esta clase deberá heredar las características de la clase "Persona", y añadir un método "TomarTe", de tipo void, que escribirá en pantalla "Estoy tomando té". Crear también una clase llamada PruebaPersona2, en el fichero "pruebaPersona2.cs". Esta clase deberá contener sólo la función Main, que creará dos objetos de tipo Persona y uno de tipo PersonaInglesa, les asignará un nombre, les pedirá que saluden y pedirá a la persona inglesa que tome té.
6.4.3: Amplía el proyecto del ejercicio 6.3.3 (Libro): crea una clase "Documento", de la que Libro heredará todos sus atributos y métodos. Ahora la clase Libro contendrá sólo un atributo "paginas", número entero, con sus correspondientes Get y Set.
6.4.4: Amplía el esqueleto del ConsoleInvaders (ejercicio 6.3.6): Crea una clase "Sprite", de la que heredarán "Nave" y "Enemigo". La nueva clase contendrá todos los atributos y métodos que son comunes a las antiguas (todos los existentes, por ahora).
6.4.5: Amplía el proyecto de la clase Coche (ejercicio 6.3.7): Crea una clase "Vehiculo", de la que heredarán "Coche" y una nueva clase "Moto". La clase Vehiculo contendrá todos los atributos y métodos que antes estaban en Coche, y tanto Coche como Moto heredarán de ella.
6.5.1: Crea un proyecto a partir del ejemplo 06.05a, en el que cada clase esté en un fichero separado. Como podrás comprobar, ahora necesitarás un "using System" en cada fuente.
6.5.2: Amplía las clases del ejercicio 6.4.2, creando un nuevo proyecto con las siguientes características: La clase Persona no cambia; la clase PersonaInglesa se modificará para que redefina el método "Saludar", para que escriba en pantalla "Hi, I am " seguido de su nombre; se creará una nueva clase PersonaItaliana, en el fichero "personaItaliana.cs", que deberá heredar las características de la clase "Persona", pero redefinir el método "Saludar", para que escriba en pantalla "Ciao"; crea también una clase llamada PruebaPersona3, en el fichero " pruebaPersona3.cs", que deberá contener sólo la función Main y creará un objeto de tipo Persona, dos de tipo PersonaInglesa, uno de tipo PersonaItaliana, les asignará un nombre, les pedirá que saluden y pedirá a la persona inglesa que tome té.
6.5.3: Retoca el proyecto del ejercicio 6.4.3 (Libro): los atributos de la clase Documento y de la clase Libro serán "protegidos".
6.5.4: Amplía el esqueleto del ConsoleInvaders (ejercicio 6.4.4): Amplía la clase Nave con un método "MoverDerecha", que aumente su X en 10 unidades, y un "MoverIzquierda", que disminuya su X en 10 unidades. Necesitarás hacer que esos atributos sean "protected". El método Lanzar de la clase Partida no esperará hasta el usuario pulse Intro sin hacer nada, sino que ahora usará un do-while que compruebe si pulsa ESC (para salir), o flecha izquierda o flecha derecha (para mover la nave: sus códigos son ConsoleKey.LeftArrow y ConsoleKey.RightArrow). Si se pulsan las flechas, la nave se moverá a un lado o a otro (con los métodos que acabas de crear). Al principio de cada pasada del do-while se borrará la pantalla ("Console.Clear();").
6.5.5: Mejora el proyecto de la clase Coche (ejercicio 6.4.5): todos los atributos serán "protegidos" y los métodos serán "públicos".
6.6.1: Ampliar las clases del ejercicio 6.5.2, para que todas ellas contengan constructores. Los constructores de casi todas las clases estarán vacíos, excepto del de PersonaInglesa, que prefijará su nombre a "John". Crea también un constructor alternativo para esta clase que permita escoger cualquier otro nombre.
6.6.2: Amplía el proyecto del ejercicio 6.5.3 (Libro): la clase Libro tendrá un constructor que permita dar valores al autor, el título y la ubicación.
6.6.3: Amplía el esqueleto del ConsoleInvaders (ejercicio 6.5.4): La clase Enemigo tendrá un constructor, sin parámetros, que prefijará su posición inicial. El constructor de la clase Nave recibirá como parámetros las coordenadas X e Y iniciales, para que se puedan cambiar desde el cuerpo del programa. Elimina las variables xNave e yNave de la clase Partida, que ya no serán necesarias.
6.6.4: Mejora el proyecto de la clase Coche (ejercicio 6.5.5): añade un atributo "cantidadDeRuedas" a la clase Vehiculo, junto con sus Get y Set. El constructor de la clase Coche le dará el valor 4 y el constructor de la clase Moto le dará el valor 2.
6.7.1: A partir de las clases del ejercicio 6.6.1, añade a la clase "Persona" un nuevo método Saludar, que reciba un parámetro, que será el texto que debe decir esa persona cuando salude.
6.7.2: Amplía el proyecto del ejercicio 6.6.2 (Libro): la clase Libro tendrá un segundo constructor que permita dar valores al autor y el título, pero no a la ubicación, que tomará el valor por defecto "No detallada".
6.7.3: Amplía el esqueleto del ConsoleInvaders (6.6.3): La clase Nave tendrá un segundo constructor, sin parámetros, que prefijará su posición inicial a (500,600). La clase Enemigo tendrá un segundo constructor, con parámetros X e Y, para poder colocar un enemigo en cualquier punto desde Main.
6.7.4: Crea dos nuevos métodos en la clase Vehiculo (ejercicio 6.6.4): uno llamado Circular, que fijará su "velocidad" (un nuevo atributo) a 50, y otro Circular(v), que fijará su velocidad al valor que se indique como parámetro.
6.8.1: Crea un único fuente que contenga las siguientes clases:
Una clase Trabajador, cuyo constructor escriba en pantalla "Soy un trabajador".
Una clase Programador, que derive de Trabajador, cuyo constructor escriba en pantalla "Soy programador".
Una clase Analista, que derive de Trabajador, cuyo constructor escriba en pantalla "Soy analista".
Una clase Ingeniero, que derive de Trabajador, cuyo constructor escriba en pantalla "Soy ingeniero".
Una clase IngenieroInformatico, que derive de Ingeniero, cuyo constructor escriba en pantalla "Soy ingeniero informático".
Una clase "PruebaDeTrabajadores", que cree un objeto perteneciente a cada una de esas clases.
6.8.2: Crea una variante del proyecto Libro (ejercicio 6.7.2) en la que el constructor de Documento escriba en pantalla "Creando documento" y el constructor de Libro escriba en pantalla "Creando libro". Comprueba su funcionamiento.
6.8.3: Crea una versión alternativa del esqueleto del ConsoleInvaders (6.7.3) en la que el constructor de Sprite escriba en pantalla "Creando sprite" y los constructores de Nave escriba en pantalla "Creando nave en posición prefijada" o "Creando nave en posición indicada por el usuario", según el caso. Comprueba su funcionamiento.
6.8.4: Crea una versión alternativa de las clases Vehiculo, Coche, Moto (6.7.4), que te avise del momento en que se entra a cada constructor. Crea un programa de prueba que defina un coche y una moto, y comprueba su funcionamiento.
7.1.1: Amplía el ejemplo 07_01a con un función "static" llamada "EscribirCentrado", que escriba centrado horizontalmente el texto que se le indique como parámetro.
7.1.2: Amplía el ejemplo 07_01b con un función llamada "EscribirCentrado", que escriba centrado horizontalmente el texto que se le indique como parámetro. Al contrario que en el ejercicio 7.1.1, esta versión no será "static".
7.1.3: Crea una nueva versión del ejercicio 5.2.3 (base de datos de ficheros, descompuesta en funciones), en la que los métodos y variables no sean "static".
7.2.1: Crea una versión ampliada del ejercicio 6.8.1 (clase Trabajador y relacionadas), en la que no se cree un único objeto de cada clase, sino un array de tres objetos.
7.2.2: Amplía el proyecto Libro (ejercicio 6.7.2), de modo que permita guardar hasta 1.000 libros. Main mostrará un menú que permita añadir un nuevo libro o ver los datos de los ya existentes.
7.2.3: Amplía el esqueleto del ConsoleInvaders (6.7.3), para que haya 10 enemigos en una misma fila (todos compartirán una misma coordenada Y, pero tendrán distinta coordenada X). Necesitarás un nuevo constructor en la clase Enemigo, que reciba los parámetros X e Y.
7.2.4: A partir del ejemplo 07.02b y del ejercicio 6.8.1 (clase Trabajador y relacionadas), crea un array de trabajadores en el que no sean todos de la misma clase.
7.2.5: Amplía el proyecto Libro (ejercicio 7.2.2), de modo que permita guardar 1000 documentos de cualquier tipo. A la hora de añadir un documento, se preguntará al usuario si desea guardar un documento genérico o un libro, para usar el constructor adecuado.
7.2.6: Amplía el esqueleto del ConsoleInvaders (7.2.3), para que haya tres tipos de enemigos, y un array que contenga 3x10 enemigos (3 filas, cada una con 10 enemigos de un mismo tipo, pero distinto del tipo de los elementos de las otras filas). Cada tipo de enemigos será una subclase de Enemigo, que se distinguirá por usar una "imagen" diferente. Puedes usar la "imagen" que quieras (siempre que sea un string de letras, como "}{" o "XX"). Si estas imágenes no se muestran correctamente en pantalla al lanzar una partida, no te preocupes, lo solucionaremos en el siguiente apartado.
7.3.1: Crea una versión ampliada del ejercicio 6.8.1 (clase Trabajador y relacionadas), en la que no se cree un único objeto de cada clase, sino un array de tres objetos.
7.3.2: Amplía el proyecto Libro (ejercicio 6.7.2), de modo que permita guardar hasta 1.000 libros. Main mostrará un menú que permita añadir un nuevo libro o ver los datos de los ya existentes.
7.3.3: Amplía el esqueleto del ConsoleInvaders (6.7.3), para que haya 10 enemigos en una misma fila (todos compartirán una misma coordenada Y, pero tendrán distinta coordenada X). Necesitarás un nuevo constructor en la clase Enemigo, que reciba los parámetros X e Y.
7.3.4: A partir del ejemplo 07.02b y del ejercicio 6.8.1 (clase Trabajador y relacionadas), crea un array de trabajadores en el que no sean todos de la misma clase.
7.3.5: Amplía el esqueleto de ConsoleInvaders (7.2.6) para que muestre las imágenes correctas de los enemigos, usando "virtual" y "override". Además, cada tipo de enemigos debe ser de un color distinto. (Nota: para cambiar colores puedes usar Console.ForegroundColor = ConsoleColor.Green;). La nave que maneja el usuario debe ser blanca.
7.4.1: Crea una versión ampliada del ejercicio 7.3.3, en la que el método "Hablar" de todas las clases hijas se apoye en el de la clase "Trabajador".
7.4.2: Crea una versión ampliada del ejercicio 7.4.1, en la que el constructor de todas las clases hijas se apoye en el de la clase "Trabajador".
7.4.3: Refina el proyecto Libro (ejercicio 7.3.4), para que el método ToString de la clase Libro se apoye en el de la clase Documento, y también lo haga el de la clase Articulo.
7.4.4: Amplía el esqueleto de ConsoleInvaders (7.3.5) para que en Enemigo haya un único constructor que reciba las coordenadas X e iniciales. Los constructores de los tres tipos de enemigos deben basarse en éste.
7.5.1: Crea una versión ampliada del ejercicio 7.4.2, en la que el constructor sin parámetros de la clase "Trabajador" se apoye en otro constructor que reciba como parámetro el nombre de esa persona. La versión sin parámetros asignará el valor "Nombre no detallado" al nombre de esa persona.
7.5.2: Crea una clase Puerta con un ancho, un alto y un método "MostrarEstado" que muestre su ancho y su alto. Crea una clase Casa, que contenga 3 puertas y otro método "MostrarEstado" que escriba "Casa" y luego muestre el estado de sus tres puertas.
7.5.3: Crea una clase Casa, con una superficie (por ejemplo, 90 m2) y un método "MostrarEstado" que escriba su superficie. Cada casa debe contener 3 puertas. Las puertas tendrán un ancho, un alto y un método "MostrarEstado" que muestre su ancho y su alto y la superficie de la casa en la que se encuentran. Crea un programa de prueba que cree una casa y muestre sus datos y los de sus tres puertas.
7.5.4: Amplía el esqueleto de ConsoleInvaders (7.4.4), de modo que el constructor sin parámetros de la clase Nave se apoye en el constructor con parámetros de la misma clase.
7.6.1: Desarrolla una clase "Matriz", que represente a una matriz de 3x3, con métodos para indicar el valor que hay en una posición, leer el valor de una posición, escribir la matriz en pantalla y sumar dos matrices. (Nota: en C# puedes sobrecargar el operador "+", pero no el operador "[]", de modo que tendrás que crear métodos "get" y "set" para leer los valores de posiciones de la matriz y para cambiar su valor).
7.6.2: Si has estudiado los "números complejos", crea una clase "Complejo", que represente a un número complejo (formado por una parte "real" y una parte "imaginaria"). Incluye un constructor que reciba ambos datos como parámetros. Crea también métodos "get" y "set" para leer y modificar los valores de dichos datos, así como métodos que permitan saber los valores de su módulo y su argumento. Crea un método que permita sumar un complejo a otro, y redefine el operador "+" como forma alternativa de realizar esa operación.
7.6.3: Crea una clase "Fraccion", que represente a una fracción, formada por un numerador y un denominador. Crea un constructor que reciba ambos datos como parámetros y otro constructor que reciba sólo el numerador. Crea un método Escribir, que escriba la fracción en la forma "3 / 2". Redefine los operadores "+", "-", "*" y "/" para que permitan realizar las operaciones habituales con fracciones.
7.6.4: Crea una clase "Vector3", que represente a un vector en el espacio de 3 dimensiones. Redefine los operadores "+" y "-" para sumar y restar dos vectores, "*" para hallar el producto escalar de dos vectores y "%" para calcular su producto vectorial.
7.7.1: Crea un proyecto "Space Invaders" con todas las clases que vimos al principio del tema 6. El proyecto no será jugable, pero deberá compilar correctamente.
7.7.2: Crea un proyecto "PersonajeMovil", que será un esqueleto sobre el que se podría ampliar para crear un juego de plataformas. Existirá una pantalla de bienvenida, una pantalla de créditos y una partida, en la que el usuario podrá mover a un personaje (que puede ser representado por una letra X). Las teclas de movimiento quedan a tu criterio, pero podrían ser "wasd" o las flechas del cursor. Si quieres que el movimiento sea más suave, puedes investigar sobre Console.Readkey (que posiblemente habrás usado ya en el proyecto ConsoleInvaders) como alternativa a Console.ReadLine.
7.7.3: Crea un proyecto "Laberinto", a partir del proyecto "PersonajeMovil", añadiendo tres enemigos que se muevan de lado a lado de forma autónoma y un laberinto de fondo, cuyas paredes no se puedan "pisar" (la clase Laberinto puede tener métodos que informen sobre si el jugador podría moverse a ciertas coordenadas X e Y). Si el personaje toca a un enemigo, acabará la partida y se regresará a la pantalla de bienvenida.
7.7.4: Crea un proyecto "Laberintos", a partir del proyecto "Laberinto", añadiendo premios que recoger, tres vidas para nuestro personaje y varios laberintos distintos que recorrer.
7.7.5: Crea un proyecto "SistemaDomotico", que simule un sistema domótico para automatizar ciertas funciones en una casa: apertura y cierre de ventanas y puertas, encendido de calefacción, etc. Además de esos elementos físicos de la casa, también existirá un panel de control, desde el que el usuario podría controlar el resto de elementos, así como programar el comportamiento del sistema (por ejemplo, subir una persiana inmediatamente o hacer que la calefacción se encienda todos los días desde las 19h hasta las 23h, a una cierta temperatura).
7.7.6: Completa el proyecto Libro (ejercicio 7.4.3), para que las clases de datos tengan un método "Contiene", que reciba un texto y devuelva el valor booleano "true" cuando ese texto esté contenido en el título o en el autor (y en la procedencia, para los artículos). El Main deberá permitir al usuario realizar búsquedas, aprovechando esta nueva funcionalidad.
7.7.7: Añade al proyecto Libro cualquier otra funcionalidad que te parezca interesante, como la de modificar datos, borrarlos u ordenarlos.
7.7.8: Crea en el proyecto Libro una clase ListaDeDocumentos, que oculte a Main los detalles de que internamente se trata de un array: deberá permitir opciones como añadir un documento, obtener los datos de uno de ellos, buscar entre la lista de todos ellos, etc. Los criterios de diseño quedan a tu criterio. Por ejemplo, puedes hacer que la búsqueda devuelve un array con los números de ficha encontrados, o un array con el contenido de esas fichas, o el contenido la siguiente ficha que cumpla con esos criterios.
7.7.9: Amplía el esqueleto de ConsoleInvaders (7.5.4), con una clase "BloqueDeEnemigos", que será la que contenga el array de enemigos, de modo que se simplifique la lógica de la clase Partida. Esta clase tendrá un método Dibujar, que mostrará todo el array en pantalla, y un método Mover, que moverá todo el bloque hacia la derecha y la izquierda de forma alternativa (deberás comprobar la posición inicial del primer enemigo y la posición final del último enemigo). En cada pasada por el bucle de juego deberás llamar a Mover.
7.7.10: Crea una clase Disparo en ConsoleInvaders. Cuando el usuario pulse cierta tecla (Espacio, por ejemplo), aparecerá un disparo encima de la nave, y se moverá hacia arriba hasta que desaparezca por la parte superior de la pantalla. Existirá un único disparo, y no se podrá volver a disparar si está activo (en pantalla). Inicialmente estará desactivado, y lo volverá a estar cuando llegue al margen de la pantalla.
7.7.11: En ConsoleInvaders, crea un método "ColisionaCon" en la clase Sprite, que reciba otro Sprite como parámetro y devuelva el valor booleano "true" si ambos sprites están "chocando" o "false" en caso contrario. Tendrás que pensar qué relación habrá entre las coordenadas X e Y de ambos sprites para que "choquen".
7.7.12: En ConsoleInvaders, crea una clase Ovni, con un nuevo tipo de Enemigo que no estará siempre activo. Su método Mover hará que se mueva hacia la derecha si ya está activo o, en caso contrario, que genere un número al azar para decidir si debe activarse.
7.7.13: En ConsoleInvaders, comprueba colisiones entre el disparo y el Ovni. Si hay colisión, desaparecerán ambos y el jugador obtendrá 50 puntos.
7.7.14: En ConsoleInvaders, comprueba colisiones entre el disparo y el bloque de enemigos. Si el disparo toca algún enemigo, ambos desaparecerán y el jugador obtendrá 10 puntos.
7.7.15: En ConsoleInvaders, añade una clase "Marcador", que muestre la puntuación y la cantidad de vidas restantes (que por ahora, siempre será 3).
7.7.16: En ConsoleInvaders, añade la posibilidad de que algunos enemigos al azar puedan disparar (los disparos de los enemigos "va hacia abajo"; piensa si crear una nueva clase o ampliar las funcionalidades de la clase Disparo que ya tienes). Ajusta la frecuencia de disparos, de modo que el juego continúe siendo jugable. Si uno de esos disparos impacta con la nave, se perderá una vida y el disparo desaparecerá. Si se pierden las 3 vidas, acaba la partida y se volverá a la pantalla de presentación.
7.7.17: En ConsoleInvaders, crea la estructura que sea necesaria para almacenar las "mejores puntuaciones", que se actualizarán al terminar cada partida y se mostrarán en la pantalla de bienvenida.
7.7.18: En ConsoleInvaders, añade las "torres defensivas", que protegen al jugador y que se van rompiendo poco a poco cada vez que un disparo impacta con ellas.
8.1.1: Crea un programa que vaya leyendo las frases que el usuario teclea y las guarde en un fichero de texto llamado "registroDeUsuario.txt". Terminará cuando la frase introducida sea "fin" (esa frase no deberá guardarse en el fichero).
8.1.2: Crea una versión de la base de datos de ficheros (ejercicio 5.2.3), de modo que todos los datos se vuelquen a un fichero de texto al terminar la ejecución del programa.
8.1.3: Amplia el proyecto Libro (ejercicio 7.7.8), de modo que todos los datos se vuelquen a un fichero de texto al terminar la ejecución del programa.
8.2.1: Crea un programa que lea las tres primeras líneas del fichero creado en el ejercicio 8.1.1 y las muestre en pantalla.
8.2.2: Crea una versión alternativa del ejercicio 8.2.1, usando el constructor de StreamReader.
8.2.3: Crea una versión alternativa del ejercicio 8.2.2, empleando la sintaxis alternativa de "using".
8.3.1: Crea una variante del ejemplo 08_03a, empleando un constructor en vez de "File.OpenText".
8.3.2: Crea una variante del ejemplo 08_03a, empleando "using" en vez de "Close".
8.3.3: Un programa que pregunte un nombre de fichero y muestre en pantalla el contenido de ese fichero, haciendo una pausa después de cada 25 líneas, para que dé tiempo a leerlo. Cuando el usuario pulse la tecla Intro, se mostrarán las siguientes 25 líneas, y así hasta que termine el fichero.
8.3.4: Amplía la base de datos de ficheros (ejercicio 8.1.2), de modo que los datos se lean desde fichero (si existe) en el momento de lanzar el programa (puedes usar try-catch para que el programa no falle en el momento inicial, en el que quizá todavía no existan datos en fichero).
8.3.5: Amplia el proyecto Libro (ejercicio 8.1.3), de modo que los datos se lean desde fichero (si existe) en el momento de poner el programa en marcha.
8.3.6: Crea un programa que pida al usuario el nombre de un fichero de texto y una frase a buscar, y que muestre en pantalla todas las líneas de ese fichero que contengan esa frase. Cada frase se debe preceder del número de línea (la primera línea del fichero será la 1, la segunda será la 2, y así sucesivamente).
8.4.1: Un programa que pida al usuario que teclee frases, y las almacene en el fichero "log.txt", que puede existir anteriormente (y que no deberá borrarse, sino añadir al final de su contenido). Cada sesión acabará cuando el usuario pulse Intro sin teclear nada.
8.5.1: Crea un programa que pida al usuario pares de números enteros y escriba su suma (con el formato "20 + 3 = 23") en pantalla y en un fichero llamado "sumas.txt", que se encontrará en un subdirectorio llamado "resultados". Cada vez que se ejecute el programa, deberá añadir los nuevos resultados a continuación de los resultados de las ejecuciones anteriores.
8.6.1: Mejora el ejercicio 8.3.4 para que compruebe antes si el fichero existe, y muestre un mensaje de aviso en caso de que no sea así.
8.6.2: Mejora el ejemplo 08_06a para que no use "while (true)", sino una variable booleana de control.
8.7.1: Un programa que pida al usuario el nombre de un fichero de origen y el de un fichero de destino, y que vuelque al segundo fichero el contenido del primero, convertido a mayúsculas. Se debe controlar los posibles errores, como que el fichero de origen no exista, o que el fichero de destino no se pueda crear.
8.7.2: Un programa que pida al usuario un número, una operación (+, -, *, /) y un segundo número, y muestre el resultado de la correspondiente operación. Si se teclea un dato no numérico, el programa deberá mostrar un aviso y volver a pedirlo, en vez de interrumpir la ejecución.
8.7.3: Un programa que pida al usuario repetidamente pares de números y la operación a realizar con ellos (+, -, *, /) y guarde en un fichero "calculadora.txt" el resultado de dichos cálculos (con la forma "15 * 6 = 90"). Debe controlar los posibles errores, como que los datos no sean numéricos, la división entre cero, o que el fichero no se haya podido crear.
8.9.1: Abre un fichero con extensión EXE (cuyo nombre introducirá el usuario) y comprueba si realmente se trata de un ejecutable, mirando si los dos primeros bytes del fichero son un 77 (que corresponde a una letra "M", según el estándar que marca el código ASCII) y un 90 (una letra "Z"), respectivamente.
8.9.2: Abre una imagen BMP (cuyo nombre introducirá el usuario) y comprueba si realmente se trata de un fichero en ese formato, mirando si los dos primeros bytes del fichero corresponden a una letra "B" y una letra "M", respectivamente.
8.9.3: Abre una imagen GIF y comprueba si sus tres primeros bytes son las letras G, I, F.
8.10.1: Crea un programa que compruebe si un fichero (cuyo nombre introducirá el usuario) contiene una cierta letra (también escogida por el usuario).
8.10.2: Crea un programa que cuente la cantidad de vocales que contiene un fichero binario.
8.10.3: Crea un programa que diga si un fichero (binario) contiene una cierta palabra que introduzca el usuario.
8.10.4: Crea un programa que extraiga a un fichero de texto todos los caracteres alfabéticos (códigos 32 a 127, además del 10 y el 13) que contenga un fichero binario.
8.11.1: Abre un fichero con extensión EXE y comprobar si realmente se trata de un ejecutable, mirando si los dos primeros bytes del fichero corresponden a una letra "M" y una letra "Z", respectivamente. Debes leer ambos bytes a la vez, usando un array.
8.11.2: Abre una imagen BMP (cuyo nombre introducirá el usuario) y comprueba si realmente se trata de un fichero en ese formato, mirando si los dos primeros bytes del fichero corresponden a una letra "B" y una letra "M", respectivamente. Usa "Read" y un array.
8.11.3: Abre una imagen GIF y comprueba si sus tres primeros bytes son las letras G, I, F. Guarda los 3 datos en un array.
8.11.4: Abre una imagen en formato BMP y comprueba si está comprimida, mirando el valor del byte en la posición 30 (empezando a contar desde 0). Si ese valor es un 0 (que es lo habitual), indicará que el fichero no está comprimido. Deberás leer toda la cabecera (los primeros 54 bytes) con una sola orden.
8.12.1: Abre un fichero con extensión EXE y comprueba si su segundo byte corresponde a una letra "Z", sin leer su primer byte.
8.12.2: Abre una imagen en formato BMP y comprueba si está comprimida, mirando el valor del byte en la posición 30 (empezando a contar desde 0). Si ese valor es 0 (que es lo habitual), indicará que el fichero no está comprimido. Salta a esa posición directamente, sin leer toda la cabecera.
8.13.1: Abre un fichero con extensión EXE y comprueba si comienza con el entero corto 23117.
8.13.2: Abre una imagen en formato BMP y comprueba si comienza con el entero corto 19778.
8.13.3: El alto de un fichero BMP es un entero de 32 bits que se encuentra en la posición 22. Amplía el ejemplo 08_13d, para que muestre también el alto de ese fichero BMP.
8.14.1: Localiza en Internet información sobre el formato de imágenes PCX. Crea un programa que diga el ancho, alto y número de colores de una imagen PCX.
8.14.2: Localiza en Internet información sobre el formato de imágenes GIF. Crea un programa que diga el subformato, ancho, alto y número de colores de una imagen GIF.
8.15.1: Crea una copia de un fichero EXE. La copia debe tener el mismo nombre y extensión BAK.
8.15.2: Crea un programa que "encripte" el contenido de un fichero BMP, volcando su contenido a un nuevo fichero, en el que intercambiará los dos primeros bytes. Para desencriptar, bastará con volver a intercambiar esos dos bytes, volcando a un tercer fichero.
8.16.1: Crea un programa que "encripte" el contenido de un fichero BMP, intercambiando los dos primeros bytes (y modificando el mismo fichero). Para desencriptar, bastará con volver a intercambiar esos dos bytes.
8.16.2: Crea un programa que vuelque todo el contenido de un fichero de texto a otro, convirtiendo cada frase a mayúsculas. Los nombres de ambos ficheros se deben indican como parámetros en la línea de comandos.
8.16.3: Un programa que vuelque todo el contenido de un fichero binario a otro, convirtiendo cada letra entre la A y la Z a mayúsculas. Los nombres de ambos ficheros se deben indican como parámetros en la línea de comandos. Si no hay parámetros, se le preguntarán al usuario.
8.16.4: Mejora la base de datos de ficheros (ejemplo 04_06a) para que los datos almacenados se guarden automáticamente en fichero al terminar una ejecución, y se vuelvan a cargar al principio de la siguiente.
8.16.5: Crea un "traductor básico de C# a C", que volcará todo el contenido de un fichero de texto a otro, pero reemplazando "Console.WriteLine" con "printf", "Main" con "main", "string" con "char[80]", "Console.ReadLine" con "scanf", y eliminando "static" y "public" y las líneas que comiencen con "Using".
8.16.6: Prepara un programa que pida al usuario el nombre de un fichero y una secuencia de 4 bytes, y diga si el fichero contiene esa secuencia de bytes.
8.16.7: Haz un programa que duplique un fichero, copiando todo su contenido a un nuevo fichero, byte a byte. El nombre del fichero de salida se tomará del nombre del fichero de entrada, al que se añadirá ".out".
8.16.8: Crea un programa que duplique un fichero, copiando todo su contenido a un nuevo fichero, volcando para ello todo el contenido en un array. El nombre de ambos ficheros se debe leer de la línea de comandos, o pedir al usuario en caso de no existir parámetros.
8.16.9: Crea un programa que compare si dos ficheros son iguales byte a byte, comprobando primero su tamaño y leyendo después cada vez un byte de cada uno de ellos.
8.16.10: Crea un programa que compare si dos ficheros son iguales, volcando todo su contenido en sendos arrays, que compararás.
8.16.11: Un programa que muestre el nombre del autor de un fichero de música en formato MP3 (tendrás que localizar en Internet la información sobre dicho formato y sobre la cabecera ID3 V1, que se encuentra -si está presente- en los últimos 128 bytes del fichero).
11.2.1: Crea un programa que pida al usuario 5 números enteros y luego los muestre en orden contrario, utilizando una pila.
11.2.2: Crea un programa que pida al usuario el nombre de un fichero de texto y muestre en orden inverso las líneas que lo forman, empleando una pila.
11.2.3: Crea una clase que imite el comportamiento de una pila, pero usando internamente un array (si no lo consigues, no te preocupes; en un apartado posterior veremos una forma de hacerlo).
11.2.4: La "notación polaca inversa" es una forma de expresar operaciones que consiste en indicar los operandos antes del correspondiente operador. Por ejemplo, en vez de "3+4" se escribiría "3 4 +". Es una notación que no necesita paréntesis y que se puede resolver usando una pila: si se recibe un dato numérico, éste se guarda en la pila; si se recibe un operador, se obtienen los dos operandos que hay en la cima de la pila, se realiza la operación y se apila su resultado. El proceso termina cuando sólo hay un dato en la pila. Por ejemplo, "3 4 +" se convierte en: apilar 3, apilar 4, sacar dos datos y sumarlos, guardar 7, terminado. Impleméntalo y comprueba si el resultado de "3 4 6 5 - + * 6 +" es 21.
11.3.1: Crea un programa que pida al usuario 5 números reales de doble precisión, los guarde en una cola y luego los muestre en pantalla.
11.3.2: Crea un programa que pida frases al usuario, hasta que introduzca una frase vacía. En ese momento, mostrará todas las frases que se habían introducido.
11.3.3: Crea un programa que lea el contenido de un fichero de texto, lo almacene línea por línea en una cola, luego muestre este contenido en pantalla y finalmente lo vuelque a otro fichero de texto.
11.4.1.1: Crea un programa que lea el contenido de un fichero de texto, lo almacene línea por línea en un ArrayList, y luego pregunte de forma repetitiva al usuario qué línea desea ver. Terminará cuando el usuario introduzca "-1".
11.4.1.2: Crea un programa que lea el contenido de un fichero de texto, lo almacene línea por línea en un ArrayList, y luego pregunte de forma repetitiva al usuario qué texto desea buscar y muestre las líneas que contienen ese texto. Terminará cuando el usuario introduzca una cadena vacía.
11.4.1.3: Crea un programa que lea el contenido de un fichero de texto, lo almacene línea por línea en un ArrayList, lo ordene y lo muestre ordenado en pantalla.
11.4.1.4: Crea un programa que lea el contenido de un fichero de texto, lo almacene línea por línea en un ArrayList, luego muestre en pantalla las líneas impares (primera, tercera, etc.) y finalmente vuelque a otro fichero de texto las líneas pares (segunda, cuarta, etc.).
11.4.1.5: Crea una nueva versión de la "bases de datos de ficheros" (ejemplo 04_06a), pero usando ArrayList en vez de un array convencional.
11.4.2.1: Crea un programa que, cuando el usuario introduzca el nombre de un número del 1 al 10 en inglés (por ejemplo, "two"), diga su traducción en español (por ejemplo, "dos").
11.4.2.2: Crea un programa que, cuando el usuario introduzca el nombre de un mes en español (por ejemplo, "abril"), muestre su traducción en inglés (por ejemplo, "april").
11.4.2.3: Crea un traductor básico de C# a Pascal, que tenga las traducciones almacenadas en una SortedList (por ejemplo, "{" se convertirá a "begin", "}" se convertirá a "begin", "WriteLine" se convertirá a "WriteLn", "ReadLine" se convertirá a "ReadLn", "void" se convertirá a "procedure" y "Console." se convertirá a una cadena vacía. Úsalo para convertir un abrir un fichero que contenga un fuente en C# y mostrar su equivalente (que no será perfecto) en Pascal.
11.5.1: Crea una versión alternativa del ejercicio 11.4.2.1, pero que tenga las traducciones almacenadas en una tabla Hash.
11.5.2: Crea una versión alternativa del ejercicio 11.4.2.2, pero que tenga las traducciones almacenadas en una tabla Hash.
11.6.1: Crea un programa que, a partir de la SortedList del ejercicio 11.4.2.1, muestre todo su contenido usando un enumerador.
11.6.2: A partir del ejercicio 11.3.1, crea un programa que pida al usuario 5 números reales de doble precisión, los guarde en una cola y luego los muestre en pantalla usando un enumerador.
11.7.1: Usando esta misma estructura de programa, crea una clase "Cola", que permita introducir datos (números enteros) y obtenerlos en modo FIFO (el primer dato que se introduzca debe ser el primero que se obtenga). Debe tener un método "Encolar" y otro "Desencolar".
11.7.2: Crea una clase "ListaOrdenada", que almacene un único dato, un "string" (no un par clave-valor como los SortedList). Debe contener un método "Insertar", que añadirá un nuevo dato en orden en el array, y un "Extraer(n)", que obtenga un elemento de la lista (el número "n"). Crea también un método "ObtenerCantidad()", que devolverá un entero, que será la cantidad de datos que hay en la lista, de forma que se pueda recorrer con un "for"
11.7.3: Prepara una pila de "doubles", usando internamente un ArrayList en vez de un array. Incluye también un programa de prueba.
11.7.4: Crea una cola que almacene un bloque de datos (struct, con los campos que tú elijas, como por ejemplo un punto con coordenadas X e Y) usando un ArrayList.
11.7.5: Crea una lista ordenada (de "strings"), como la del ejercicio 11.7.2, pero esta vez usando un ArrayList.
11.8.1: Crea una nueva versión de la "bases de datos de ficheros" (ejemplo 04_06a), pero usando List en vez de un array convencional.
11.8.2: Crea un programa que lea todo el contenido de un fichero, lo guarde en una lista de strings y luego lo muestre en orden inverso (de la última línea a la primera).
12.1.1: Crea una versión mejorada del ejemplo 12_01a, que muestre el nombre del mes (usa un array para almacenar los nombres y accede a la posición correspondiente), la hora, los minutos, los segundos y las décimas de segundo (no las milésimas). Si los minutos o los segundos son inferiores a 10, deberán mostrarse con un cero inicial, de modo que siempre aparezcan con dos cifras.
12.1.2: Crea un reloj que se muestre en pantalla, y que se actualice cada segundo (usando "Sleep"). En esta primera aproximación, el reloj se escribirá con "WriteLine", de modo que aparecerá en la primera línea de pantalla, luego en la segunda, luego en la tercera y así sucesivamente (en el próximo apartado veremos cómo hacer que se mantenga fijo en unas ciertas coordenadas de la pantalla).
12.1.3: Crea un programa que pida al usuario su fecha de nacimiento, y diga de qué día de la semana se trataba.
12.1.4: Crea un programa que muestre el calendario del mes actual (pista: primero deberás calcular qué día de la semana es el día 1 de este mes). Deberá ser algo como:
Mayo 2015
lu ma mi ju vi sá do
1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28
12.1.5: Crea un programa que muestre el calendario correspondiente al mes y el año que se indiquen como parámetros en línea de comandos.
12.1.6: Crea un programa que vuelque a un fichero de texto el calendario del año que se indique como parámetro en línea de comandos. Deben mostrarse tres meses en anchura: el primer bloque contendrá enero febrero y marzo, el segundo tendrá abril, mayo y junio y así sucesivamente.
12.2.1: Crea un programa que muestre una "pelota" (la letra "O") rebotando en los bordes de la pantalla. Para que no se mueva demasiado rápido, haz una pausa de 50 milisegundos entre un "fotograma" y otro.
12.2.2: Crea una versión de la "base de datos de ficheros" (ejemplo 04_06a) que use colores para ayudar a distinguir los mensajes del programa de las respuestas del usuario, y que no necesite pulsar Intro tras escoger cada opción.
12.2.3: Crea un programa que permita "dibujar" en consola, moviendo el cursor con las flechas del teclado y pulsando "espacio" para dibujar un punto o borrarlo.
12.2.4: Crea una versión del programa de "dibujar" en consola (12.2.3), que permita escribir más caracteres (por ejemplo, las letras), así como mostrar ayuda (pulsando F1), guardar el contenido de la pantalla en un fichero de texto (con F2) o recuperarlo (con F3).
12.2.5: Crea una versión mejorada del programa 12.1.2 (mostrar el reloj actualizado en pantalla, que lo dibuje siempre en la esquina superior derecha de la pantalla).
12.3.1: Crea un programa que muestre en pantalla el contenido de un fichero de texto, cuyo nombre escoja el usuario. Si el usuario no sabe el nombre, podrá pulsar "Intro" y se le mostrará la lista de ficheros existentes en el directorio actual, para luego volver a preguntarle el nombre del fichero.
12.3.2: Crea un programa que cree un fichero de texto a partir del contenido de todos los ficheros de texto existentes en la carpeta actual.
12.3.3: Crea un programa que permita "pasear" por la carpeta actual, al estilo del antiguo "Comandante Norton": mostrará la lista de ficheros y subdirectorios de la carpeta actual, y permitirá al usuario moverse hacia arriba o abajo dentro de la lista usando las flechas del cursor. El elemento seleccionado se mostrará en color distinto del resto.
12.3.4: Mejora el ejercicio 12.3.3 para que muestre directorios (en primer lugar) y ficheros (a continuación), y permita entrar a un directorio si se pulsa Intro sobre él (en ese momento, se actualizará la lista de ficheros y directorios, para mostrar el contenido del directorio al que se ha accedido).
12.3.5: Mejora el ejercicio 12.3.4 para que contenga dos paneles, uno al lado del otro, cada uno de los cuales podrá estar mostrando el contenido de un directorio distinto. Si se pulsa el "tabulador", cambiará el panel activo.
12.3.6: Mejora el ejercicio 12.3.5, para que se pueda "seleccionar un fichero" pulsando "Espacio" o "Insert". Los ficheros seleccionados se mostrarán en un color distinto. Se podrán deseleccionar volviendo a pulsar "Espacio" o "Insert". Si se pulsa F5, los ficheros seleccionados en la carpeta actual del panel actual se copiarán a la carpeta del otro panel. Mientras se están copiando, el programa debe mostrar una "barra de progreso" de color amarillo, que indicará el porcentaje de ficheros que ya se han copiado.