Práctica #6: Estatutos de repetición II

Objetivo

Durante esta actividad, los alumnos serán capaces de:

Resolver diferentes problemas de programación utilizando estatutos for y while en Python.

Instrucciones

NOTA: La siguiente actividad se puede realizar de manera individual o en parejas.

Crea un archivo fuente llamado practica6.py.

Coloca en la parte superior de este archivo el siguiente comentario reemplazando los datos ficticios con tus datos personales (matrícula y nombre):

# Autores: 
#          A01166611 Pepper Pots
#          A01160611 Anthony Stark
#
# Descripción de la práctica.
#
# 27 de septiembre, 2019.

    .
    . (El resto del programa va aquí)
    .

En este mismo archivo escribe en Python las funciones que se describen a continuación. Cada función debe incluir al inicio una cadena de documentación que describa brevemente el comportamiento de la función seguido de todos los casos de prueba indicados en la descripción del problema. Por ejemplo:

def raiz_cuadrada_entera(n):
    """
    Devuelve la raíz cuadrada entera de n.

    >>> raiz_cuadrada_entera(4)
    2
    >>> raiz_cuadrada_entera(20)
    4
    >>> raiz_cuadrada_entera(70)
    8
    >>> raiz_cuadrada_entera(0)
    0
    >>> isinstance(raiz_cuadrada_entera(0), int)
    True
    """
    raiz_cuadrada = n ** 0.5
    truncado = int(raiz_cuadrada)
    return truncado

Coloca al final del archivo y una sola vez el siguiente código con el fin de que las pruebas se ejecuten de manera automática al momento de correr el programa:
```
if __name__ == '__main__':
    import doctest
    print(doctest.testmod())
```

Problemas

Escribe la función duplica que recibe una cadena de caracteres frase como argumento. Devuelve una nueva cadena en la que cada carácter de frase está duplicada. Por ejemplo, si la entrada es 'Hola' la función debe devolver 'HHoollaa'.

Pruebas:

>>> duplica('Hola')
'HHoollaa'
>>> duplica('')
''
>>> duplica('¡Me gusta programar!')
'¡¡MMee  gguussttaa  pprrooggrraammaarr!!'
>>> duplica('ESTO SE ACABÓ')
'EESSTTOO  SSEE  AACCAABBÓÓ'
>>> isinstance(duplica('Hola'), str)
True

Escribe la función periodos que recibe como agumento tres valores numéricos positivos: inicial, objetivo e interes. Devuelve el número de periodos de inversión necesarios para que el saldo inicial crezca a un monto que sea igual o superior al saldo objetivo dada la tasa de interes (5% debe especificarse como 0.05). Aunque esto se puede calcular usando una fórmula de interés compuesto, para este problema debes usar un ciclo while.

Por ejemplo, periodos(200, 250, 0.05) devuelve 5, porque ese es el número de periodos que tomará para llegar a 250 (o más) comenzando con 200 con una tasa de interés del 5%, como se puede observar en la siguiente tabla:

# de periodo	saldo
0	200
1	210
2	220.5
3	231.525
4	243.10125
5	255.2563125

Pruebas:

>>> periodos(200, 250, 0.05)
5
>>> periodos(15000, 14000, 0.07)
0
>>> periodos(15000, 15000, 0.07)
0
>>> periodos(15000, 30000, 0.05)
15
>>> periodos(15000, 30000, 0.07)
11
>>> periodos(15000, 30000, 1.00)
1
>>> isinstance(periodos(200, 250, 0.05), int)
True

Escribe la función codifica que recibe una cadena de caracteres frase como entrada. Devuelve una tupla que contiene el punto de código de Unicode de cada carácter contenido en frase.

NOTA: Utiliza la función ord para obtener el punto de código de un carácter.

Pruebas:
```
>>> codifica('ABC')
(65, 66, 67)
>>> codifica('')
()
>>> codifica('¡Hola, mundo!')
(161, 72, 111, 108, 97, 44, 32, 109, 117, 110, 100, 111, 33)
>>> codifica('EL FIN')
(69, 76, 32, 70, 73, 78)
>>> isinstance(codifica('ABC'), tuple)
True
```
Procusto fue un legendario ladrón de la antigua Ática. Ataba a sus víctimas a una cama de hierro, y si eran más cortas o más largas que la cama, estiraba o cortaba sus extremidades para que encajaran exactamente en ella.

Escribe la función procustea que recibe tres argumentos como entrada: una cadena de caracteres frase, un entero positivo mayor a cero n y una cadena de caracteres no vacía relleno. Devuelve una copia de frase pero conformada exactamente de n caracteres, usando relleno si es necesario para completarla. Esto significa que si frase tiene una longitud mayor que n, la función debe devolver frase truncada a n caracteres. Por otro lado, si la longitud de frase es menor que n, la función debe devolver frase concatenada a relleno repetido tantas veces como sea necesario para producir una cadena resultante con exactamente n caracteres. Por último, si frase tiene una longitud que es igual a n, la función debe devolver frase sin modificaciones.

