Introducción a la Programación

Nombre de la asignatura:

Introducción a la programación

Clave de la asignatura:

INP-ES

Propósito de aprendizaje de la asignatura:

El alumno implementará programas mediante metodologías y herramientas de programación para visualizar las aplicaciones de tecnologías de la información en la solución de problemas.

Cuatrimestre

Primero

Horas presenciales

90

Horas por semana presenciales

6

Horas por semana no presenciales

1

Horas totales por semana

7

Evaluaciones por Unidad

Luis Joyanes 2008 Fundamentos de Programación: Algoritmos, estructura de datos y objetos Madrid, España Mc Graw Hill 978-84-481-6111-8

Luis Joyanes 2013 Fundamentos generales de programación Madrid, España Mc Graw Hill 978-607-15-0818-8

CAIRÓ, Osvaldo 2005 Metodología de la programación - algoritmos, diagramas de flujo y programas México Alfaomega 970-15-1100-X

SZNAJDLEDER, Pablo 2017 Algoritmos a Fondo: - Con implementaciones en c y java México Alfaomega Grupo Editor " 9786077079576 "

"Mark A. Weiss, Mark Allen Weiss, Weiss Mark Hardcover" 2013 Structures & Algorithm Analysis in C++ Estados Unidos Prentice Hall College 978-0-13-284737-7

Juan Bernado Vázquez Gómez 2012 Análisis y diseño de algoritmos México Red Tercer Milenio 978-607-733-053-0

Robert Sedgewick, Kevin Wayne 2106 Algorithms Estados Unidos Addison-Wesley Professional 978-0-13-438468-9

Tema 1 - Fundamentos de algoritmos

Tema 2 - Tipos de datos y expresiones

Tema 3 - Metodología para la solución de problemas

1. Definir el problema: saber que es el problema y comprenderlo.
2. Analizar el problema: idear los pasos a seguir, identificar las entradas, salidas y procesos.
3. Diseñar una solución: el análisis plantearlo mediante un algoritmo: diagrama de flujo y pseudocódigo.
   • INICIO
   • Paso1. Declarar variables
   • Paso2. Entradas de datos
   • Paso3. Proceso de datos
   • Paso4. Salida de datos
   • FIN
4. Implementar la solución: El diagrama de flujo representarlo en un lenguaje de programación, realizar pruebas y mejoras al programa.

Evaluación

Herramientas a utilizar

PSeInt

Da clic aquí para descargar

Archivo con formato personalizado para PSeInt

Da clic aquí para descargarlo

Visual Studio 17

Da clic aquí para descargar

Compilador online de C# (dotnetfiddle.net)

Da clic aquí para acceder

Compilador online de C# (Repl.it)

Da clic aquí para acceder

1er Bloque de Ejercicios - Algoritmos secuenciales en PseInt

Da clic aquí para descargar el archivo

2do Bloque de Ejercicios - Algoritmos secuenciales en PseInt

Da clic aquí para descargar el archivo

Tema 1 - Tipos de aplicaciones

Por lo general podemos encontrar una clasificación de tipos de aplicaciones divididas en tres grupos: nativas, híbridas y generadas. Lo importante a considerar para seleccionar un tipo es conocer el recurso económico con el que se cuenta, saber en qué es bueno nuestro equipo de desarrollo, saber cuál es el uso que se le dará a la aplicación, etc. También es super importante conocer que modelo, tecnología y lenguaje utilizar para el desarrollo.

Nativas
Para su desarrollo es utilizado un lenguaje de programación nativo. Para iOS es Objective C o Siwft, para Android es Java, para Windows Phone es .NET. Las apps no son portables y se deben desarrollar según la plataforma en donde se implementará. Si se desea crear una app nativa multiplataforma, se deberá crear una app para cada plataforma.

Híbridas
Son desarrolladas utilizando tecnologías web como HTML5, CSS3, JavaScript, utilizando Phonegap/Cordova haciendo su modelo neutro con respecto a la plataforma a utilizar.

