8. Ciclos II#

(★☆☆, ★★☆, ★★★) Esta notación indica la dificultad de cada ejercicio, de menor a mayor.

★☆☆ ¿En qué se diferencian las sentencias break y continue?
★☆☆ Programar una función que tome una lista de números y compute la suma de todos los números en la lista.
★☆☆ Programar una función que tome dos listas y retorne True si las listas tienen por lo menos un elemento en común.
★☆☆ Completar la función count_A para que cuente la cantidad de letras “A” que se encuentran en un texto (y devuelva dicha cantidad). Complete el siguiente código:
```
def count_A(the_string):
    # complete me
```
★☆☆ Escriba una función count(s, character) que cuente cuántas veces aparece el carácter character en la cadena s. Complete el siguiente código:
```
def count(s, character):
    # complete me
```
1. Escriba un programa que le pida al usuario un carácter y un texto y luego muestre la cantidad de ocurrencias del carácter en el texto ingresado. Por ejemplo, puede seguir la siguiente interfaz:
```
texto: podemos ingresar una cadena relativamente larga y contar la cantidad de ocurrencias de un carácter
carácter: a
> la cantidad de "a" en el texto es: 15
```
2. Escriba un programa que le pida al usuario un texto y dos caracters e indique qué carácter tiene más ocurrencias. Por ejemplo, puede seguir la siguiente interfaz:
```
texto: podemos ingresar una cadena relativamente larga y contar la cantidad de ocurrencias de un carácter
carácter 1: a
carácter 2: e
El texto tiene más "a" que "e".
```
★★☆ Solo algunos tipos de piedras son joyas, sin embargo, todas las joyas son piedras. Si representamos cada piedra con un carácter, por ejemplo la “a”, podemos usar una cadena de caracteres para representar un conjunto de piedras, por ejemplo “aaAb”. Suponiendo que poseemos un conjunto de piedras representadas con una cadena. Queremos saber cuántas joyas tenemos en nuestro poder comparando esa cadena con una cadena patrón compuesta solo por joyas.

Las letras distinguen entre mayúsculas y minúsculas, por lo que “a” se considera un tipo de piedra diferente de “A”.

En la tabla siguiente se muestran ejemplos de resultados esperados para distintos valores de la entrada:

Piedras que tienes Piedras que son joyas Cantidad de joyas

"aAAbbbb" "aA" 3

"ZZ" "z" 0
★★☆ Programar una función que retorne True si un password (string) cumple con los siguientes requisitos:
- Tiene que tener por lo menos una letra minúscula.
- Tiene que tener por lo menos una letra mayúscula.
- Tiene que tener por lo menos un número.
- Tiene que tener por lo menos un signo no alfanumérico (p.ej. ! ó $).
- Tiene que tener entre 8 y 31 caracteres.

★★☆ Escribir una función que permita determinar si una cadena podría formar una palabra, del siguiente modo: el carácter “?” sirve de comodín para cualquier letra, mientras que sea 1 (una) letra, por lo que “?oca” puede formar la palabra “poca”, también la palabra “boca”, o “roca”. La palabra “?” puede formar cualquier cadena de largo 1, mientras que “?o?a” puede formar “poca”, “bota”, “rosa”, etc.

La función debe cumplir el siguiente prototipo:

def matches(base: str, word: str) -> bool:
# complete me

El siguiente código debe funcionar sin errores con la función desarrollada:

def test_matches():
    if matches("?", ""):
        return False
    if not matches("?", "a"):
        return False
    if matches("?", "aa"):
        return False
    if matches("x", "a"):
        return False
    if not matches("?o?a", "rota"):
        return False
    if not matches("?o?a", "poca"):
        return False
    if not matches("?o?a", "bota"):
        return False
    if not matches("?o?a", "sola"):
        return False
    if not matches("?o?a", "cosa"):
        return False
    if matches("?osa", "rota"):
        return False
    if matches("?ola", "poca"):
        return False
    if matches("co?a", "bota"):
        return False
    if matches("mo?a", "sola"):
        return False
    if matches("so?a", "cosa"):
        return False

if test_matches() is False:
    print("Esto no funciona")

★☆☆ Programar una función my_max que tome por argumento una lista con números (int o float) y retorne el número máximo.
★☆☆ Hay un lenguaje de programación con sólo cuatro operaciones y una variable, x, definido por los siguientes items:
- Inicialmente, el valor de x siempre es 0.
- ++x y x++ incrementa el valor de la variable x en 1.
- --x y x-- decrementa el valor de la variable x en 1.
Dada una lista de cadenas que contienen una lista de operaciones, devuelva el valor final de x después de realizar todas las operaciones.

En la tabla siguiente se muestran resultados esperados para distintos valores de la entrada:

Operaciones Valor final de x

[] 0

["++x"] 1

["--x"] -1

["--x", "x++"] 0

["++x", "x++"] 2

["++x", "x++", "x--"] 1
★☆☆ Programar una función que tome como argumento un párrafo (un string con muchas palabras), y retorne una lista indicando la frecuencia con la que ocurren palabras de distinta longitud (la estructura de la lista a retornar queda a criterio del diseñador, pero debe ser explicada claramente en el docstring). Es decir, la función debe computar cuantas palabras de largo 1 hay en el párrafo, cuantas de largo 2, y así sucesivamente hasta la longitud más larga que tenga el párrafo.

Importante

los signos de puntuación no son considerados parte de la palabra, así como cualquier otro carácter que no sea una letra del abecedario.
★☆☆ Escribir una función que reciba una lista de listas y elimine todas las listas cuyo 3er elemento sea mayor a un número dado. Por ejemplo, si se tiene la lista: [["W", 5, 31], ["U", 7, 18], ["F", 11, 15], ["B", 16, 28]], y el número 20, debe devolver la lista [["U", 7, 18], ["F", 11, 15]].
★★★ En este ejercicio practicaremos el concepto de filtrado: queremos quedarnos con algunos elementos de entre otros tantos, para ello:
- Escribir una función que reciba una lista y retorne True o False si la lista es de al menos 3 elementos y el segundo es menor al tercero y la suma de estos dos es mayor 20.
```
def condicion(lista):
    pass # completa aquí

print(condicion([1, 25])) # False
print(condicion([1, 2, 3])) # False
print(condicion([1, 10, 10])) # False
print(condicion([1, 10, 11])) # True
print(condicion([1, 10, 10, 10])) # False
print(condicion([1, 10, 11, 10])) # True
```
- Escribir una función llamada filtrar que recibe una lista l y una función f y retorne una lista con aquellos elementos de l que al aplicarles f individualmente devuelven True.
```
def filtrar(l, f):
    pass # completa aquí

print(filtrar([[1, 25], [1, 2, 3], [1, 10, 10], [1, 10, 11], [1, 10, 10, 10], [1, 10, 11, 10]], condicion))
# [[1, 10, 11], [1, 10, 11, 10]]
```
- Resolver el ejercicio anterior utilizando la función filtrar desarrollada en el inciso anterior.

Operaciones	Valor final de x
`[]`	`0`
`["++x"]`	`1`
`["--x"]`	`-1`
`["--x", "x++"]`	`0`
`["++x", "x++"]`	`2`
`["++x", "x++", "x--"]`	`1`

Piedras que tienes	Piedras que son joyas	Cantidad de joyas
`"aAAbbbb"`	`"aA"`	3
`"ZZ"`	`"z"`	0