Ejercicios de programación 1. Números triangulares

Los números triangulares son aquellos que se pueden escribir como la suma de una serie consecutiva de números empezando por 1. Así 6 es triangular porque es la suma de los primeros tres números: 6 = 1 +2 + 3. Una fórmula para calcular el enésimo número triangular tn es:

o

El nombre se debe a que un número triangular puede recomponerse en la forma de un triángulo equilátero:

Se pide desarrollar un programa que calcule con la primera fórmula el n-ésimo número triangular que se indica por el usuario y el tiempo que tarda en calcularlo. numerotriangular.py

2. Factores propios Desarrollar un programa que imprima los factores propios y su número, de un número especificado por el usuario. factorespropios.py

3. Números deficientes, abundantes, perfectos Si las sumas de los factores propios de un número es menor a n se le llama deficiente. Si la suma es mayor que n se le llama abundante. Si la suma es igual a n se le llama perfecto. Desarrollar un programa que lea un número y determine si es deficiente, abundante o perfecto. defabunperf.py

4. Lista de primos. Criba de Eratostenes Programa que imprime todos los primos menores a un número primos.py

5. Serie de Fibonacci La serie de Fibonacci responde a la siguiente ecuación recurrente: Fn = Fn-1 + Fn-2 con los valores iniciales F0 = 0 and F1 = 1.

Desarrollar un programa que imprima la serie de Fibonacci hasta el n término especificado por el usuario.

6. Máximo común divisor Dados dos números a y b, se llama d el máximo común divisor de a y b si: 1. d divide a a (d|a) y d|b 2. d es el mayor número que divide tanto a a y b. mcd_i.py

7. Descomposición en factores primos de un número Desarrollar un programa que lea un número natural e imprima los factores primos del número. primefactors.py

8. Factores de un número y función tau Los factores de un número natural n son aquellos números divisores de n (incluye 1 y n). La función tau es aquella que cuenta cuántos divisores tiene n. Desarrollar un programa que lea un número natural e imprima sus divisores y la función tau. divisores_tau.py

9. Números amigos Dos números son amigos si cada uno de ellos es igual a la suma de los divisores del otro. Por ejemplo 220 y 284 (amigos más pequeños). Desarrollar un programa que imprima todas las parejas de números amigos inferiores a un número dado. num_amigos.py

10. Números felices Un número feliz es aquel que, al sumar los cuadrados de sus dígitos (recursivamente), da como resultado final el número 1. num_felices.py

11. Triángulo de Pascal

Programa que imprima el triángulo de Pascal hasta un determinado nivel que se pide al usuario. El primer nivel se considera 0.

El triángulo de Pascal es una representación de los coeficientes binomiales ordenados en forma de triángulo. Se construye siguiendo un patrón como el que se muestra en la figura. Se comienza desde la cúspide con el número 1 hacia abajo(infinito), a modo de "árbol"; se clasifica en filas, empezando por la fila cero (el 1 de la cúspide). Los nodos del árbol son cada número que compone el triángulo. La suma de dos nodos produce como resultado el nodo situado debajo de estos dos, y así sucesivamente. Las diagonales que empiezan desde la raíz (1) o cabeza del triángulo valen siempre 1.

triangPascal.py

12. Triángulo de pascal Existe una estrecha relación entre el triángulo de Pascal y los coeficientes del binomio de Newton (x + y)n. Se demuestra que:

Así los coeficientes hasta el nivel 6 se obtienen según la siguiente figura:

Se pide desarrollar un programa que calcule el triángulo de Pascal según la formulación combinatoria. triangPascalcomb.py

13. Números Catalan En matemática combinatoria, los números Catalan forman una secuencia de números naturales que ocurren en varios problemas de conteo. Una formulación del enésimo número Catalan se deriva de los coeficientes binomiales:

Desarrollar un programa que imprima los primeros n números Catalan. numeroCatalan.py

14. Epsilon de la máquina