Web
Son desarrolladas con tecnologías web: HTML, CSS, Javascript, utilizando frameworks. Se alojan en servidores.

Generadas
Son las apps donde se desarrollan en un lenguaje de programación específico, y se genera un código nativo para cada plataforma. Se dice serán el desarrollo de apps del futuro. Son desarrolladas con herramientas como Xamarin o Genexus, utilizando técnicas para generar la app en el lenguaje de la plataforma donde se implementará. Se le denomina falsas nativas, pues no cumplen con los principios de las apps nativas.

Tema 2 - Entrada y salida de datos

Salida de datos
Para mostrar una salida de datos, es decir, texto en la consola necesitamos declarar de la biblioteca de funciones la clase Console y después mandar llamar el método Write() o WriteLine():

		//Muestra texto en la consola
		Console.Write();
		
		//Muestra texto por linea en la consola
		Console.WriteLine();
		
		/* -----Ejemplos----- */
		
		//Muestra el texto "hola mundo"
		Console.WriteLine("Hola mundo");
		
		------------------------
		|consola               |
		------------------------
		|   Hola mundo         |
		|                      |
		|                      |
		|                      |
		|                      |
		------------------------
		
		//Muestra un entero 10
		Console.WriteLine(10);
		
		------------------------
		|consola               |
		------------------------
		|   10                 |
		|                      |
		|                      |
		|                      |
		|                      |
		------------------------
	

Entrada de datos
Para pedir una entrada de datos en una consola, necesitamos declarar de la biblioteca de funciones la clase Console y después mandar llamar el método Read() o ReadLine():

		//Le pide al usuario que ingrese datos a la consola en una sola línea
		Console.Read()
		
		//Le pide al usuario que ingrese datos a la consola y los lee por línea
		Console.ReadLine();
		
		/* -----Ejemplos----- */
		
		//Le pide al usuario que ingrese un valor y lo lee y lo guarda como cadena
		Console.WriteLine("Ingrese un valor:");
		string valor = Console.ReadLine();
		
		------------------------
		|consola               |
		------------------------
		|   Ingrese un valor:  |
		|   >Hola              |
		|                      |
		|                      |
		|                      |
		------------------------
		
		//El valor se almacena en la variable valor,
		//entonces si la agregamos dentro de un Console.WriteLine()
		//el valor de la variable valor se muestra:
		Console.WriteLine(valor);
		------------------------
		|consola               |
		------------------------
		|   Hola               |
		|                      |
		|                      |
		|                      |
		|                      |
		------------------------
	

Tema 3 - Declaración de variables

Notación húngara
Es una convención de nomenclatura que propone anteponer al nombre de la variable un prefijo que, a simple vista, permita identificar su tipo de datos. Por ejemplo: iContador ("i" de int), sNombre ("s" de string), bFin ("b" de boolean), dPrecioVenta ("d" de double), etcétera.
Si bien la notación húngara cuenta con una importante comunidad de detractores que aseguran que, a la larga, complica la legibilidad y la mantenibilidad del código fuente, personalmente considero que, en ciertas ocasiones, se puede utilizar.

Las variables
Las variables representan un espacio de la memoria de la computadora. A travpes de una variable, podemos almacenar temporalmente datos para tenerlos disponibles durante la ejecución del programa. Para utilizar una variable, tenemos que especificar un nombre y un tipo de datos. Al nombre de la variable lo llamamos "identificador". Al tipo de dato de la variable la llamaremos "literal". En general, un identificador debe comenzar con una letra y no puede contener espacios en blanco, signos de puntuación u operadores.
Nombres de las variables o identificadores válidos:

• fecha
• fec
• fechaNacimiento
• fechaNac
• fec1
• fec2
• iFechaNac

Nombres de variables o identificadores incorrectos:

• 2fecha (no puede comenzar con un número)
• -fecha (no puede comenzar con un signo "menos")
• fecha nacimiento (no puede tener espacios en blanco)
• fecha-nacimiento (no puede tener el signo "menos")
• fecha+nacmieto (no puede tener el signo "mas")

