<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 <header class="w3-container w3-teal">
<img src="images/utfsm.png" alt="" align="left"/>
<img src="images/inf.png" alt="" align="right"/>
</header>
<br/><br/><br/><br/><br/>
IWI131
Programación de Computadores
Sebastián Flores
http
Step1:  Solución
La función coloca en una lista los dígitos del número.
Pregunta 2 [35%]
El prestamista Vito Corleone, aburrido de perseguir a sus clientes, ha solicitado la ayuda de algún astro de la programación  para resolver sus problemas logísticos.
Vito cuenta con la lista clientes, la que tiene tuplas con el nombre de cada cliente, el monto adeudado y la fecha del ultimo pago (también dentro de una tupla).
Python
    clientes = [('Don Ramon', 3500, (9, 4, 2014)), 
                ('Miguel', 2785, (30, 10, 2014)), 
                ('Cesar', 100, (28, 5, 2015)), # ...
               ]
Nota
Step2:  Pregunta 2.b
Implemente la función mayor_deudor(clientes, ultimo) que retorne el nombre del cliente 
que tiene la mayor deuda, y que además su ultimo pago haya sido realizado en el año ultimo.
Si no hay clientes con pagos en el año ultimo, retorne un string vacío.
```Python
mayor_deudor(clientes, 2014)
'Don Ramon'
```
Estrategia de solución
Step3:  Pregunta 2.c
Implemente la función pagar(clientes, pago) que recibe la lista clientes y una tupla pago compuesta por el nombre de quien paga, el monto que cancela y la fecha en que lo hace. La 
función modifica y retorna la lista clientes, descontando la deuda y actualizando la fecha del
ultimo pago, según se indique en la tupla pago. Si la deuda llega a 0, debe borrar al cliente de
esta lista. No es necesario considerar el caso en que se paga más de lo que se debe.
```Python
pagar(clientes, ('Miguel', 85, (3, 6, 2015)))
[('Don Ramon', 3500, (9, 4, 2014)), ('Miguel', 2700, (3, 6, 2015)), 
 ('Cesar', 100, (28, 5, 2015))]
pagar(clientes, ('Cesar', 100, (4, 6, 2015)))
[('Don Ramon', 3500, (9, 4, 2014)), ('Miguel', 2700, (3, 6, 2015))]
```
Estrategia de solución
Step4:  Pregunta 3 [40%]
El villano más malvado sobre la faz de la tierra, Ultron, tiene catalogado a todos los
superhéroes de la tierra de la siguiente forma
Step5:  Pregunta 3.a
Desarrollar la función diferencias_poder(superheroes, diferenciapoder, umbral)
que reciba el diccionario superheroes, el valor diferenciapoder y un valor de umbral. La
función debe retornar una lista de tuplas de todos los superhéroes que tengan una diferencia de poder (diferencia min-poder y max-poder) mayor o igual a diferencia poder y un min-poder superior al umbral. Cada tupla debe contener nombre, detalle, habilidad y max-poder.
```Python
diferencias_poder(superheroes, 30, 39)
[('Iron man', 'mk42', 'uni-rayo', 95), 
('Thor', 'hijo de odin', 'mjolnir', 100), 
('Chapulin Colorado', 'no contaban con mi astucia','chipote chillon', 90)]
```
Estrategia de solución
Step6:  Pregunta 3.b
Ultron necesita saber quién es amigo de quién. Dos asociados se consideran amigos si cada uno tiene al otro en el diccionario asociados. Genere una función amigos(asociados) que reciba el diccionario asociados y retorne un diccionario con los amigos, donde la llave es el superhéroe y como valor un conjunto con los amigos de éste. Si un superhéroe no tiene amigos, no se agrega.
```Python
amigos(asociados)
{'Iron man'
Step7:  Pregunta 3.c
Gracias a la manipulación mental de Scarlet Witch, Ultron logrará que los superhéroes amigos que posean una diferencia de poder superior a 40 y además que superen un umbral de min-poder de 30 luchen entre ellos. Se pide generar una función
versus(superheroes, asociados) que reciba el diccionario superheroes, el diccionario asociados y retorne una lista de tuplas con los enfrentamientos de los amigos. 
NOTA
<ASSISTANT_TASK:>
Python Code:
# n numero entero
def f(n):
    l = []
    for i in range(len(str(n))-1,-1,-1):
        x = n/(10**i)
        l.append(x)
        n=n %(10**i)
    return l
f(421)
Explanation: <header class="w3-container w3-teal">
<img src="images/utfsm.png" alt="" align="left"/>
<img src="images/inf.png" alt="" align="right"/>
</header>
<br/><br/><br/><br/><br/>
IWI131
Programación de Computadores
Sebastián Flores
http://progra.usm.cl/ 
https://www.github.com/usantamaria/iwi131
Soluciones a Certamen 2, 1S 2015, Casa Central
Pregunta 1 [25%]
(a) Realice el ruteo de los siguientes programas e indique qué es lo que imprimen. 
Cada vez que el valor de una variable cambie, escríbalo en una nueva fila de la tabla.
<img src="images/2015.png" alt="" align="middle"/>
Pregunta 1.b : Análisis de Algoritmo
Analice el siguiente algoritmo y determine, en pocas palabras, lo que realiza. No debe usar m ́as
del espacio indicado.
End of explanation
# Cargando los datos
clientes = [('Don Ramon', 3500, (9, 4, 2014)), 
            ('Miguel', 2785, (30,10, 2014)), 
            ('Cesar', 100, (28, 5, 2015)), # ...
           ]
def deuda_total(clientes):
    total = 0
    for nombre, deuda, fecha in clientes:
        total += deuda
    return total
deuda_total(clientes)
Explanation: Solución
La función coloca en una lista los dígitos del número.
Pregunta 2 [35%]
El prestamista Vito Corleone, aburrido de perseguir a sus clientes, ha solicitado la ayuda de algún astro de la programación  para resolver sus problemas logísticos.
Vito cuenta con la lista clientes, la que tiene tuplas con el nombre de cada cliente, el monto adeudado y la fecha del ultimo pago (también dentro de una tupla).
Python
    clientes = [('Don Ramon', 3500, (9, 4, 2014)), 
                ('Miguel', 2785, (30, 10, 2014)), 
                ('Cesar', 100, (28, 5, 2015)), # ...
               ]
Nota: Esto es sólo un ejemplo, considere que la lista puede tener muchos clientes. Sin embargo  asuma que cada nombre de cliente aparece sólo una vez.
Pregunta 2.a
Implemente la función deuda_total(clientes) que reciba como entrada la lista de tuplas clientes, y retorne la suma de las deudas de todos los deudores.
```Python
deuda_total(clientes)
6385
```
Estrategia de solución:
* ¿Qué estructura tienen los datos de entrada?
* ¿Qué estructura deben tener los datos de salida?
* ¿Cómo proceso los inputs para generar el output deseado?
End of explanation
def mayor_deudor(clientes, ultimo):
    nombre_mayor_deudor = ""
    deuda_mayor_deudor = -float("inf")
    for nombre, deuda, (dia, mes, anno) in clientes:
        if anno==ultimo and deuda>deuda_mayor_deudor:
            nombre_mayor_deudor=nombre
            deuda_mayor_deudor=deuda
    return nombre_mayor_deudor
print mayor_deudor(clientes, 2014)
print mayor_deudor(clientes, 2015)
print mayor_deudor(clientes, 2016)
Explanation: Pregunta 2.b
Implemente la función mayor_deudor(clientes, ultimo) que retorne el nombre del cliente 
que tiene la mayor deuda, y que además su ultimo pago haya sido realizado en el año ultimo.
Si no hay clientes con pagos en el año ultimo, retorne un string vacío.
```Python
mayor_deudor(clientes, 2014)
'Don Ramon'
```
Estrategia de solución:
* ¿Qué estructura tienen los datos de entrada?
* ¿Qué estructura deben tener los datos de salida?
* ¿Cómo proceso los inputs para generar el output deseado?
End of explanation
# SACAR ELEMENTO DE TUPLA
tupla = ("zero", "uno","dos","tres","cuatro")
# No es posible directamente, hay que generar una nueva tupla
tupla = (tupla[0], tupla[2], tupla[3], tupla[4])
print tupla
# SACAR ELEMENTO DE LISTA
lista = ["zero", "uno","dos","tres","cuatro"]
lista.pop(1)
print lista
# SACAR ELEMENTO DE DICCIONARIO
diccio = {"zero":0, "uno":1,"dos":2,"tres":3,"cuatro":4}
del diccio["uno"]
print diccio
# SACAR ELEMENTO DE CONJUNTO
conjunto = {"zero", "uno","dos","tres","cuatro"}
conjunto.remove("uno")
print conjunto
def pagar(clientes, pago):
    nombre_pagador, monto_pago, fecha_pago = pago
    for i in range(len(clientes)):
        nombre, deuda, fecha = clientes[i]
        if nombre_pagador==nombre:
            deuda_restante = deuda - monto_pago
            if deuda_restante<=0:
                clientes.pop(i)
            else:
                deuda_actualizada = (nombre, deuda_restante, fecha_pago)
                clientes[i] = deuda_actualizada
    return clientes
clientes = [('Don Ramon', 3500, (9, 4, 2014)), 
            ('Miguel', 2785, (30,10, 2014)), 
            ('Cesar', 100, (28, 5, 2015)), # ...
           ]
print pagar(clientes, ('Miguel', 85, (3, 6, 2015)))
print pagar(clientes, ('Cesar', 100, (4, 6, 2015)))
def pagar(clientes, pago):
    nombre_pagador, monto_pago, fecha_pago = pago
    for cliente in clientes:
        nombre, deuda, fecha = cliente
        if nombre_pagador==nombre:
            deuda_restante = deuda - monto_pago
            if deuda_restante<=0:
                clientes.remove(cliente)
            else:
                deuda_actualizada = (nombre, deuda_restante, fecha_pago)
                cliente = deuda_actualizada
    return clientes
clientes = [('Don Ramon', 3500, (9, 4, 2014)), 
            ('Miguel', 2785, (30,10, 2014)), 
            ('Cesar', 100, (28, 5, 2015)), # ...
           ]
print pagar(clientes, ('Miguel', 85, (3, 6, 2015)))
print pagar(clientes, ('Cesar', 100, (4, 6, 2015)))
Explanation: Pregunta 2.c
Implemente la función pagar(clientes, pago) que recibe la lista clientes y una tupla pago compuesta por el nombre de quien paga, el monto que cancela y la fecha en que lo hace. La 
función modifica y retorna la lista clientes, descontando la deuda y actualizando la fecha del
ultimo pago, según se indique en la tupla pago. Si la deuda llega a 0, debe borrar al cliente de
esta lista. No es necesario considerar el caso en que se paga más de lo que se debe.
```Python
pagar(clientes, ('Miguel', 85, (3, 6, 2015)))
[('Don Ramon', 3500, (9, 4, 2014)), ('Miguel', 2700, (3, 6, 2015)), 
 ('Cesar', 100, (28, 5, 2015))]
