fork download
copy 
  1. # Examen final (parcial 1) ALS (c) 2019 Baltasar MIT License <jbgarcia@uvigo.es>
  2.  
  3. """
  4.     1. (2 pts.) Implemente la función calcula_diferencia(s1, s2). Esta función recorre comparando ambas cadenas. Para cada carácter distinto, convierte el carácter a su código correspondiente en minúsculas y resta ambos. Si las dos cadenas tienen longitud distinta, se le suma por cada carácter de diferencia la existente entre ‘z’ y ‘a’, más 10.
  5.  
  6. print(calcula_diferencia(“radia”, “radio”))	# delta ‘o’ a ‘a’ == 14
  7. print(calcula_diferencia(“radia”, “rada”))	# delta ‘i’ a ‘a’ + delta ‘a’ a ‘z’ + 10 == 43
  8.  
  9.  
  10.     2. (4 pts.) Cree la clase Arbol para estructuras en árboles. Esta clase admite dos valores en el constructor: el nodo raíz, y una lista con los subnodos, que pueden tener un valor cualquiera, u otro objeto Arbol. Tendrá también las propiedades de solo lectura raiz, que devolverán el nodo raíz y subnodos, que devolverá una nueva lista con los subnodos. La función len() será capaz de actuar sobre objetos de esta clase, devolviendo el número de elementos en la lista de subnodos. El operador [] será aplicable, de manera que se devolverá el elemento i-ésimo de la lista de subnodos. Debe ser posible convertir la información de un árbol a cadena, en el formato raiz(subnodo1, subnodo2, ...). Crea el método estático combina(a1, a2), que devolverá un nuevo árbol cuya raíz es la raíz de a1 concatenada con la de a2, y sus subnodos los subnodos de a1 y a2. Así, la combinación de Arbol(“a”, [Arbol(“b”, [“c”, “d”]), “e”]), y  Arbol(“a”, [“f”, “g”]), devolvería el árbol Arbol(“aa”, [Arbol(“b”, [“c”, “d”]), “e”, “f”, “g”]).
  11.  
  12.     3. (4 pts.) Cree la clase Alumno, cuyos objetos se construyen con los datos: dni y nombre, ambos texto. De esta clase derivan la clase Erasmus, que incorpora su país de origen. La clase Nota se construye con un objeto alumno y una nota (float). La clase Asignatura se construye con su nombre, el nombre del profesor, y el año. La clase Calificaciones se construye con el nombre del examen (p.ej. “parcial 1”), un objeto asignatura, y una lista de objetos Nota. Cree propiedades de solo lectura para todos los atributos. Cree métodos que permitan convertir la información a texto en todas las clases.
  13.  
  14. alumno1 = Alumno("Baltasar", "1X")
  15. alumno2 = Erasmus("Wally", "X2X", "Noselandia")
  16. nota1 = Nota(alumno1, 9.5)
  17. nota2 = Nota(alumno2, 5.752)
  18. asignatura = Asignatura("ALS", "Baltasar", 2019)
  19. parcial1 = Calificaciones("parcial 1", self.asignatura, [self.nota1, self.nota2])
  20. print(parcial1)
  21.  
  22. ALS
  23. parcial 1
  24. 1X - Baltasar:  9.50
  25. X2X - Wally (Noselandia):  5.75
  26. """
  27.  
  28. def calcula_diferencia(s1, s2):
  29.     """Calcula la diferencia entre dos textos.
  30.         - Para cada carácter distinto, convierte el carácter a su código correspondiente en minúsculas y resta ambos.
  31.         - Si las dos cadenas tienen longitud distinta, se le suma por cada carácter de diferencia la existente entre ‘z’ y ‘a’, más 10.
  32.  
  33.         :param s: La cadena a rotar.
  34.         :param n: El num. de veces a rotar.
  35.     """
  36.  
  37.     def diferencia_caracteres(c1, c2):
  38.         val1 = ord(c1[0].lower())
  39.         val2 = ord(c2[0].lower())
  40.  
  41.         return abs(val1 - val2)
  42.  
  43.     def diferencia_cadenas(s1, s2):
  44.         val1 = abs(ord('z') - ord('a')) + 10
  45.  
  46.         return abs(len(s1) - len(s2)) * val1
  47.  
  48.     s1 = s1.strip().lower()
  49.     s2 = s2.strip().lower()
  50.     len_comun = min(len(s1), len(s2))
  51.     toret = diferencia_cadenas(s1, s2)
  52.  
  53.     for i in range(len_comun):
  54.         toret += diferencia_caracteres(s1[i], s2[i])
  55.  
  56.     return toret
  57.  
  58.  
  59. class Arbol:
  60.     """Representa un arbol."""
  61.  
  62.     def __init__(self, raiz, subnodos):
  63.         self._raiz = raiz
  64.         self._subnodos = list(subnodos)
  65.  
  66.     @property
  67.     def raiz(self):
  68.         return self._raiz
  69.  
  70.     @property
  71.     def subnodos(self):
  72.         return list(self._subnodos)
  73.  
  74.     def __len__(self):
  75.         return len(self._subnodos)
  76.  
  77.     def __getitem__(self, item):
  78.         return self._subnodos[item]
  79.  
  80.     def __str__(self):
  81.         return str.format("{}({})", str(self.raiz), ", ".join([str(x) for x in self._subnodos]))
  82.  
  83.     @staticmethod
  84.     def combina(a1, a2):
  85.         return Arbol(a1.raiz + a2.raiz, a1.subnodos + a2.subnodos)
  86.  
  87.  
  88. class Alumno:
  89.     """ Un alumno de una asignatura. """
  90.     def __init__(self, nombre, dni):
  91.         self._nombre = nombre
  92.         self._dni = dni
  93.  
  94.     @property
  95.     def dni(self):
  96.         return self._dni
  97.  
  98.     @property
  99.     def nombre(self):
  100.         return self._nombre
  101.  
  102.     def __str__(self):
  103.         return str.format("{} - {}", self.dni, self.nombre)
  104.  
  105.  
  106. class Erasmus(Alumno):
  107.     """ Alumno proveniente del extranjero. """
  108.     def __init__(self, nombre, dni, pais):
  109.         super().__init__(nombre, dni)
  110.         self._pais = pais
  111.  
  112.     @property
  113.     def pais(self):
  114.         return self._pais
  115.  
  116.     def __str__(self):
  117.         return str.format("{} ({})", super().__str__(), self.pais)
  118.  
  119.  
  120. class Nota:
  121.     """ Nota de un alumno. """
  122.     def __init__(self, alumno, nota):
  123.         self._alumno = alumno
  124.         self._nota = nota
  125.  
  126.     @property
  127.     def alumno(self):
  128.         return self._alumno
  129.  
  130.     @property
  131.     def nota(self):
  132.         return self._nota
  133.  
  134.     def __str__(self):
  135.         return str.format("{}: {:5.2f}", str(self.alumno), self.nota)
  136.  
  137.  
  138. class Asignatura:
  139.     def __init__(self, nombre, nombre_profesor, anno):
  140.         self._nombre = nombre
  141.         self._nombre_profesor = nombre_profesor
  142.         self._anno = anno
  143.  
  144.     @property
  145.     def nombre(self):
  146.         return self._nombre
  147.  
  148.     @property
  149.     def nombre_profesor(self):
  150.         return self._nombre_profesor
  151.  
  152.     @property
  153.     def anno(self):
  154.         return self._anno
  155.  
  156.     def __str__(self):
  157.         return str.format( "{} {} ({})", self.nombre, self.nombre_profesor, self.anno)
  158.  
  159.  
  160. class Calificaciones:
  161.     def __init__(self, nombre_examen, asignatura, lista_notas):
  162.         self._nombre_examen = nombre_examen
  163.         self._asignatura = asignatura
  164.         self._lista_notas = lista_notas
  165.  
  166.     @property
  167.     def nombre_examen(self):
  168.         return self._nombre_examen
  169.  
  170.     @property
  171.     def asignatura(self):
  172.         return self._asignatura
  173.  
  174.     @property
  175.     def notas(self):
  176.         return list(self._lista_notas)
  177.  
  178.     def __len__(self):
  179.         return len(self._lista_notas)
  180.  
  181.     def __getitem__(self, item):
  182.         return self._lista_notas[item]
  183.  
  184.     def __str__(self):
  185.         return str.format("{}\n{}\n{}\n",
  186.                           self.asignatura.nombre,
  187.                           self.nombre_examen,
  188.                           "\n".join([str(nota) for nota in self._lista_notas]))
  189.  
  190.  
  191. import unittest 
  192.  
  193.  
  194. class TestCalculaDiferencia(unittest.TestCase):
  195.     def setUp(self):
  196.         self.diferencia_caracter_extra = abs(ord('a') - ord('z')) + 10
  197.  
  198.     def testIt(self):
  199.         cads1 = ["radia", "radia"]
  200.         cads2 = ["radio", "rada"]
  201.         resultados = [abs(ord('o') - ord('a')),
  202.                       abs(ord('i') - ord('a'))
  203.                         + self.diferencia_caracter_extra]
  204.  
  205.         for i, resultado in enumerate(resultados):
  206.             self.assertEqual(resultado, calcula_diferencia(cads1[i], cads2[i]))
  207.  
  208.  
  209.  
  210. class TestArbol(unittest.TestCase):
  211.     def setUp(self):
  212.         self.a1 = Arbol("a", [Arbol("b", ["c", "d"]), "e"])
  213.         self.a2 = Arbol("a", ["f", "g"])
  214.  
  215.     def testArbol1(self):
  216.         sub_a3 = self.a1[0]
  217.  
  218.         self.assertEqual(2, len(sub_a3))
  219.         self.assertEqual('b', sub_a3.raiz)
  220.         self.assertEqual('c', sub_a3[0])
  221.         self.assertEqual('d', sub_a3[1])
  222.         self.assertEqual("b(c, d)", str(sub_a3))
  223.  
  224.         self.assertEqual(2, len(self.a1))
  225.         self.assertEqual('a', self.a1.raiz)
  226.         self.assertEqual(sub_a3, self.a1[0])
  227.         self.assertEqual('e', self.a1[1])
  228.         self.assertEqual("a(b(c, d), e)", str(self.a1))
  229.  
  230.     def testArbol2(self):
  231.         self.assertEqual(2, len(self.a2))
  232.         self.assertEqual('a', self.a2.raiz)
  233.         self.assertEqual('f', self.a2[0])
  234.         self.assertEqual('g', self.a2[1])
  235.         self.assertEqual("a(f, g)", str(self.a2))
  236.  
  237.     def testCombina(self):
  238.         a4 = Arbol.combina(self.a1, self.a2)
  239.  
  240.         self.assertEqual(4, len(a4))
  241.         self.assertEqual(self.a1.raiz + self.a2.raiz, a4.raiz)
  242.         self.assertEqual(self.a1[0], a4[0])
  243.         self.assertEqual('e', a4[1])
  244.         self.assertEqual('f', a4[2])
  245.         self.assertEqual('g', a4[3])        
  246.         self.assertEqual("aa(b(c, d), e, f, g)", str(a4))
  247.  
  248.  
  249. class TestNotasAsignatura(unittest.TestCase):
  250.     def setUp(self):
  251.         self.alumno1 = Alumno("Baltasar", "1X")
  252.         self.alumno2 = Erasmus("Wally", "X2X", "Noselandia")
  253.         self.nota1 = Nota(self.alumno1, 9.5)
  254.         self.nota2 = Nota(self.alumno2, 5.752)
  255.         self.asignatura = Asignatura("ALS", "Baltasar", 2019)
  256.         self.parcial1 = Calificaciones("parcial 1",
  257.                                        self.asignatura,
  258.                                        [self.nota1, self.nota2])
  259.  
  260.     def testAlumno1(self):
  261.         self.assertEqual("Baltasar", self.alumno1.nombre)
  262.         self.assertEqual("1X", self.alumno1.dni)
  263.         self.assertEqual("1X - Baltasar", str(self.alumno1))
  264.  
  265.     def testAlumno2(self):
  266.         self.assertEqual("Wally", self.alumno2.nombre)
  267.         self.assertEqual("X2X", self.alumno2.dni)
  268.         self.assertEqual("Noselandia", self.alumno2.pais)
  269.         self.assertEqual("X2X - Wally (Noselandia)", str(self.alumno2))
  270.  
  271.     def testNota1(self):
  272.         self.assertEqual(self.alumno1, self.nota1.alumno)
  273.         self.assertEqual(9.5, self.nota1.nota)
  274.         self.assertEqual("1X - Baltasar:  9.50", str(self.nota1))
  275.  
  276.     def testNota2(self):
  277.         self.assertEqual(self.alumno2, self.nota2.alumno)
  278.         self.assertEqual(5.752, self.nota2.nota)
  279.         self.assertEqual("X2X - Wally (Noselandia):  5.75", str(self.nota2))
  280.  
  281.     def testAsignatura(self):
  282.         self.assertEqual("ALS", self.asignatura.nombre)
  283.         self.assertEqual("Baltasar", self.asignatura.nombre_profesor)
  284.         self.assertEqual(2019, self.asignatura.anno)
  285.  
  286.     def testCalificaciones(self):
  287.         text = (self.parcial1.asignatura.nombre
  288.             + "\n" + self.parcial1.nombre_examen
  289.             + "\n" + "\n".join([str(x) for x in self.parcial1.notas])
  290.             + "\n")
  291.  
  292.         self.assertEqual("parcial 1", self.parcial1.nombre_examen)
  293.         self.assertEqual(self.asignatura, self.parcial1.asignatura)
  294.         self.assertEqual(2, len(self.parcial1))
  295.         self.assertEqual([self.nota1, self.nota2], self.parcial1.notas)
  296.         self.assertEqual(self.nota1, self.parcial1[0])
  297.         self.assertEqual(self.nota2, self.parcial1[1])
  298.         self.assertEqual(text, str(self.parcial1))
  299.  
  300.  
  301. if __name__ == "__main__":
  302.     unittest.main()
  303.  
Success #stdin #stdout #stderr 0.04s 29768KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
stderr
copy 
..........
----------------------------------------------------------------------
Ran 10 tests in 0.001s

OK
https://ideone.com/BA6xx8
Solución al examen de ALS final (parcial 1) 2018/19.
language:
Python 3 (python  3.9.5)
created:
4 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!