En aritmética de coma flotante, se llama épsilon de la máquina (ε-mach) al menor valor de una determinada máquina que cumple lo siguiente: 1.0 + εm-mach > 1.0 por tanto, el épsilon es el número decimal más pequeño que, sumado a 1, la computadora nos arroja un valor diferente de 1, es decir, que no es redondeado. Representa la exactitud relativa de la aritmética del computador. La existencia del épsilon de la máquina es una consecuencia de la precisión finita de la aritmética en coma flotante.(Fuente: Wikipedia)

Desarrollar un programa para calcular el épsilon de la máquina y compararlo con el valor contenido en sys.float_info.epsilon. epsilon.py

15. Algoritmo de suma de Kahan (suma compensada) El pseudocódigo del algoritmo es: function KahanSum(input) // Prepare the accumulator

var sum = 0.0 // A running compensation for lost low-order bits. var c = 0.0 // The array input has elements indexed input[1] to input[input.length]. for i = 1 to input.length do // c is zero the first time around. var y = input[i] - c // Alas, sum is big, y small, so low-order digits of y are lost. var t = sum + y // (t - sum) cancels the high-order part of y; // subtracting y recovers negative (low part of y) c = (t - sum) - y // Algebraically, c should always be zero. sum = t // Next time around, the lost low part will be added to y. next i

return sum Desarrollar un programa con el algoritmo de Kahan para la suma de valores de una lista y compararlo con la suma aritmética normal. kahansum.py

16. Evaluación simple Evaluar f(x) = 1

√𝑥𝑥2+1 − 1

para valores de x = 10i donde { i ϵ Ν / 4 ≤ i ≤ 7}. Imprimir x y f(x) naiveval.py

17. Exponencial Desarrollar un programa para calcular la función exponencial:

evaluada para valores de x = 0.1, 20. −20. El número de términos n se incrementará hasta que suman ≠ suman-1 . Se imprimirá el número de término, el valor de exp (suman), y el valor del término añadido. Se comparará con el valor devuelto por la función exp de la librería math. compexp.py

18. Cancelación Calcular

𝑒𝑒𝑥𝑥−1𝑥𝑥

considerando valores de x 10-i con i [14, 15, 16] y −10-i con i [15, 16, 17]. Considerar una evaluación directa y otra que tenga en cuenta las singularidades.

exp(x)

cancel.py 19. Derivadas

Programa para calcular la derivada de 𝑒𝑒𝑠𝑠𝑠𝑠𝑠𝑠(2𝑥𝑥) para x = 0.5 considerando los métodos de cálculo en adelanto y central para pasos h = 10-i en un rango de i entre 1 y 11. Imprimir para cada paso el error absoluto con el valor real y analizar el valor de h que menor error produce. finitediff.py

20. Derivada por Richardson

Programa para calcular la derivada de 𝑒𝑒𝑠𝑠𝑠𝑠𝑠𝑠(2𝑥𝑥) para x = 0.5 considerando el método Richardson aplicado al cálculo en adelanto y central para pasos h = 10-i en un rango de i entre 1 y 6. Imprimir para cada paso el error absoluto con el valor real y analizar el valor de h que menor error produce. richardsondiff.py

21. Programa que imprime el día de la semana para una fecha (dia, mes, año) dada, que se ingresa desde la línea de comando. Las fórmulas para determinar el día de la semana son: y0 = y - (14 - m) / 12 x = y0 + y0/4 - y0/100 + y0/400 m0 = m + 12 * ((14 - m) / 12) - 2 d0 = (d + x + (31*m0) / 12) mod 7 El resultado d0 indica 0 para Domingo, 1 Lunes, …

22. Programa que determina si un año es bisiesto. (Definición de año bisiesto: Un año es

bisiesto si es divisible por 4, excluyendo al que es divisible por 100, pero no si es divisible por 400). Determinar los años bisiestos en el rango de 1800 – 2200.

23. Programa que calcule el índice de masa corporal (IMC) de una persona:

IMC =𝑝𝑝𝑒𝑒𝑝𝑝𝑝𝑝 (𝑘𝑘𝑘𝑘)