Los valores que mantienen las variables pueden cambiar durante la ejecución del programa, justamente por eso, son "variables". Para que una variable adquiera un determinado valor se lo tendremos que asignar manualmente con el operador de asignación o bien leer u valor a través de algún dispositivo de entrada y almacenarlo en la variable.

Declaración de variables según C#

		
		Tipos de valor
			Tipos simples
				Entero con signo: sbyte, short, int, long
				Entero sin signo: byte, ushort, uint, ulong
				Caracteres Unicode: char
				Punto flotante de IEEE: float, double
				Decimal de alta precisión: decimal
				Booleano: bool
			Tipos de enumeración
				Tipos definidos por el usuario con el formato enum E { ... }
			Tipos de estructura
				Tipos definidos por el usuario con el formato struct S { ... }
			Tipos de valor que aceptan valores NULL
				Extensiones de todos los demás tipos de valor con un valor NULL
				
		Tipos de referencia
			Tipos de clase
				Clase base definitiva de todos los demás tipos: object
			Cadenas Unicode: string
			Tipos definidos por el usuario con el formato class C { ... }
			Tipos de interfaz
				Tipos definidos por el usuario con el formato interface I { ... }
			Tipos de matriz
				Unidimensional y multidimensional; por ejemplo, int[] y int[,]
			Tipos delegados
				Tipos definidos por el usuario con el formato delegate int D { ... }
	

Tema 4 - Conversión de tipos de datos

C# permite convertir datos de un tipo a otro. Una variable definida con un tipo de dato, puede convertir su valor a otro. Estas conversiones se pueden clasificar como:

• Conversiones implícitas: no se requiere una sintaxis especial porque la conversión es segura y no se perderán datos. Los ejemplos incluyen conversiones de tipos integrales de menores a mayores, y conversiones de clases derivadas a clases base.

  				int num = 2147483647;
  				long bigNum = num;
  			

  Tabla de conversión implícita
  
• Conversiones explícitas: las conversiones explícitas requieren un operador de conversión. La conversión se requiere cuando la información puede perderse en la conversión, o cuando la conversión puede no tener éxito por otras razones. Los ejemplos típicos incluyen la conversión numérica a un tipo que tiene menos precisión o un rango menor, y la conversión de una instancia de clase base a una clase derivada.

  				double x = 1234.7;
  				int a;
  				// Cast double to int.
  				a = (int)x;
  				System.Console.WriteLine(a);
  			

  Tabla de conversión explícita
  
• Conversiones definidas por el usuario: las conversiones definidas por el usuario se realizan mediante métodos especiales que puede definir para habilitar conversiones explícitas e implícitas entre tipos personalizados que no tienen una relación de clase derivada de clase base. Los operadores de conversión tienen las siguientes propiedades:
  • Las conversiones declaradas como implicito ocurren automáticamente cuando es requerido.
  • Las conversiones declaradas como explicitas requieren un reparto para ser llamado.
  • Todas las conversiones deben ser declaradas como static.