pagar(clientes, ('Cesar', 100, (4, 6, 2015)))
[('Don Ramon', 3500, (9, 4, 2014)), ('Miguel', 2700, (3, 6, 2015))]
```
Estrategia de solución:
* ¿Qué estructura tienen los datos de entrada?
* ¿Qué estructura deben tener los datos de salida?
* ¿Cómo proceso los inputs para generar el output deseado?
End of explanation
# CARGAR LOS DATOS
# nombre: [detalle, edad, habilidad, (min-poder, max-poder)]
superheroes = {
'Iron man': ['mk42', 50 , 'uni-rayo', (45, 95)],
'Thor': ['hijo de odin', 10000 , 'mjolnir', (50, 100)],
'Condorito':['de pelotillehue', 40, 'washington', (1, 10)],
'Chapulin Colorado': ['no contaban con mi astucia', 40, 'chipote chillon', (40, 90)],
# ...
}
# nombre : nombre_asociados
asociados = {
'Iron man': set(['Thor', 'Black Widow', 'Hawkeye', 'Hulk']),
'Thor': set(['Iron man', 'Hulk', 'Chapulin Colorado']),
'Condorito' : set(['Don Chuma', 'Hulk']),
'Chapulin Colorado' : set(['Condorito', 'Thor']),
# ...
}
Explanation: Pregunta 3 [40%]
El villano más malvado sobre la faz de la tierra, Ultron, tiene catalogado a todos los
superhéroes de la tierra de la siguiente forma:
Python
    # nombre: [detalle, edad, habilidad, (min-poder, max-poder)]
    superheroes = {
    'Iron man': ['mk42', 50 , 'uni-rayo', (45, 95)],
    'Thor': ['hijo de odin', 10000 , 'mjolnir', (50, 100)],
    'Condorito':['de pelotillehue', 40, 'washington', (1, 10)],
    'Chapulin Colorado': ['no contaban con mi astucia', 40, 'chipote
    chillon', (40, 90)],
    # ...
    }
    # nombre : nombre_asociados
    asociados = {
    'Iron man': set(['Thor', 'Black Widow', 'Hawkeye', 'Hulk']),
    'Thor': set(['Iron man', 'Hulk', 'Chapulin Colorado']),
    'Condorito' : set(['Don Chuma', 'Hulk']),
    'Chapulin Colorado' : set(['Condorito', 'Thor']),
    # ...
    }
Pese a ser la inteligencia artificial más avanzada jamás creada, se le complica un poco cuando llega el momento de programar, por ello pide ayuda a los alumnos de IWI-131 en lo siguiente:
End of explanation
def diferencias_poder(superheroes, diferenciapoder, umbral):
    superheroes_seleccionados = []
    for nombre, caracteristicas in superheroes.items():
        detalle, edad, habilidad, (min_poder, max_poder) = caracteristicas
        if max_poder-min_poder>=diferenciapoder and min_poder>umbral:
            tupla_datos = (nombre, detalle, habilidad, max_poder) 
            superheroes_seleccionados.append( tupla_datos )
    return superheroes_seleccionados
diferencias_poder(superheroes, 30, 39)
Explanation: Pregunta 3.a
Desarrollar la función diferencias_poder(superheroes, diferenciapoder, umbral)
que reciba el diccionario superheroes, el valor diferenciapoder y un valor de umbral. La
función debe retornar una lista de tuplas de todos los superhéroes que tengan una diferencia de poder (diferencia min-poder y max-poder) mayor o igual a diferencia poder y un min-poder superior al umbral. Cada tupla debe contener nombre, detalle, habilidad y max-poder.
```Python
diferencias_poder(superheroes, 30, 39)
[('Iron man', 'mk42', 'uni-rayo', 95), 
('Thor', 'hijo de odin', 'mjolnir', 100), 
('Chapulin Colorado', 'no contaban con mi astucia','chipote chillon', 90)]
```
Estrategia de solución:
* ¿Qué estructura tienen los datos de entrada?
* ¿Qué estructura deben tener los datos de salida?
* ¿Cómo proceso los inputs para generar el output deseado?
End of explanation
def amigos(asociados):
    amigos = {}
    for nombre, conjunto_socios in asociados.items():
        for nombre_socio in conjunto_socios:
            # Ver si son amigos
            if (nombre_socio in asociados) and \
               (nombre in asociados[nombre_socio]):
                # Si son amigos, agregar al diccionario
                if nombre not in amigos:
                    amigos[nombre] = set([nombre_socio])
                else:
                    amigos[nombre].add(nombre_socio)
    return amigos
print amigos(asociados)
Explanation: Pregunta 3.b
Ultron necesita saber quién es amigo de quién. Dos asociados se consideran amigos si cada uno tiene al otro en el diccionario asociados. Genere una función amigos(asociados) que reciba el diccionario asociados y retorne un diccionario con los amigos, donde la llave es el superhéroe y como valor un conjunto con los amigos de éste. Si un superhéroe no tiene amigos, no se agrega.
```Python
amigos(asociados)
{'Iron man': set(['Thor']), 
'Chapulin Colorado': set(['Thor']), 
'Thor': set(['Iron man', 'Chapulin Colorado'])}
```
Estrategia de solución:
* ¿Qué estructura tienen los datos de entrada?
* ¿Qué estructura deben tener los datos de salida?
* ¿Cómo proceso los inputs para generar el output deseado?
End of explanation
def versus(superheroes, asociados):
    # Crear diccionario con amigos
    amigos_dict = amigos(asociados)
    # Candidatos a pelear, pero con demasiada informacion
    lista_diferencias_poder = diferencias_poder(superheroes, 30, 39)
    # Candidatos a pelear, solo nombres
    superheroes_poderosos = []
    for nombre, _, _, _ in lista_diferencias_poder:
        superheroes_poderosos.append(nombre)
    # Recorrer y agregar a lista (una unica vez)
    lista_versus = []
    for nombre_1 in superheroes_poderosos:
        for nombre_2 in amigos_dict[nombre_1]:
            if nombre_2 in superheroes_poderosos:
                tupla_a_agregar = (nombre_2, nombre_1) 
                tupla_quizas_presente = (nombre_1, nombre_2) 
                if tupla_quizas_presente not in lista_versus:
                    lista_versus.append(tupla_a_agregar)
    return lista_versus
print versus(superheroes, asociados)
Explanation: Pregunta 3.c
Gracias a la manipulación mental de Scarlet Witch, Ultron logrará que los superhéroes amigos que posean una diferencia de poder superior a 40 y además que superen un umbral de min-poder de 30 luchen entre ellos. Se pide generar una función
versus(superheroes, asociados) que reciba el diccionario superheroes, el diccionario asociados y retorne una lista de tuplas con los enfrentamientos de los amigos. 
NOTA: no se deben repetir las parejas.
```Python
versus(superheroes, asociados)
[('Iron man', 'Thor'), ('Chapulin Colorado', 'Thor')]
```
Estrategia de solución:
* ¿Qué estructura tienen los datos de entrada?
* ¿Qué estructura deben tener los datos de salida?
* ¿Cómo proceso los inputs para generar el output deseado?
End of explanation
<END_TASK>