𝑒𝑒𝑝𝑝𝑒𝑒𝑒𝑒𝑒𝑒𝑒𝑒𝑒𝑒𝑒𝑒2(𝑚𝑚)

Un IMC por debajo de 18,5 indica desnutrición o algún problema de salud, mientras que un IMC superior a 25 indica sobrepeso. Por encima de 30 hay obesidad leve, y por encima de 40 hay obesidad elevada que necesita seguimiento médico continuo. El programa repite la lectura hasta que el usuario detenga la ejecución.

24. Dado un entero positivo, calcular su factorial de forma iterativa.

25. Programa y resultados de ejecución para obtener la tabla de verdad de los siguientes

circuitos lógicos combinacionales: ABCD + A!B!C + B!C!D AB + CD + ABC + BCD

26. Programa para el cambio de base de un número en decimal a otra base (2 -16) especificada por el usuario. El programa repite la lectura hasta que el usuario detenga la ejecución.

27. Calcular las raíces de la ecuación de segundo grado 02 =++ CxBxA , para cualquier valor de los coeficientes A, B y C.

Probar con los siguientes datos: A = 4 B = 3 C = 2 A = 1 B = 9 C = 4 A = 1 10-2 B = 1 107 C = 1 10-2 (analizar la respuesta)

28. En el circuito serie RLC de la Figura, el generador de tensión tiene un valor instantáneo dado por la expresión: u(t)=√2 50 cos 100t voltios. Calcular: a) intensidad compleja e instantánea b) potencia instantánea desarrollada por el generador c) potencia compleja entregada por el generador d) potencia compleja de cada elemento pasivo;

29. Coordenadas polares: Desarrollar un programa que convierta coordenadas cartesianas a

polares. El programa debe aceptar dos flotantes en la línea de comandos e imprimir las coordenadas polares r y θ. Usar la función Python math.atan2(y,x) que calcula el arco tangente de y/x que está en el rango de –π a π.

30. Error absoluto, relativo, aproximado La exactitud (accuracy) se refiere a la proximidad de un valor calculado o medido respecto del valor verdadero. La precisión (precision) se refiere a la proximidad de un valor individual calculado o medido respecto de otros.

a) inaccurate and imprecise b) accurate and imprecise c) inaccurate and precise d) accurate and precise

True error (Et): the difference between the true value in a calculation and the approximate value found using a numerical method etc.

True Error (Et)= True Value – Approximate Value Absolute error (|Et|): the absolute difference between the true value and the approximation. Relative true error: the true error divided by the true value. Relative True Error ( ) = Relative error (et): the relative true error expressed as a percentage. What can be done if true values are not known or are very difficult to obtain? If this is the case, approximations can be made to the error. Approximate error is defined as

the difference between the present approximation and the previous approximation. Approximate Error (Ea)= Present appr. – Previous appr.

True Error True Value

Según lo anterior, calcular el valor de las siguientes funciones evaluando su expansión en serie para un número determinado de términos:

....!8!6!4!2