• Conversiones con clases auxiliares: para convertir entre tipos no compatibles, como enteros y objetos System.DateTime , o cadenas hexadecimales y de bytes, puede usar la clase System.BitConverter , la clase System.Convert y los Parsemétodos de la compilación. -en tipos numéricos, tales como Int32.Parse. Para obtener más información, vea Cómo convertir una matriz de bytes en un int , Cómo convertir una cadena en un número y Cómo convertir entre cadenas hexadecimales y tipos numéricos.

  				double dNumber = 23.15;
  				try {
  					// Returns 23
  					int    iNumber = System.Convert.ToInt32(dNumber);
  				}
  				catch (System.OverflowException) {
  					System.Console.WriteLine(
  								"Overflow in double to int conversion.");
  				}
  			

  Tabla de algunos métodos de la clase Convert
  
  
  Conversiones con Parse(): Este es el más simple. Parse() lanza excepciones en entradas inválidas. Esto puede ser lento si los errores son comunes. Nota: Parse() es un método estático al que accedemos en el tipo int.

  				using System;
  
  				class Program
  				{
  					static void Main()
  					{
  						// Convert string to number.
  						string text = "500";
  						int num = int.Parse(text);
  						Console.WriteLine(num);
  					}
  				}
  			

  
  
  Conversiones con TryParse(): Este es el más simple. Parse() lanza excepciones en entradas inválidas. Esto puede ser lento si los errores son comunes. Nota: Parse() es un método estático al que accedemos en el tipo int.

  				using System;
  
  				class Program
  				{
  					static void Main()
  					{
  						// See if we can parse the 'text' string.
  						// If we can't, TryParse will return false.
  						// Note the "out" keyword in TryParse.
  						string text1 = "x";
  						int num1;
  						bool res = int.TryParse(text1, out num1);
  						if (res == false)
  						{
  							// String is not a number.
  						}
  
  						// Use int.TryParse on a valid numeric string.
  						string text2 = "10000";
  						int num2;
  						if (int.TryParse(text2, out num2))
  						{
  							// It was assigned.
  						}
  
  						// Display both results.
  						Console.WriteLine(num1);
  						Console.WriteLine(num2);
  					}
  				}
  			

Ejemplo de pseudocódigo y diagrama de flujo de conversiones implícitas, explícitas, con clase Convert y método Parse()

3er Bloque de Ejercicios - Conversiones implícitas

Da clic aquí para descargar las indicaciones

4to Bloque de Ejercicios - Conversiones explícitas (cast)

Da clic aquí para descargar las indicaciones

5to Bloque de Ejercicios - Conversiones explícitas utilizando la clase Convert y Parse

Da clic aquí para descargar las indicaciones

Tema 5 - Estructuras de control

El teorema de la programación estructurada (70s) describe tres estructuras básicas de control con los que demuestra que es posible resolver cualquier problema computacional.

Programación estructurada: Es un paradigma de programación orientado a mejorar la claridad, calidad y tiempo de desarrollo de un programa de computadora, utilizando únicamente subrutinas y tres estructuras: secuencia, selección (if y switch) e iteración (bucles for y while), considerando innecesario y contraproducente el uso de la instrucción de transferencia incondicional (GOTO), que podría conducir a "código espagueti", que es mucho más difícil de seguir y de mantener, y era la causa de muchos errores de programación. Surgió en la década de 1960, particularmente del trabajo Böhm y Jacopini, y una famosa carta, La sentencia goto considerada perjudicial, de Edsger Dijkstra en 1968 y fue reforzado teóricamente por el teorema del programa estructurado, y prácticamente por la aparición de lenguajes como ALGOL con adecuadas y ricas estructuras de control. (EcuRed.cu. Proyecto de constitución de la república de Cuba. dirección de donde se extrajo el documento: fuente)

Estructura secuencial
En este caso, simplemente, haremos un breve repaso para recordar que la estructura secuencial consiste en ejecutar, secuencialmente, una acción simple detrás de otra.
Se considera acción simple a las acciones de leer, escribir, asignar valor a una variable e invocar a un módulo o función.

Estructura de decisión
Permite decidir entre ejecutar uno u otro conjunto de acciones en función de que se cumpla o no una determinada condición lógica. Principalmente se usa el if{}else{} y switch(){}

Estructura de repetición
También llamada "estructura iterativa" o "ciclo de repetición", permite ejecutar una y otra vez un conjunto de acciones en funciones de que se verifique una determinada condición lógica.
Según sea exacta o inexacta la cantidad de veces que el ciclo iterará podemos clasificar a la estructura de repetición de la siguiente manera:

• Estructura de repetición inexacta que itera entre 0 y n veces (while)
• Estructura de repetición inexacta que itera entre 1 y n veces (do-while)
• Estructrua de repetición exacta que itera entre i y n veces, siendo i <= n (for)

