MAESTRÍA EN ANÁLISIS ESTADÍSTICO Y COMPUTACIÓN

Curso: Programación

Actividad: Tarea 1

Fecha de entrega: Sábado 18 de Febrero de 2023, 23:59 hrs

Alumno: Jesús Germán Galdámez Ovando

Ejercicio 1
Escribe una función en python que revierta una cadena de palabras.

Entrada: "Maestría de Análisis Estadístico y Computación"

Salida "Computación Y Estadístico Análisis de Maestría

In [2]: # código
def Reverse(x):
palabra=x.split() #Separar la cadena de texto en palabras con la función "split()"
reverse=palabra[::-1] #Se crea una lista con las palabras al reverso
reverse_texto=" ".join(reverse) #se concatenan las palabras hasta formar de nuevo el
return(reverse_texto) #Regrea el texto al reverso

#Se ejecuta la función "Reverse()"

Reverse("Maestría de Análisis Estadístico y Computación")

'Computación y Estadístico Análisis de Maestría'

Out[2]:

Ejercicio 2
Escribe una función en python que encuentre un par de elementos (índice de los números) de
una matriz dada cuya suma es igual a un número de destino específico.

Entrada: L=[10,20,40,30,80,60], objetivo=60

Salida 1,2

In [3]: def Get_index(s,suma): 1.1

n=len(s) #número de datos en la lista
count = 0 # Inicia el incremento
#se forman las combinaciones de pares.solo el que cumpla con el objetivo se almace
for i in range(0, n):
for j in range(i + 1, n):
if s[i] + s[j] == suma:
posciones = str(s.index(s[i])) + " " + str(s.index(s[j])) #se concatena
count += 1
return posciones
 Lista = [10,20,40,30,80,60]
Obj = 60
Get_index(Lista,60)

'1 2'
Out[3]:

Ejercicio 3
Dada una lista de números L=[$x_0$,...,$x_{n-1}$]. Implemente una función en Python que
devuelva la media y la varianza, es decir

La media $$ \bar{x}=\frac{1}{n} \sum_{i=1}^n x_i $$

La varianza $$ \operatorname{Var}(x)=\frac{1}{n} \sum_{i=1}^n\left(x_i-\bar{x}\right)^2 $$
En el caso de la varianza puede usar el algoritmo en dos pasos (two-pass algorithm), es
decir, usando directamente la formula anterior, o el algoritmo en un paso (one-pass
algorithm), ie, usando la siguiente formula

$$\operatorname{Var}(x)=\left(\frac{1}{n} \sum_{i=1}^n x_i^2\right)-\bar{x}^2$$

Entrada: [1,2,3,4,5,6,7,8,9,10]

In [7]: #------------------------------------------------------------------------
#a) La media
#------------------------------------------------------------------------
def media(datos):
n=len(datos) #Número de datos
return(sum(datos)/n) #Promedio

datos=[1,2,3,4,5,6,7,8,9,10]
media(datos)

5.5
Out[7]:

In [8]: #------------------------------------------------------------------------
#b) La varianza: two-pass algorithm
#------------------------------------------------------------------------
def var_two_pass(num):
n=len(num) #Número de datos
media=sum(num)/n #promedio
var_des =[((i-media)**2) for i in num] #Cálculo de la desviación estandar
varianza=sum(var_des)/n #Cálculo de la varianza sumando la desviació y dividirlo p
return varianza

datos=[1,2,3,4,5,6,7,8,9,10]
var_two_pass(datos)

8.25
Out[8]:

In [9]: #------------------------------------------------------------------------
#b) La varianza: one-pass algorithm
#------------------------------------------------------------------------
def var_one_pass(num):
n=len(num) #Número de datos
 media=sum(num)/n #promedio
var=0
for i in num:
var+= (i**2)/n #La sumatoria de los datos al cuadrado, dividido entre el número de
varianza=var-media**2 #Cálculo de la varianza
return varianza

datos=[1,2,3,4,5,6,7,8,9,10]
var_one_pass(datos)

8.25
Out[9]:

Ejercicio 4
Escribir una función en python para encontrar la validez de una cadena de paréntesis, '(', ')', '[',
']', '{', '}'. Los paréntesis de abrir y cerrar deben aparecer en el orden correcto. Por ejemplo:

Válidos: $'()'$, $'([])'$, $'([{}]()([]))'$

No válidos: $')'$, $')))'$, $'(])'$, $'([{}])))'$

In [2]: def Verificar(s):

abre = ["[","{","("] #Los simbolos que abren
cierra = ["]","}",")"] #Los simbolos que cierran
stack = []
for i in s:
if i in abre:
stack.append(i) #Se almacenaran los simbolos que estan en la lista y que a
elif i in cierra:
#print(i)
pos = cierra.index(i) #La posición de los simbolos que cierran
if ((len(stack) > 0) and (abre[pos] == stack[len(stack)-1])):
stack.pop()
#print(stack)
else:
return "No es válido"
if len(stack) == 0:
return "Es válido"
else:
return "No es válido"
# Driver code
lista = "([{}]()([])"
print(lista,"-", Verificar(lista))

lista = "([{}])))"
print(lista,"-", Verificar(lista))

([{}]()([]) - No es válido
([{}]))) - No es válido

Ejercicio 5
 Escribe una función en python que traduzca un texto a Pig Latin. Las reglas utilizadas para el Pig
