fork download 
  1. # Examen ALS parcial 1 (c) Baltasar 2022 MIT License <jbgarcia@uvigo.es>
  2.  
  3.  
  4.  
  5. """
  6. (3 pts.) Implemente la función es_dict_superconjunto(d1, d2).
  7. Se trata de una función que recibe dos diccionarios,
  8. y decide si d1 es un superconjunto de d2.
  9. Un diccionario d1 será superconjunto de otro d2 si
  10. todas las claves de d2 también están en d1, y además,
  11. sus valores asociados son iguales.
  12. La función devolverá una tupla formada
  13. en su primera posición por un valor booleano
  14. (indicando True si es superconjunto o False en caso contrario),
  15. y en la segunda posición otra tupla que contendrá las claves en d2
  16. que no se encuentran en d1 o tienen valores diferentes.
  17. Así, para d1 = {‘a’, 1} y d2 = {‘b’, 2}, devolverá (False, (‘b’,)),
  18. para d1 = {‘a’, 1, ‘b’: 2} y d2 = {‘b’, 2}, devolverá (True, ()),
  19. para d1 = {‘a’, 1, ‘b’: 2} y d2 = {‘a’: 1, ‘b’, 2}, devolverá (True, ()),
  20. y para d1 = {‘a’, 1} y d2 = {‘a’, 42}, devolverá (False, (‘a’,))
  21. """
  22. def is_dict_superset(d1: dict, d2: dict) -> tuple:
  23.     """Is d1 a superset of d2?"""
  24.     diffs = []
  25.  
  26.     for k, v in d2.items():
  27.         if (k not in d1.keys()
  28.          or v != d1[k]):
  29.             diffs.append(k)
  30.  
  31.     toret = len(diffs) == 0
  32.     return (toret, tuple(diffs))
  33.  
  34.  
  35. """
  36. (3 pts.) Cree la función evalua_fecha(f: str) -> list,
  37. que acepta una fecha en formato dd/mm/aaaa, d/m/aa, o aaaa/mm/dd.
  38. Nótese que los separadores pueden ser la barra (‘/’), guión (‘-‘)
  39. o incluso un punto (‘.’). Si el año es menor que 100, se le suma 2000.
  40. La función devolverá la fecha como una lista de tres posiciones,
  41. la primera el año, la segunda el mes y la tercera el día.
  42. """
  43. def eval_date(d: str) -> list:
  44.     # Decide separator
  45.     sep = '/'
  46.  
  47.     if d.find('-') >= 0:
  48.         sep = '-'
  49.  
  50.     if d.find('.') >= 0:
  51.         sep = '.'
  52.  
  53.     # Get parts
  54.     toret = [int(x) for x in d.split(sep)]
  55.     is_iso = True
  56.  
  57.     if toret[0] <= 31:
  58.         is_iso = False
  59.  
  60.     if not is_iso:
  61.         toret.reverse()
  62.  
  63.     # Add 2000 if needed
  64.     if toret[0] < 100:
  65.         toret[0] += 2000
  66.  
  67.     return toret
  68.  
  69.  
  70. """
  71.     3. (4 pts.) Se necesita desarrollar un programa para explicar recorridos.
  72.     Cree la clase Paso, que se construye con una distancia (número real).
  73.     De ella derivan las clases Avance
  74.     (que además lleva el nombre de la carretera, como texto),
  75.     y Desvío de la que a su vez derivan las clases Derecha e Izquierda.
  76.     Estas tres clases guardan adicionalmente como texto
  77.     el nombre de la salida a tomar,
  78.     y la distancia es el punto kilométrico de dicha salida.
  79.     La clase Recorrido llevará una lista de objetos Paso,
  80.     y dos atributos que guardarán el nombre del punto de salida,
  81.     y el nombre del punto de llegada. Ofrecerá los métodos __len__(),
  82.     que devuelve el número de elementos del recorrido, inserta(m: Paso),
  83.     que inserta al final un nuevo paso, y la propiedad pasos,
  84.     que devolverá una lista con los pasos guardados. 
  85.     El método calcula_distancia() sumará las distancias de los pasos Avance.
  86.     Cree inicializadores, métodos __str__() (excepto para Paso)
  87.     y propiedades de solo lectura para las clases anteriores.
  88.     Tome el siguiente código como referencia.
  89.  
  90. 	> r = Recorrido("Ourense", "Vigo")
  91. 	> r.inserta(Derecha(1.5, "entrada centro"))
  92. 	> r.inserta(Avance(110, "A-52"))
  93. 	> r.inserta(Derecha(111, "avda. Madrid"))
  94. 	> print(f"Número de pasos: {len(r)}")
  95. Número de pasos: 3
  96. 	> print(r)
  97. Ourense - Vigo (110km): gire a la derecha en km 1.5 por entrada centro,
  98. avance 110km por A-52, gire a la derecha en km 111 por avda. Madrid
  99. """
  100. class Paso:
  101.     def __init__(self, distancia: float):
  102.         self._distancia = distancia
  103.  
  104.     @property
  105.     def distancia(self):
  106.         return self._distancia
  107.  
  108.  
  109. class Avance(Paso):
  110.     def __init__(self, distancia: float, nombre_carretera: str):
  111.         super().__init__(distancia)
  112.         self._nombre_carretera = nombre_carretera
  113.  
  114.     @property
  115.     def nombre_carretera(self):
  116.         return self._nombre_carretera
  117.  
  118.     def __str__(self):
  119.         return f"avance {self.distancia}km por {self.nombre_carretera}"
  120.  
  121.  
  122. class Desvio(Paso):
  123.     def __init__(self, distancia: float, nombre_salida: str):
  124.         super().__init__(distancia)
  125.         self._nombre_salida = nombre_salida
  126.  
  127.     @property
  128.     def nombre_salida(self):
  129.         return self._nombre_salida
  130.  
  131.     def __str__(self):
  132.         return f"en km {self.distancia} por {self.nombre_salida}"
  133.  
  134.  
  135. class Derecha(Desvio):
  136.     def __str__(self):
  137.         return f"gire a la derecha {super().__str__()}"
  138.  
  139.  
  140. class Izquierda(Desvio):
  141.     def __str__(self):
  142.         return f"gire a la izquierda {super().__str__()}"
  143.  
  144. class Recorrido:
  145.     def __init__(self, comienzo: str, final: str):
  146.         self._pasos = []
  147.         self._comienzo = comienzo
  148.         self._final = final
  149.  
  150.     def inserta(self, p: Paso):
  151.         self._pasos.append(p)
  152.  
  153.     def __len__(self) -> int:
  154.         return len(self._pasos)
  155.  
  156.     @property
  157.     def comienzo(self):
  158.         return self._comienzo
  159.  
  160.     @property
  161.     def final(self):
  162.         return self._final
  163.  
  164.     @property
  165.     def pasos(self):
  166.         return list(self._pasos)
  167.  
  168.     def calcula_distancia(self):
  169.         toret = 0
  170.  
  171.         for p in self._pasos:
  172.             if isinstance(p, Avance):
  173.                 toret += p.distancia
  174.  
  175.         return toret
  176.  
  177.     def __str__(self):
  178.         toret = f"{self.comienzo} - {self.final} ({self.calcula_distancia()}km): "
  179.         return toret + ", ".join([str(x) for x in self._pasos])
  180.  
  181.  
  182. if __name__ == "__main__":
  183.     d1 = {'a': 1, 'b': 2}
  184.     d2 = {'a': 1}
  185.     d3 = dict(d1)
  186.     d4 = {'c': 3}
  187.     d5 = {'a': 42}
  188.  
  189.     print(f"{d1} superset {d2}: {is_dict_superset(d1, d2)}")
  190.     print(f"{d1} superset {d3}: {is_dict_superset(d1, d3)}")
  191.     print(f"{d1} superset {d4}: {is_dict_superset(d1, d4)}")
  192.     print(f"{d2} superset {d1}: {is_dict_superset(d2, d1)}")
  193.     print(f"{d3} superset {d1}: {is_dict_superset(d3, d1)}")
  194.     print(f"{d4} superset {d1}: {is_dict_superset(d4, d1)}")
  195.     print(f"{d2} superset {d5}: {is_dict_superset(d2, d5)}")
  196.  
  197.     r = Recorrido("Ourense", "Vigo")
  198.     r.inserta(Derecha(1.5, "entrada centro"))
  199.     r.inserta(Avance(110, "A-52"))
  200.     r.inserta(Derecha(111, "avda. Madrid"))
  201.     print(f"Número de pasos: {len(r)}")
  202.     print(r)
  203.  
  204.     print(f"eval_date('2022/02/01') = {eval_date('2022/02/01')}")
  205.     print(f"eval_date('2022/2/1') = {eval_date('2022/2/1')}")
  206.     print(f"eval_date('1-2-22') = {eval_date('1-2-22')}")
  207.  
Success #stdin #stdout 0.02s 9412KB
comments (?)
stdin 
Standard input is empty
stdout 
{'a': 1, 'b': 2} superset {'a': 1}: (True, ())
{'a': 1, 'b': 2} superset {'a': 1, 'b': 2}: (True, ())
{'a': 1, 'b': 2} superset {'c': 3}: (False, ('c',))
{'a': 1} superset {'a': 1, 'b': 2}: (False, ('b',))
{'a': 1, 'b': 2} superset {'a': 1, 'b': 2}: (True, ())
{'c': 3} superset {'a': 1, 'b': 2}: (False, ('a', 'b'))
{'a': 1} superset {'a': 42}: (False, ('a',))
Número de pasos: 3
Ourense - Vigo (110km): gire a la derecha en km 1.5 por entrada centro, avance 110km por A-52, gire a la derecha en km 111 por avda. Madrid
eval_date('2022/02/01') = [2022, 2, 1]
eval_date('2022/2/1') = [2022, 2, 1]
eval_date('1-2-22') = [2022, 2, 1]
https://ideone.com/j3eriN
Solución al examen ALS parcial 1 2021/22
language:
Python 3 (python  3.9.5)
created:
2 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!