Tema 6 - Estructuras de secuencia

La estructura secuencial consiste en ejecutar, secuencialmente, una acción simple detrás de otra. Una acción simple puede ser leer, escribir, asignar valor a una variable e invocar a un módulo o función.

6to Bloque de Ejercicios - Estructuras de secuencia en C#

1. PROBLEMA1: Elabora un programa en consola C#, en donde el usuario ingrese dos números enteros y el programa calcule su suma, su resta, su multiplicación y su división.
2. PROBLEMA2: Elabora un programa en consola C#, en donde el usuario ingrese cinco precios de productos con sus respectivas cantidades y el programa muestre el total de los precios y el total de las cantidades.
3. PROBLEMA3: Elabora un programa en consola C#, en donde el usuario ingrese cinco numeradores y cinco denimonadores y muestre el residuo de la combinación de cada uno de ellos.
4. PROBLEMA4: Elabora un programa en consola C#, en donde el precio de una hamburguesa especial de $35.00, hamburguesa sencilla es de $25.00, refresco de $15.00, papas de $20.00. El usuario debe indicar la cantidad que desea comprar de cada producto y el programa deberá mostrar el precio de cada producto por la cantidad y el precio total con el iva correspondiente (ya incluido).
5. PROBLEMA5: Elabora un programa en consola C#, en donde el usuario ingrese dos número y el programa muestre como resultado de cada uno el valor absoluto (Math.Abs()), potencia (Math.Pow()), raíz cuadrada (Math.Sqrt()), seno (Math.Sin()), coseno (Math.Cos()), número máximo de los dos (Math.Max()), número mínimo de los dos (Math.Min()), parte entera (Math.Trunc()) y si son decimales que los muestre redondeados (Math.Round()).

Tema 7 - Estructuras de decisión

La estructura de decisión permite decidir entre ejecutar uno u otro conjunto de acciones en función de que se cumpla o no una determinada condición lógica. Da clic aquí para más información.

• Simples (if): La instrucción if realiza (selecciona) una acción si una condición es verdadera, o ignora la acción si la condición es falsa

  				if(expresión booleana)
  				{
  					Instrucción(es) de condición verdadera;
  				}
  			

• Anidadas (if...else): Cuando en una estructura de decisión utilizamos otra estructura de decisión, decimos que ambas son estructuras anidadas. La condición siempre se evalúa en el if. NUNCA se evaluará una condición después de la sentencia else.

  				if(expresión booleana)
  				{
  					Instrucción(es) de condición verdadera;
  				}
  				else 
  				{
  					Instrucción(es) de condición falsa;
  				}
  			

• En línea (x ? y : z): Esta estructua implementa un if en una única línea de código y funciona así: resultado = condicion ? expresion1:expresion2;

  				Console.WriteLine(x==0 ? "x igual a cero" : "x es diferente de cero");
  			

• Cascada (if...if...if...else): Esta estructura contiene una serie de if, si una condición no se cumple entonces puede preguntar por otra condición, después por otra.

  				if(condición1)
  				{
  					Bloque de instrucciones;
  				}
  				else if(condición2)
  				{
  					Bloque de instrucciones;
  				}
  				else if(condición3)
  				{
  					Bloque de instrucciones;
  				}
  				else
  				{
  					Bloque de instrucciones;
  				}
  			

• Múltiple (switch): Cuando hay muchas condiciones a evaluar, la instrucción if…else puede resultar demasiado compleja de manejar. Una solución mucho más limpia en estos casos consiste en usar la instrucción switch. La instrucción switch permite cualquier valor entero o de cadena con múltiples valores. Cuando se produce una coincidencia se ejecutan todas las instrucciones asociadas con ella.

  				switch(expresión_de_control)
  				{
  					case -literal1-:
  						Instrucciones;
  						break;
  					.
  					.
  					.
  					case -literaln-:
  						Instrucciones;
  						break;
  					default:
  						Instrucciones;
  						break;
  				}
  			