Pruebas:
```
>>> procustea('Hola', 10, '*')
'Hola******'
>>> procustea('¡Hola, mundo!', 10, '*')
'¡Hola, mun'
>>> procustea('Hola', 4, '*')
'Hola'
>>> procustea('AB', 20, 'rollo')
'ABrollorollorollorol'
>>> isinstance(procustea('Hola', 4, '*'), str)
True
```
Escribe la función sin_vocales que recibe como argumento una cadena de caracteres frase. Devuelve una nueva cadena que contiene exactamente los mismos caracteres contenidos en frase pero sin vocales. Puedes suponer que las vocales no están acentuadas (no tienen tilde), pero sí pueden venir en mayúsculas y/o minúsculas.

Pruebas:
```
>>> sin_vocales('¡Hola!')
'¡Hl!'
>>> sin_vocales('<AEIOUaeiou>')
'<>'
>>> sin_vocales('Esta es una pequeña prueba.')
'st s n pqñ prb.'
>>> sin_vocales('UMPA-LUMPA')
'MP-LMP'
>>> isinstance(sin_vocales('¡Hola!'), str)
True
```
El ADN (ácido desoxirribonucleico) es una doble hélice de dos hebras de nucleótidos. Cada base de nucleótidos puede representarse con una sola letra, por lo que una hebra de nucleótidos puede considerarse como una cadena de caracteres. Aunque el ADN tiene dos hebras, las dos están estrechamente relacionadas: dada una, es fácil calcular la otra. Por lo tanto, el ADN generalmente se describe mediante una cadena de caracteres que representan las bases de nucleótidos de una de sus hebras.

Las cuatro bases que forman el ADN son:
- (A) Adenina
- (C) Citosina
- (G) Guanina
- (T) Timina
La segunda hebra de ADN es siempre el complemento inverso de la primera. El complemento de una hebra de ADN intercambia cada base por su base complementaria:
- A ↔ T
- C ↔ G
El complemento inverso simplemente invierte el orden del complemento. Por ejemplo, el complemento de GATTACA es CTAATGT, y su complemento inverso es TGTAATC.

Escribe la función complemento_inverso_adn que recibe como argumento una cadena de caracteres hebra formado exclusivamente por los caracteres (en mayúsculas o minúsculas): A, C, G y T. Devuelve una cadena de caracteres con el complemento inverso de hebra, todo en mayúsculas.

Pruebas:
```
>>> complemento_inverso_adn('GATTACA')
'TGTAATC'
>>> complemento_inverso_adn('tctgttgagt')
'ACTCAACAGA'
>>> complemento_inverso_adn('TtCcTtaGGtcTCCAgccGc')
'GCGGCTGGAGACCTAAGGAA'
>>> complemento_inverso_adn('')
''
>>> isinstance(complemento_inverso_adn('GATTACA'), str)
True
```

Escribe la función digitos que recibe como argumento un número entero positivo n. Devuelve una tupla conformada por cada uno de los dígitos de n.

Pruebas:

>>> digitos(1729)
(1, 7, 2, 9)
>>> digitos(7)
(7,)
>>> digitos(0)
(0,)
>>> digitos(1234567890)
(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
>>> isinstance(digitos(1), tuple)
True

Escribe la función reduce que recibe como argumento un número entero positivo n. Devuelve la reducción a un solo dígito de n. La reducción consiste en sumar todos los dígitos individuales de n y repetir este proceso hasta obtener un número de un solo dígito. Por ejemplo, la reducción de 897 consiste primero en sumar 8 + 9 + 7 = 24; dado que 24 no es un número de un solo dígito, el proceso debe repetirse: 2 + 4 = 6; dado que 6 es un número de un solo dígito, ese es el resultado que debe devolver la función.

Pruebas:
```
>>> reduce(897)
6
>>> reduce(10000)
1
>>> reduce(9999999999999)
9
>>> reduce(123456789123456789123456789123456789)
9
>>> isinstance(reduce(1), int)
True
```

Escribe la función producto_punto que recibe como argumento dos tuplas de números a y b. Devuelve el resultado de realizar el producto punto de a por b. El producto punto es la suma de los productos de las correspondientes entradas en dos secuencias numéricas del mismo tamaño:

$$ a \cdot b = \sum_{i=0}^{n-1} (a_i \times b_i) = (a_0 \times b_0) + (a_1 \times b_1) + \cdots + (a_{n-1} \times b_{n-1}) $$

Pruebas:

>>> producto_punto((1, 2, 3), (4, 5, 6))
32
>>> producto_punto((), ())
0
>>> producto_punto((1.3, 3.4, 5.7, 9.5, 10.4),
...                (-4.5, 3.0, 1.5, 0.9, 0.0))
21.45
>>> producto_punto((92, -39, 82, 16, -64, -1, -16, -45, -7, 39,
...                 45, 0, 34, -3, -51, 71, 23, -8, 41, -40),
...                (-50, -81, 94, -84, 47, 86, 52, 19, -57, 36,
...                 -20, 11, -42, 48, 14, 13, 9, -67, 92, 96))
357
>>> isinstance(producto_punto((), ()), int)
True

¿Qué se debe entregar?

Todas tus funciones deben estar contenidas en el archivo practica6.py.

Instrucciones para subir archivo

Para entregar el archivo practica6.py, ingresa los siguientes datos:

Solicitar NIP

Si la práctica fue desarrollada por un equipo de dos personas, basta que una persona la entregue.

Fecha límite: Viernes, 4 de octubre.