<jupyter_start><jupyter_text>Simulación de procesos financieros. **Nombres:**  <NAME> |  <NAME> **Fecha:** 17 de febrero del 2021.  **Expediente** :  724055  |  724031**Profesor:** <NAME>. Estudiante 1 |  Estudiante 2  Tarea 3: Clase 6     [link de repositorio GitHub](https://github.com/AndresLaresBarragan/ProyectoConjunto_ALares_FAguilar_Tarea3) > Usando compresión de listas o funciones map(sino recuerda como funciona observar el siguiente enlace https://www.pythonforbeginners.com/lists/list-comprehensions-in-python/), resolver los siguientes ejercicios:>1. Resolver la siguiente ecuación recursiva usando funciones como se vió en clase$$ D_{n}=(n-1) D_{n-1}+(n-1) D_{n-2} \quad n\ge 3$$con $D_1=0$ y $D_2 = 1$>3. Count the number of spaces in the following string `variable =  relaciónn  requiere,  para obtener  el  valor  de un  cierto  término,  el conocimiento de los dos anteriores`.>4. Remove all of the vowels in a string [make a list of the non-vowels].>5. Find all of the words in a string that are less than 4 letters.>6. Use a dictionary comprehension to count the length of each word in a sentence.>7. Use a nested list comprehension to find all of the numbers from 1-1000 that are divisible by any single digit besides 1 (2-9).<jupyter_code># libreria
import numpy as np<jupyter_output><empty_output><jupyter_text>1. Resolver la siguiente ecuación recursiva usando funciones como se vió en clase$$ D_{n}=(n-1) D_{n-1}+(n-1) D_{n-2} \quad n\ge 3$$con $D_1=0$ y $D_2 = 1$  Solución  <NAME><jupyter_code>def solver(n):
    D = np.zeros(n+1)    # se crea un array con la dimension n+1 para regresar un array con el numero de soluciones deseadas.
    D[0] = 0           # D[0] = 0 para que Dn este alineado con el indice del array
    D[1] = 0           # D[1] es el valor de D1
    D[2] = 1           # D[2] es el valor de D2
    
    def generador(i):  # funcion encargada de generar valor Dn.
        nonlocal D
        D[i] = ((i-1)*D[i-1])+((i-1)*D[i-2])
    
    list(map(lambda iterador: generador(iterador), np.arange(3,n+1))) # el rango debe empezar de 3, para que la funcion generador(i) no sobreescriba los valores iniciales.
    soluciones = D[1:] # quitamos la primera observacion D0, para que la lista empieze desde D1.                                         # el rango termina en n+1 para que se genere la cantidad de valores de D deseados.
    return soluciones


solver(6) # primeros 6 valores de Dn.Empezando desde D1.<jupyter_output><empty_output><jupyter_text>Solución  <NAME><jupyter_code>def ecuacion(x):
    a = np.zeros(x+1)
    a[0] = 0
    a[1] = 0
    a[2] = 1
    
    def dn(y):
        nonlocal a
        a[y] = (y-1)*a[y-1]+(y-1)*a[y-2]
        
    list(map(lambda z: dn(z), range(3,x+1)))
    sol = a[1:]
    return sol

ecuacion(10)<jupyter_output><empty_output><jupyter_text>2. Count the number of spaces in the following string:`variable =  relaciónn  requiere,  para obtener  el  valor  de un  cierto  término,  el conocimiento de los dos anteriores`.  Solución  <NAME><jupyter_code>variable_str =  'relaciónn  requiere,  para obtener  el  valor  de un  cierto  término,  el conocimiento de los dos anteriores'

sum([True for i in range(len(variable_str)) if variable_str[i] == ' ' ])<jupyter_output><empty_output><jupyter_text>- accede a cada caracter de la variable string usando un iterador en su índice.- compara si el caracter es igual a un espacio. Regresa **True** si es el caso.- La compresión de lista regresa una lista de **True´s**, se suman con *sum()* para obtener el número de veces que se cumple la condición.  Solución  <NAME><jupyter_code>variable =  "relaciónn  requiere,  para obtener  el  valor  de un  cierto  término,  el conocimiento de los dos anteriores"
variable.count(" ")<jupyter_output><empty_output><jupyter_text>3. Remove all of the vowels in a string(make a list of the non-vowels).  Solución  <NAME><jupyter_code>def non_vowels(string):
    banned = ['a','e','i','o','u','á','é','í','ó','ú','A','E','I','O','U','Á','É','Í','Ó','Ú',' ']    
    return [letra for letra in string if letra not in banned]
non_vowels(variable_str)
non_vowels('aeiou --- AEIOU --- áéíóú --- ÁÉÍÓÚ')<jupyter_output><empty_output><jupyter_text>- En una compresión de listas, accede a cada letra/caracter del string.- Determina si se encuentra en la lista de caracteres prohibidos, en este caso son las vocales.  Solución  <NAME><jupyter_code># Programa para eliminar las vocales del enunciado del ejercicio 2
vowels = 'aeiouAEIOUáéíóúÁÉÍÓÚ'
vocales = [''.join([x for x in variable if x not in vowels])]
vocales
# Programa para eliminar las vocales de cualquier oración que nos den.
given_str = input("Introduce una oración : ")
final_str = [''.join([ch for ch in given_str if ch not in vowels])]

print(final_str)<jupyter_output>Introduce una oración : HOLA MUNDO COMO ESTÁN
['HL MND CM STN']<jupyter_text>4. Find all of the words in a string that are less than 4 letters.  Solución  <NAME><jupyter_code>print(variable_str)

def less_than_4(string):
    return [palabra for palabra in string.split() if len(palabra) < 4 ]
print(less_than_4(variable_str))
less_than_4('Esta es la segunda prueba donde solo las palabras con menos de cuatro letras se imprimen')<jupyter_output>['el', 'de', 'un', 'el', 'de', 'los', 'dos']<jupyter_text>- La funcion toma un string como argumento, y lo separa por palabras.- La lista donde cada elemento es una palabra individual es el iterador. Es decir que cada iteracion sera una palabra.- Se determina si la longitud de la palabra es menor a 4, regresa la palabra si es el caso.  Solución  <NAME><jupyter_code># Programa para encontrar las palabras que tienen menos de 4 letras de la oración del ejercicio 2
filtro = variable
filtro =  list(filter(lambda x: len(x) < 4, filtro.split()))
filtro
# Programa para encontrar las palabras que tienen menos de 4 letras de cualquier oración
palabra = input("Introduce una oración : ")
filtro2 = palabra
filtro2 =  list(filter(lambda x: len(x) < 4, filtro2.split()))
filtro2<jupyter_output>Introduce una oración : hola<jupyter_text>5. Use a dictionary comprehension to count the length of each word in a sentence.  Solución  <NAME><jupyter_code>sample_text = 'Lorem ipsum dolor sit amet consectetur adipiscing elit'

dict_of_lengths = {k:len(k) for k in sentence.split(' ')}
dict_of_lengths<jupyter_output><empty_output><jupyter_text>Solución  <NAME><jupyter_code># Program para contar las letras de cada palabra de la oración del ejercicio 2
dict = variable.split()
dict_comp = [len(x) for x in dict]
dict_comp
# Program para contar las letras de cada palabra de cualquier oración
dict2 = input('Escribe una oración: ').split()
dict_comp2 = [len(x) for x in dict2]
dict_comp2<jupyter_output>Escribe una oración: hola mundo<jupyter_text>6. Use a nested list comprehension to find all of the numbers from 1-1000 that are divisible by any single digit besides 1 (2-9).   Solución  <NAME><jupyter_code>[num for num in range(1,1001) if True in[True for div in range(2,10) if num % div ==0]]<jupyter_output><empty_output><jupyter_text>- La lista externa regresa el valor de *num*, sólo cuando la lista anidada regresa **TRUE**. - La lista anidada regresa **TRUE** si se cumple la condición descrita dentro de ella. - La condición calcula el módulo del valor de *num* entre el valor de *div* y evalúa si es igual a cero (lo cual indica que *num* es par). - *num* es el iterador externo, por lo tanto conserva un mismo valor hasta que el ciclo interno (el de *div*) haya concluído. Una vez que esto suceda, *num* cambia de valor.  Solución  <NAME><jupyter_code>numeros = [n for n in range(1,1001) if True in (True for div in range(2,10) if n % div == 0)]
numeros<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10516772438803264, 'fraction_numerical': 0.0198160859992229, 'mean_word_length': 4.27098976109215, 'pattern_counts': {'":': 0, '<': 67, '<?xml version=': 0, '>': 71, 'https://': 2, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '13', 'dir': 'jupyter-structured-clean-dedup', 'id': '343123', 'license': 'MIT', 'n_tokens_mistral': 2854, 'n_tokens_neox': 2785, 'n_words': 975, 'path': 'ProyectoConjunto_ALares_FAguilar_Tarea3.ipynb', 'repo_name': 'AndresLaresBarragan/ProyectoConjunto_ALares_FAguilar_Tarea3', 'size': '7928'}