7mo Bloque de Ejercicios - Estructuras de decisión en C#

1. PROBLEMA1: Elabora un programa en consola C#, en donde el usuario ingrese un número entero, después se deberá mostrar si el número indicado tiene uno o dos dígitos.
2. PROBLEMA2: Elabora un programa en consola C#, en donde el usuario proporciona cinco calificaciones, calcula el promedio y muestra si la calificación es aprobatoria (calificacion>=7) o reprobada
3. PROBLEMA3: Elabora un programa en consola c#, en donde el usuario proporcione cinco números y nos diga cuáles números son mayores a 10
4. PROBLEMA4: Elabora un programa en consola C# en donde el usuario ingrese tres números y nos muestre cual es el mayor de ellos
5. PROBLEMA5: Elabora un programa en consola C# en donde el usuario ingrese un número entero y muestre si es par o impar
6. PROBLEMA6: Elabora un programa en consola C# en donde el usuario ingrese cinco números y nos muestre si son positivos, negativos o son igual a cero
7. PROBLEMA7: Elabora un programa en consola C# en donde el usuario ingrese la edad de una persona y el sexo de la misma (1. Masculino, 2. Femenino) de dos personas y nos muestre de qué sexo es la persona mayor de edad
8. PROBLEMA8: Elabora un programa en consola C# en donde el usuario seleccione si quiere calcular el área y perímetro de una de las siguientes figuras: cuadrado, triángulo, rectángulo, círculo
9. PROBLEMA9: Elabora un programa en consola C# en donde el usuario seleccione una de las siguientes opciones y realice sus respectivos calculos: 1) Suma, 2) Resta, 3) Multiplicación, 4) División, 5) Raíz Cuadrada, 6) Exponenciación, 7) Salir del programa
10. PROBLEMA10: Elabora un programa en consola C# en donde el usuario ingrese la cantidad de bytes y después seleccione una de las siguientes opciones y realice sus respectivos calculos: a) Convertir a Kb, b) Convertir a Mb, c) Convertir a Gb, d) Convertir a Tb, e) Convertir a Pb, f) Convertir a Eb, g) Convertir a Zb, h) Convertir a Yb, i) Convertir a Bb, j) Convertir a Gb

Tema 8 - Estructuras de repetición

Los bucles o ciclos repiten una sentencia o una secuencia de sentencias un número de veces. A dichas sentencias se les conoce como cuerpo del bucle. A cada repetición del bucle se le llama iteración. (fuente)

• Mientras (while): Repite la ejecución de una sentencia o de un grupo de sentencias mientras la condición que se evalúa (al principio del bucle) sea verdadera.

  				while(condición_del_bucle)
  				{
  					instrucciones;
  				}
  			

• Para (for): Ejecuta una sentencia o conjunto de sentencias un número finito de veces.

  				for(inicialización; condición_iteración; incremento_o_decremento)
  				{
  					Instrucciones;
  				}
  			

• Repite (do...while): Repite le ejecución de una sentencia o de un grupo de sentencias mientras se cumpla la condición especificada (al menos una vez).

  				do
  				{
  					Instrucciones;
  				}
  				while(condición);
  			

8vo Bloque de Ejercicios - Estructuras de repetición en C#

