El método numérico llamado método de la trisección no existe, sin embargo, resulta en un práctica interesante de programación.

La única diferencia entre el método de la bisección y el de la trisección es que, en este último, el intervalo de búsqueda de la raíz se divide en tres parte iguales.

La definición completa del examen se encuentra en https://www.scribd.com/doc/306301095/Ejercicios-Basicos-de-Programacion

Una posible solución

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu May 20 19:36:44 2021
Me tomó 27 minutos resolver
27*3 + 15 min. para leer el texto = 96 min.
96 min. + 5 min. para subir a evirtual = 101 min.
@author: Angel Vázquez-Patiño
"""
from math import factorial

def seno(x):
    suma = 0
    for i in range(50):
        numerador = ((-1)**i)*(x**(2*i+1))
        denominador = factorial(2*i+1)
        suma += numerador/denominador
    return suma

def f(x):
    return seno(2*x+1)-(3/5)*x+1

def triseccion(f, a, b):
    aproximaciones = [(a+b)/2]
    e_a = 1 # para que entre al menos una vez al while
    while e_a > 0.000001:
        mi = a + (b-a)/3
        md = (mi + b)/2
        
        if f(a)*f(mi) < 0:
            aproximaciones.append((a+mi)/2)
            b = mi
        elif f(mi)*f(md) < 0:
            aproximaciones.append((mi+md)/2)
            a, b = mi, md
        elif f(md)*f(b) < 0:
            aproximaciones.append((md+b)/2)
            a = md
        elif f(mi) == 0:
            aproximaciones.append(mi)
            return aproximaciones
        elif f(md) == 0:
            aproximaciones.append(md)
            return aproximaciones
        
        e_a = abs((aproximaciones[-1]-aproximaciones[-2])/aproximaciones[-1])
    return aproximaciones

def grabar(lista, path):
    with open(path, 'w') as f:
        f.write('Aproximación, Valor\n')
        for i in range(len(lista)):
            f.write(str(i)+','+str(lista[i])+'\n')
a, b = -19, 3.5          
aproxs = triseccion(f, -19, 3.5)
grabar(aproxs, 'interciclo_resultados.csv')
# FIN de esta posible solución del examen (hay muchas otras formas de resolverlo)

# De aquí en adelante no es parte del examen
import numpy as np # Esto no he utilizado en la solución en sí del examen
from matplotlib import pyplot as plt # Esto no he utilizado en la solución en sí del examen
xs = np.linspace(a, b, 100)
ys = [seno(2*i+1)-3*i/5+1 for i in xs]
ys = np.array(ys)

plt.figure(figsize=(4,3))
plt.plot(xs, ys, label='$f(x)$', lw=2)
plt.scatter([1.21], [0], label='raíz', color='k')
plt.axhline(0, color='gray')
plt.axvline(0, color='gray')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.show()

Prueba dos de la materia de Programación Orientada al Cálculo Científico del semestre marzo - agosto 2021. Tomado el día jueves 20 de mayo de 2021.

Planteamiento

El juego comienza generando una letra del alfabeto (incluyendo la letra ñ) de manera aleatoria (0.5 puntos). Con esa primera letra, el jugador 1 debe escribir una palabra. El jugador 2 debe escribir una siguiente palabra que comience con la letra con la que termina la palabra del jugador 1. Esa palabra debe ser una que no haya sido escrita antes por ningún jugador. De la misma manera, el jugador 1 debe escribir una nueva palabra que comience con la última letra de la última palabra escrita por el jugador 2. Esa palabra debe ser una que no haya sido escrita antes por ningún jugador. Se repite estos pasos hasta que termine el juego (1 punto). El juego termina cuando los dos jugadores, de manera sucesiva, no son capaces de escribir palabras diferentes (i.e., que no hayan sido ingresadas antes por cualquiera de los dos jugadores) o siguiendo la regla del juego (e.g., cuando el jugador escribe una palabra que no comienza con la última letra de la última palabra escrita) (1.5 puntos). Un jugador tiene la posibilidad de indicar que no puede escribir una palabra válida presionando la tecla Enter sin antes escribir ningún carácter; cuando en dos jugadas sucesivas se presiona Enter, se termina el juego (0.5 puntos). Gana el juego la persona que haya escrito el mayor número de caracteres (se suma la cantidad de caracteres de todas las palabras ingresadas por cada jugador); se lo debe indicar cuando termina el juego (0.5 puntos). Al finalizar el juego, todas las palabras (una palabra es una cadena de al menos un carácter) diferentes ingresadas por los jugadores deben ser escritas en un archivo junto con el puntaje de cada jugador (1 punto).

Si usa Python, la siguiente línea de código le ayuda a generar las letras del abecedario: import string; print(string.ascii_lowercase).

Ejemplos de la ejecución del juego se muestran en el documento Ejercicios Básicos de Programación.

Una posible solución

import string
from random import choice

def letra():
    letras = list(string.ascii_lowercase)
    letras.append('ñ')
    return choice(letras)

palabras1 = [] # palabras del jugador 1
palabras2 = [] # palabras del jugador 2

ultima_letra = letra()
palabras_repetidas = 0 # permite terminar el juego
palabras_que_comienzan_mal = 0 # permite terminar el juego
enters = 0 # permite terminar el juego
jugador = 1 # la uso como bandera
print(ultima_letra)
while palabras_repetidas < 2 and palabras_que_comienzan_mal < 2 and enters < 2:
    palabra = input('Jugador '+str(jugador)+': ')
    if palabra in palabras1 or palabra in palabras2:
        palabras_repetidas += 1
    else:
        palabras_repetidas = 0
    if palabra != '':
        if palabra[0] != ultima_letra:
            palabras_que_comienzan_mal += 1
        else:
            palabras_que_comienzan_mal = 0
    
    if palabra == '':
        enters += 1
    else:
        enters = 0
    if (not palabra in palabras1) and palabra != '' and palabra[0] == ultima_letra:
        if jugador == 1:
            palabras1.append(palabra)
        else: # cuando jugador es igual a 2
            palabras2.append(palabra)
            
    if palabra != '':
        ultima_letra = palabra[-1]
    
    if jugador == 1: # uso de la estrategia de bandera
        jugador = 2  # para cambiar de jugador en cada iteración
    else:
        jugador = 1

print('\nPalabras repetidas sucesivas:', palabras_repetidas)
print('Palabras sucesivas con primera letra incorrecta:', palabras_que_comienzan_mal)
print('\"Enters\" sucesivos:', enters, end='\n\n')

puntaje1, puntaje2 = 0, 0 # puntajes para los jugadores

for elemento in palabras1:
    puntaje1 += len(elemento)
for elemento in palabras2:
    puntaje2 += len(elemento)

if puntaje1 > puntaje2:
    print('¡Ganó jugador 1!')
elif puntaje2 > puntaje1:
    print('¡Ganó jugador 2!')
else:
    print('¡Hubo empate!')

print('\tJugador 1:', puntaje1, 'puntos.')
print('\tJugador 2:', puntaje2, 'puntos.')

with open('prueba2.csv', 'w') as f:
    f.write('Jugador 1, Jugador 2\n')
    longitud = max(len(palabras1), len(palabras2))
    for i in range(longitud):
        
        if not(i >= len(palabras1)):
            f.write(palabras1[i]+',')
        else:
            f.write(',')
        if not(i >= len(palabras2)):
            f.write(palabras2[i]+'\n')
        else:
            f.write(',\n')

Planteamiento

1. Lea CON PANDAS el archivo predictores_estacionarios_luego_de_mutual_info_regression.csv (3 puntos). La primera columna en el archivo es el índice (que es una fecha) que debe usar para el DataFrame 1 de pandas (4 puntos).
2. Para cada columna del DataFrame 1 de Pandas que contenga la información del archivo (no el índice del DataFrame), ajuste una recta. De cada recta ajustada a los datos, de cada columna del DataFrame 1, tome el valor de la pendiente. (8 puntos)
3. Genere un nuevo DataFrame 2 de Pandas que contenga las mismas columnas que el DataFrame 1 referido en el punto 1 y 2 (4 puntos). En la única fila que va a tener este nuevo DataFrame 2, debe poner las pendientes que calculó en el punto 2. Es decir, en cada columna debe estar la pendiente correspondiente a la recta ajustada a los datos de las columnas correspondientes del DataFrame 1 (4 puntos).
4. Guarde el nuevo DataFrame 2 de Pandas referido en el punto 3 como archivo csv (ponga el nombre que quiera al archivo) (3 puntos). El archivo csv no debe ser guardado con el índice que tiene el DataFrame (4 puntos).
5. Suba a EVIRTUAL solamente el archivo .py de su script. Debe subir un (1) script. Puede subir hasta las 09h00. Solamente calificaré lo que suba a EVIRTUAL.
   

Nota: La información del DataFrame 2 debe ser guardado utilizando Pandas.

Solución

import pandas as pd
from scipy.optimize import curve_fit

def f(x, m, a):
    ''' Función que evalua una función que es un polinomio de primer grado.
    x: valor de la abscisa
    m: valor de la pendiente
    a: valor del intercepto
    '''
    return m*x + a

# index_col = 0 indica que la primera columna del archivo se usará como índice
df1 = pd.read_csv('predictores_estacionarios_luego_de_mutual_info_regression.csv',
                  index_col=0)

df2 = pd.DataFrame(columns=df1.columns, index=['Pendiente'])

for columna in df1.columns:
    # línea que permite verificar resultados
    print('Columna', columna)
    parametros, _ = curve_fit(f, range(len(df1[columna])), df1[columna])
    # línea que permite verificar resultados
    print('\tPendiente: {0}\n\tIntercepto: {1}'.format(parametros[0], parametros[1]))
    df2[columna] = parametros[0]
    
# index=False indica que no se guardará el índice en el archivo csv
df2.to_csv('pendientes.csv', index=False)