1)cos(8642 xxxxx +−+−=

+−+−=!7!5!3

)sin(753 xxxxx

Calcular también el error verdadero, relativo y el error aproximado relativo con respecto al valor de la función respectiva en el módulo math.

31. Error de truncamiento y redondeo Round off errors arise because digital computers cannot represent some quantities exactly. Caused by representing a number approximately.

There are two major facets of round off errors involved in numerical calculations: - Digital computers have size and precision limits on their ability to represent numbers. - Certain numerical manipulations are highly sensitive to round off errors.

Truncation errors are caused by truncating or approximating a mathematical procedure. En Python los números en punto flotante se representan usando 64 bits en total siguiendo el estándar IEEE754 binary64 con tres componentes:

La precisión de un número en punto flotante de 64 bits es aproximadamente de 16 dígitos decimales. Límites de los números (sys.float_info): Largest number: 1.7976931348623157x10+308 Minimal positive number: 2.2250738585072014x10–308 Machine epsilon: 2.220446049250313x10–16 Cálculo de PI (π) mediante la aproximación de un círculo por polígonos (método de Liu Hui):

Después de varias iteraciones:

𝜋𝜋 ≈𝑆𝑆 ∙ 𝑁𝑁𝑠𝑠𝑠𝑠𝑠𝑠𝑒𝑒𝑠𝑠

2

Desarrollar un programa iterativo que imprima: el número y longitud de los lados (considerando valores iniciales: n= 6, s=1),

el valor de pi calculado según la formulación anterior y el error absoluto entre el valor “verdadero” (math.pi) y el calculado considerando que en cada iteración se dobla el número de lados hasta un valor dado de iteraciones. Comprobar la evolución del error variando el número de iteraciones (20, 25, 30). Analizar los resultados y explicarlos.

import math nsides = 6 length = 1. for i in range(20): length = (2. - (4. - length**2)**0.5)**0.5 nsides *= 2 pi = length*nsides/2. print('-'*30) print('Polygon of',nsides,'slides:') print('pi(calc) = %.15f' % pi) print('diff = %.15f' % abs(math.pi-pi))

Analysis: Go back to the recursive formula:

S is actually a very small number! When we do the calculation, we have to worry about the finite accuracy of the float point number.

Cálculo de PI (π) mediante la Fórmula de Leibniz A partir de la función trigonométrica:

Desarrollar un programa que calcule pi utilizando la serie anterior para 1000, 100000, 1000000 términos: • calcule pi según la serie, • imprima cada 100 términos el valor del término, el valor pi calculado según la formulación

anterior y • el error absoluto entre el valor “verdadero” (math.pi) y el calculado Comprobar la evolución del error. Analizar los resultados y explicarlos

import math pi = 0. numerator = 1. for n in range(1001): pi += numerator/(2.*n+1.)*4. numerator = -numerator if n%100 == 0: print('-'*30) print('Sum up to',n,'step:') print('pi(calc) = %.15f' % pi) print('diff = %.15f' % abs(math.pi-pi))

Después de N iteraciones: Los errores de aproximación o truncamiento se reducirán (por ejemplo, más términos en la expansión de Taylor) según

donde α y β son dependientes del algoritmo Los errores de redondeo (roundoff) van en dirección opuesta, es decir, a más iteraciones el error se acumula

donde εm es la precisión dependiente de la máquina El error total es:

Para el ejercicio de cálculo de π con la fórmula de Leibniz para π/4: α ≈ 1y β ≈ 1 (cada 10 pasos se mejora el cálculo en 1 dígito). Si se realiza el cálculo en doble precisión, se puede obtener el error total mínimo:

para (cálculo grueso) Calcular la derivada de la función:

para h →0 para el valor 0.5, usando la fórmula: utilizar como valor inicial de h = 1E-2 y dividirlo por 10 en cada iteración mientras h > 1E-15. Imprimir el valor exacto y para cada iteración: el valor de h, el valor numérico y el valor absoluto de la diferencia. Es fácil comprobar que el valor exacto de la derivada es:

Analizar los resultados. Nota: Para un valor pequeño h, la expansión de Taylor es:

A partir de la cual se obtiene la formula de la derivada aproximada:

Es decir, se tiene un error de truncamiento (aproximación) de O(h), pero hay un error de redondeo relacionado con la precisión de la máquina:

Si se tiene en cuenta en la derivación numérica:

El error total es: Para un número en doble precisión: Por lo que el valor de h para que el error total se minimice:

import math def f(x): return x**2+math.exp(x)+math.log(x)+math.sin(x) def fp(x): return 2.*x+math.exp(x)+1./x+math.cos(x) x, h = 0.5, 1E-2 fp_exact = fp(x) print('Exacto = %.16f\n' % fp_exact) print ('\th \t Numerico \t diff') while h>1E-15: fp_numeric = (f(x+h) - f(x))/h print('%e, ' % h, end=' ') print('%.16f, ' % fp_numeric, end=' ') print('%.16f' % abs(fp_numeric-fp_exact)) h /= 10.

32. Interpolación de Lagrange

Desarrollar un programa que calcule la interpolación de Lagrange: para interpolar una serie de N puntos (xi, yi) dados como datos, se hace pasar un polinomio por tales puntos. La solución clásica es usar la fórmula de Lagrange que expresada matemáticamente es:

∑ ∏≤≤

≠≤≤ −

−=

Njj

jiNi ij

i yxxxx

xp1 1

)()(

Los datos del programa son: - Número de puntos N, que a su vez es el número de términos del polinomio. - Puntos a interpolar (x1, y1), (x2, y2),....,(xN, yN). - Valor x a interpolar. El resultado es el cálculo de la interpolación según la fórmula anterior. El programa repite la lectura del valor a interpolar hasta que el usuario detenga la ejecución.

33. Multiplicación matricial Escribir un programa para calcular el producto matricial de dos matrices (MxN y NxP). Se recuerda que cada elemento Ci,j de la matriz resultante se calcula aplicando la siguiente fórmula:

∑=

⋅=N

kjkBkiAjiC

1),(),(),(

34. Algoritmo de Floyd-Warshall – Caminos más cortos para todos los pares de vértices de un grafo Un grafo G = (V, E) está compuesto de: V: conjunto de vértices o nodos E: conjunto de aristas o arcos que conectan los vértices en V Una arista e = (v, w) es un par de vértices. Una Arista dirigida es un par ordenado (u, v) Un camino es una secuencia de vértices <v1, v2,..., vn> tal que (vi, vi+1) son adyacentes. Matriz de Adyacencia: Matriz M[i][j] con entradas para todos los pares de vértices. En grafos con pesos:

• M[i][j] = costo o peso, si hay una arista (i, j) en el grafo. • M[i][j] = infinito, si no hay una arista (i, j) en el grafo.

El costo de un camino es la suma de los costos de las aristas del camino. Un problema muy común es el de hallar el costo y el camino mínimo entre cualquier par de nodos de un grafo. Una forma de resolverlo es utilizando el algoritmo de Floyd-Warshall: • Utiliza una matriz Ak[i][j], que contiene el costo del camino más corto que pasa por los

primeros k primeros vértices. Otra matriz pathk[i][j], contiene el nodo del camino más corto que pasa por los primeros k primeros vértices

• Inicialmente Ak[i][j] = C[i][j] ∀ i ≠ j. Si no hay arista de i a j C[i][j] = ∞ y los elementos diagonales se ponen a 0. La matriz path[i][j] se inicializa con los nodos finales de las aristas cuyo costo es diferente de ∞.

• En la iteración k (nodo k como pivote) se calcula, para cada camino de v a w, si es más corto pasando por k aplicando la condición de relajación: Ak[i][j] = min (Ak-1[i][j] , Ak-1[i][k] + Ak-1[k][j] ), ∀ i ≠ j. y se registra el nodo intermedio en path: pathk[i][j] = pathk[i][k] En pseudocódigo:

FloydWarshall (n, C, A) # n = número de vértices, C = matriz de costo { # A = matriz resultado de costo for i in range(n): for j in range(n): if i ≠ j: A[i][j] = C[i][j] else A[i][j] = 0 for i in range(n): for j in range(n): if i == j or graph[i][j] <> ∞: path[i][j] = j for k in range(n): for i in range(n): for j in range(n): if (A[i][k] + A[k][j] < A[i][j]) A[i][j] = A[i][k] + A[k][j] path[i][j] = path[i][k] }

• Como no varía la fila y la columna k en la iteración k, sólo es necesario una matriz A. • El camino más corto entre los nodos se puede obtener con el siguiente algoritmo:

imprime_path (n, path) # n = número de vértices, { # path = matriz de nodos de los caminos de menos peso for i in range(n): for j in range(n): if path[i][j] <> ø and i <> j: cam = [i] # lista de nodos del camino tmp = i while tmp <> j: tmp = path[tmp][j] cam.append( it ) print(cam) }

Desarrollar un programa que calcule la matriz y los caminos de costo mínimo entre todos los pares de vértices de un grafo dirigido.