1. Elabora un programa en consola C#, en donde muestres los números del 0 y 100
2. Elabora un programa en consola C#, en donde muestres los números del 100 y 0
3. Elabora un programa en consola C#, en donde muestres los números impares entre el 0 y 100
4. Elabora un programa en consola C#, en donde muestres los números pares entre el 0 y 100
5. Elabora un programa en consola C#, en donde muestres los números multiplos de 3 del 0 al 100
6. Elabora un programa en consola C#, en donde muestres los números multiplos de 5 del 0 al 100
7. Elabora un programa en consola C#, en donde el usuario ingrese un número y mostrar la suma de los números que lo anteceden. Es decir, si el usuario ingresa 5, que sume 5+4+3+2+1
8. Elabora un programa en consola C#, en donde cuente los multiplos de 3 desde la unidad hasta un número que ingresemos
9. Elabora un programa en consola C#, en donde muestres los números primos del 0 al 100
10. Elabora un programa en consola C#, en donde el usuario ingrese 10 números, sume los positivos y reste los negativos
11. Elabora un programa en consola C#, en donde el usuario ingrese dos números e intercambie sus digitos
12. Elabora un programa en consola C#, en donde muestres las tablas de multiplicar de un número ingresado por el usuario del 1 al 10 y que se visualice:
    • 1x1=1
    • 1x2=2
    • 1x3=3
    • 1x4=4
    • 1x5=5
    • 1x6=6
    • 1x7=7
    • 1x8=8
    • 1x9=9
    • 1x10=10
13. Elabora un programa en consola C#, en donde el usuario ingrese dos números, muestre los números naturales que hay entre ambos empezando por el más pequeño, contar cuántos números hay y cuántos de ellos son pares
14. Elabora un programa en consola C#, en donde el usuario ingrese un número y se muestre la factorial de ese número
15. Elabora un programa en consola C#, en donde se le muestre al usuario las opciones de realizar: a) permutaciones con repetición, b) permutaciones sin repetición, c) combinaciones. El usuario debe proporcionar el total de valores y los grupos a formar

Evaluación

INDICACIONES: Elabora un programa en C# en donde el usuario puede seleccionar uno de los siguientes ejercicios utilizando funciones:

• JUEGO NÚMERO SECRETO: El ordenador elegirá un número al azar entre 1 y 100. El usuario irá introduciendo números por teclado, y el ordenador le irá dando pistas: "mi número es mayor" o "mi número es menor", hasta que el usuario acierte. Entonces el ordenador le felicitará y le comunicará el número de intentos que necesitó para acertar el número secreto.
• AÑOS BISIESTOS: Determinar cuántos años bisiestos existen dentro de un periodo dado por el usuario. Ejemplo: 1999 a 2010 = 3 años bisiestos; un año es bisiesto si es múltiplo de 4 salvo el caso en que sea múltiplo de 100, que no es bisiesto, y no sea múltiplo de 400. Por ejemplo, el año 1900 no fue bisiesto, el año 2000 sí y el 2100 no lo es.
• FECHA DOMINGO DE PASCUA: La fecha de cualquier domingo de pascua se calcula de la siguiente forma: sea X el año para el que se quiere calcular la fecha. Sea A el resto de la división de X entre 19, sea B el resto de la división de X entre 4, sea C el resto de la división de X entre 7, sea D el resto de la división de (19*A+24) entre 30, sea E el resto de la división de (2*B+4*C+6*D+5) entre 7. La fecha para el domingo de pascuales el día (22+D+E) de marzo (observese que puede dar una fecha en mes de abril). Escribir un programa que pida como entrada un año y saque por pantalla la fecha del domingo de pascua para ese año.
• RAÍCES: El programa deberá calcular las raíces, bien reales o imaginarias de una ecuación de segundo grado. El programa también debe ser capaz de operar con valores nulos para el coeficiente de orden dos (es decir, deberá de ser capaz de resolver ecuaciones de primer grado).
• SERIE FIBONACCI: Pedirle al usuario que ingrese un número para calcular la serie fibonacci en donde se suma siempre los últimos dos números de la serie 0,1,1,2,3,5,8,13,21,34..., el programa resolvería (0+1=1 / 1+1=2 / 1+2=3 / 2+3=5 / 3+5=8 / 5+8=13 / 8+13=21 / 13+21=34...), Así sucesivamente, hasta el infinito. Por regla, la sucesión de Fibonacci se escribe así: n = n-1 + n-2. El programa le pedirá al usuario que siga ingresando valores hasta que el usuario indique lo contrario.
• PRESIONAR CUALQUIER OTRA LETRA PARA SALIR