Latin son las siguientes (nota: existen otras variantes, https://en.wikipedia.org/wiki/Pig_Latin):

Si una palabra comienza con una vocal, agregar "ay" al final. Por ejemplo, "escribe" se
traduce por "escribeay".
Si comienza con una o mas consonantes, entonces tomamos todas las consonantes antes
de la primera vocal y las colocamos al final de la palabra y luego se agrega "ay" al final. Por
ejemplo, "principal" se traduce como "incipalpray".

Entrada: "el principio de arquimedes"

Salida: "elay incipiopray eday arquimedesay"

Ejemplo de traductor: https://lingojam.com/PigLatinTranslator

En esta parte, creo la función Pig_Latin(), para cuando se le dá una palabra

In [10]: def Pig_Latin(s):

inicio_palabra = "" #Objeto vacio para ir almacenando las letas antes de la vocal
index = 0
vocal=['a','e','i','o','u'] #lista de vocal
muda=(" ".join("h"+str(i) for i in vocal)) #union de consonate muda y vocal
vocal_muda=vocal+muda.split()
for char in s: #Iterar según el numero de letras en la palabra
if char in vocal: #recorrer las letras que esten la lista vocal
ter_palabra = str(s[index:])#si se encuentra, que se extraiga a partir de d
break
if char in muda:#recorrer las letras que esten la lista consonante mudas
ter_palabra = str(s[index:]) #si se encuentra, que se extraiga a partir de
break
else:
inicio_palabra = inicio_palabra + char #si no ocurre lo anterior, es decir,
index = index + 1
return str(ter_palabra) + inicio_palabra + "ay" #se regresa la palabra transformad

lista="hola"
Pig_Latin(lista)

'holaay'
Out[10]:

La función "resul()", manda a llamar la funcion "Pig_Latin" transformando a cada una de las
palabras de la cadena de caracter; que despues es unida para presentar la cadena transformada
a pig latin.

In [11]: def resul(s):

latin=" " #Objeto vacios
#s=s.split()
j=0 #contador inial
for palabra in s.split():
latin=latin + " " + Pig_Latin(str(s.split()[j]))#se almacena las palabras tran
j = j + 1
return(latin) #regresa la cadena de caracter transformada en pig latin
 entrada="el principio de arquimedes"
resul(entrada)

' elay incipiopray eday arquimedesay'

Out[11]:

Ejercicio 6
Escribe una función en python que obtenga todos los posibles subconjuntos únicos de un
conjunto de números enteros distintos.

Entrada: [4,5,6]

Salida: [[], [6], [5], [5, 6], [4], [4, 6], [4, 5], [4, 5, 6]]

Con la función "subconjuntos()" se crea los subconjuntos de una lista dada, el resultado es una
lista de tuplas que representa las combinaciones.

In [14]: import itertools #Importar la libreria para que me haga las combinaciones

def subconjuntos(s):
combinacion = []
for i in range(len(s)+1):
for j in itertools.combinations(s,i): #Se generan todas las poibles combinacione
combinacion.append(j) #se almacena las combinaciones en el objeto "combinaci
print(combinacion)

lista = [4,5,6]
subconjuntos(lista)

[(), (4,), (5,), (6,), (4, 5), (4, 6), (5, 6), (4, 5, 6)]
 Ejercicio 7
Implemente una función en python que retorna el término n-esimo de la secuencia mirar y
decir (Look and Say). La secuencia mirar y decir es la secuencia de los siguientes números
enteros: 1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, .. Nota que los terminos se
generan al mirar y decir el anterior:

El primer término es "1"

El segundo término es "11", que se genera al leer el primer término como "Un 1" (Hay un 1
en el término anterior)

El tercer término es "21", generado al leer el segundo término como "Dos 1"

El cuarto término es "1211", generado al leer el tercer término como "Un 2 Un 1 "

y así sucesivamente.

Salida: Lista de los 10 primeros términos de esta secuencia

Se crea la función "mirarydecir ()" para generar la secuencia "mirar y decir" a partir de una
secuencia dada anteriormente.

In [12]: def mirarydecir(numero):

result = "" # Objeto vacio donde se almacenará las ocurrencia de los números
i = 0 # Iteración comenzando de cero
while i < len(numero): #Longitud que tiene el número serie de números
count = 1 # Se almacena las ocurrencia o veces que aparece el número
# se crea la condicional para que cuente y alamcene en "count" el número de ve
while i + 1 < len(numero) and numero[i] == numero[i+1]:
i += 1
count += 1
result += (str(count) + numero[i]) #se almacena las veces de ocurrencia del nú
i += 1
return result

In [ ]: La función Look_Say() genera el número de secuencia "mirar y decir" cuantas veces (n)

In [13]: def Look_Say(serie,veces):

for k in range(veces): #Iterar el número de veces a generar
print(serie) #Se imprime la serie
serie = mirarydecir(serie) #para cada serie se genera la secuencia de "mirar y dec

#Se implementa la función "Look_Say"

numero = "123" #Iniciando con el número o serie de números
n = 6 # Número de secuencias
Look_Say (numero,n)
 123
111213
31121113
1321123113
1113122112132113
3113112221121113122113

Powered by TCPDF (www.tcpdf.org)

 Índice de comentarios

1.1 No es tolerante a fallas.

Powered by TCPDF (www.tcpdf.org)