1 /* ----------------------------------------------------------------------------

2 Nombre completo:Kharchenko Lina

3 1DAW Programación
4 Examen de los Temas 8 Y 9.
5 Clases, herencia, polimorfismo, abstracción, gestión de errores, gestión del sistema
de ficheros y flujos e/s
6 26-Abril-2024
7 -----------------------------------------------------------------------------*/
8
9 /* ----------------------------------------------------------------------------
10 Puntuación de los ejercicios: se indica junto a cada ejercicio
11 Duración del examen: 90 minutos
12 Se valorará además de que las solución de los ejercicios sea correcta, la correcta
indentación, los comentarios en el código, y la claridad y simplicidad del código en
general.
13 No entregues dos soluciones al mismo ejercicio. Cada ejercicio debe tener una única
solución, aunque puedes añadir todos los comentarios que creas conveniente.
14 Salvo que se indique así en el enunciado, no hace falta controlar errores
15 Se valorará la creación de los métodos necesarios y la elección de sus nombres para
mejorar la estructura del programa
16 -----------------------------------------------------------------------------*/
17
18 // ----------------------------------------------------------------------------
19 // Ejercicio 1 (3.5 puntos)c
20 /* ----------------------------------------------------------------------------
21 Crea una Pila genérica (que permite almacenar cualquier tipo de datos) utilizando
22 arrays dinámicos (List) para guardar los elementos.
23 La pila creará un tipo de excepción PilaListaException que herede de Exception
24
25 Crea las propiedades:
26 NumeroElementos: (sólo lectura) devolverá el número de elementos de la pila
27 Vacia: (sólo lectura) devolverá true si la pila está vacía
28
29 Crea los métodos:
30 Apilar: añadirá un elemento a la pila
31 Desapilar: devolverá el último elemento añadido a la pila y lo eliminará. Mostrará un
error si la pila está vacía
32 Cima: devolverá el último elemento añadido a la pila sin eliminarlo. Mostrará un
error si la pila está vacía
33
34 Se proporciona un código de prueba que muestra cómo se puede utilizar la pila para
35 invertir las palabras de una frase.
36 -----------------------------------------------------------------------------*/
37
38 // class Program
39 // {
40 // static void Main()
41 // {
42 // string frase = "En un lugar de la Mancha de cuyo nombre no quiero
acordarme.";
43 // var pila = new PilaLista<char>();
44
45 // for (int i = 0; i < frase.Length; i++)
46 // {
47 // if (Char.IsLetterOrDigit(frase[i]))
48 // pila.Apilar(frase[i]);
49 // if (!Char.IsLetterOrDigit(frase[i]) || i == frase.Length - 1)
50 // while (!pila.Vacia)
51 // Console.Write(pila.Desapilar());
52 // if (!Char.IsLetterOrDigit(frase[i]))
53 // Console.Write(frase[i]);
54 // }
55 // }
56 // }
57 // Salida:
58 // nE nu ragul ed al ahcnaM ed oyuc erbmon on oreiuq emradroca.
59 using System;
60 using System.Collections.Generic;
61 using System.Linq;
62 using System.Text;
63 using System.Threading.Tasks;
64 using System.Windows;
65 using System.Text;
 66
67 class PilaListaException : Exception
68 {
69 public PilaException(string message) : base(message) { }
70 }
71
72 public class Pila<T>
73 {
74 List<T> pila = new List<T>();
75
76 public void Apilar(T dato) => pila.Add(dato);
77
78 public T Desapilar()
79 {
80 if (Vacia)
81 new PilaException("No se puede Desapilar de una pila vacía");
82 T dato = ConsultarCabeza;
83 pila.RemoveAt(pila.Count - 1);
84 return dato;
85 }
86
87 public T ConsultarCabeza
88 {
89 get
90 {
91 if (Vacia)
92 throw new PilaException("No se puede consultar la cabeza de una pila
vacía");
93 return pila[pila.Count - 1];
94 }
95 }
96
97 public bool Vacia
98 {
99 get
100 {
101 return pila.Count == 0;
102 }
103 }
104
105 public override string ToString()
106 {
107 if (Vacia) return "Pila vacía";
108 return string.Join(", ", pila);
109 }
110 }
111 class Program
112 {
113 public static void ImprimePila(Pila<string> pila) => Console.WriteLine(frase);
114
115 List<T> pila = new List<T>();
116
117 public void Apilar(T frase) => pila.Add(frase);
118
119 public T Desapilar()
120 {
121 if (Vacia)
122 new PilaException("No se puede Desapilar de una pila vacía");
123 T dato = ConsultarCabeza;
124 pila.RemoveAt(pila.Count - 1);
125 return dato;
126 }
127 static void Main()
128 {
129 string frase = "En un lugar de la Mancha de cuyo nombre no quiero acordarme.";
130 var pila = new PilaLista<char>();
131
132 for (int i = 0; i < frase.Length; i++)
133 {
134 if (Char.IsLetterOrDigit(frase[i]))
135 pila.Apilar(frase[i]);
136 if (!Char.IsLetterOrDigit(frase[i]) || i == frase.Length - 1)
137 while (!pila.Vacia)
138 Console.Write(pila.Desapilar());
139 if (!Char.IsLetterOrDigit(frase[i]))
140 Console.Write(frase[i]);
141 }
142 }
143 }
144 // ----------------------------------------------------------------------------
145 // Ejercicio 2 (3.5 puntos)
146 /* ----------------------------------------------------------------------------
147 Se proporcinan ya implementadas las siguientes clases:
148 Clase Pelicula, con los atributos: titulo, director, año, duración, dinero recaudado,
valoración de los espectadores y número de emisiones.
149 Clase Canción, con los atributos: título, autor, año, duración, dinero recaudado,
valoración de los oyentes y número de emisiones.
150 Clase Libro, con los atributos: título, autor, año, número de páginas, dinero
recaudado, valoración de los lectores y número de impresiones.
151 Todas las clases tienen un constructor y un override del método ToString().
152
153 Crea la interfaz IClasificable con el método CalcularPuntuacion() que devuelve un
número entero.
154 Haz que todas las clases implementen la interfaz IClasificable.
155 La puntuación de una película es la recaudación más la valoración de los espectadores
por el número de emisiones.
156 La puntuación de una canción es la recaudación más la valoración de los oyentes por
el número de emisiones.
157 La puntuación de un libro es 10 por: la recaudación más la valoración de los lectores
por el número de impresiones
158 (La puntación de un libro es mayor que la de las películas y canciones para que sean
comparables).
159
160 En Main, crea un método al que le pasamos una lista (tipo List) de objetos
IClasificable y nos devuelva el objeto con mayor puntuación.
161 En Main, crea un bucle que recorra la lista y muestre por pantalla el objeto y su
puntuación.
162
163 Se proporcionan dos objetos de cada clase ya creados para que puedas probar tu código.
164
165 Salida esperada:
166 El objeto con mayor puntuación es: Titulo: Bohemian Rhapsody, Autor: Queen, Año: 1975
167
168 Objeto: Titulo: El Padrino, Director: Francis Ford Coppola, Año: 1972. Puntuación:
1165
169 Objeto: Titulo: Titanic, Director: James Cameron, Año: 1997. Puntuación: 2881
170 Objeto: Titulo: Bohemian Rhapsody, Autor: Queen, Año: 1975. Puntuación: 9650
171 Objeto: Titulo: Believer, Autor: Imagine Dragons, Año: 2017. Puntuación: 1800
172 Objeto: Titulo: El Señor de los Anillos, Autor: J.R.R. Tolkien, Año: 1954.
Puntuación: 1245
173 Objeto: Titulo: Harry Potter y la Piedra Filosofal, Autor: J.K. Rowling, Año: 1997.
Puntuación: 4300
174 -----------------------------------------------------------------------------*/
175 public class Pelicula
176 {
177 public string Titulo { get; set; }
178 public string Director { get; set; }
179 public int Anyo { get; set; }
180 public int Duracion { get; set; } // En minutos
181 public double DineroRecaudado { get; set; } // En millones de euros
182 public double ValoracionEspectadores { get; set; }
183 public int NumeroEmisiones { get; set; } // En millones de emisiones
184
185 public Pelicula(string titulo, string director, int anyo, int duracion, double
dineroRecaudado, double valoracionEspectadores, int numeroEmisiones)
186 {
187 Titulo = titulo; Director = director; Anyo = anyo; Duracion = duracion;
DineroRecaudado = dineroRecaudado; ValoracionEspectadores =
valoracionEspectadores; NumeroEmisiones = numeroEmisiones;
188 }
189
190 public override string ToString() => $"Titulo: {Titulo}, Director: {Director},
Año: {Anyo}";
191 }
192
193 public class Cancion
194 {
195 public string Titulo { get; set; }
196 public string Autor { get; set; }
197 public int Anyo { get; set; }
198 public double Duracion { get; set; } // En minutos
199 public double DineroRecaudado { get; set; } // En millones de euros
200 public double ValoracionOyentes { get; set; }
201 public double NumeroEmisiones { get; set; } // En millones de emisiones
202
203 public Cancion(string titulo, string autor, int anyo, double duracion, double
dineroRecaudado, double valoracionOyentes, double numeroEmisiones)
204 {
205 Titulo = titulo; Autor = autor; Duracion = duracion; Anyo = anyo;
NumeroEmisiones = numeroEmisiones; ValoracionOyentes = valoracionOyentes;
DineroRecaudado = dineroRecaudado;
206 }
207
208 public override string ToString() => $"Titulo: {Titulo}, Autor: {Autor}, Año:
{Anyo}";
209 }
210
211 public class Libro
212 {
213 public string Titulo { get; set; }
214 public string Autor { get; set; }
215 public int Anyo { get; set; }
216 public int NumeroPaginas { get; set; }
217 public double DineroRecaudado { get; set; } // En millones de euros
218 public double ValoracionLectores { get; set; }
219 public double NumeroImpresiones { get; set; } // En millones de impresiones
220
221 public Libro(string titulo, string autor, int anyo, int numeroPaginas, double
dineroRecaudado, double valoracionLectores, double numeroImpresiones)
222 {
223 Titulo = titulo; Autor = autor; Anyo = anyo; NumeroPaginas = numeroPaginas;
ValoracionLectores = valoracionLectores; DineroRecaudado = dineroRecaudado;
NumeroImpresiones = numeroImpresiones;
224 }
225
226 public override string ToString() => $"Titulo: {Titulo}, Autor: {Autor}, Año:
{Anyo}";
227 }
228
229 public class Program
230 {
231 public static void Main()
232 {
233 Pelicula p1 = new Pelicula("El Padrino", "Francis Ford Coppola", 1972, 175,
245, 9.2, 100);
234 Pelicula p2 = new Pelicula("Titanic", "James Cameron", 1997, 195, 2187, 7.8,
89);
235 Cancion c1 = new Cancion("Bohemian Rhapsody", "Queen", 1975, 5.55, 150, 9.5,
1000);
236 Cancion c2 = new Cancion("Believer", "Imagine Dragons", 2017, 3.23, 100, 8.5,
200);
237 Libro l1 = new Libro("El Señor de los Anillos", "J.R.R. Tolkien", 1954, 1200,
100, 9.8, 2.5);
238 Libro l2 = new Libro("Harry Potter y la Piedra Filosofal", "J.K. Rowling",
1997, 300, 50, 9.5, 40);
239 }
240 }
241
242 // ----------------------------------------------------------------------------
243 // Ejercicio 3 (3 puntos)
244 /* ----------------------------------------------------------------------------
245 Crea la clase PoligonoRegular con las siguientes datos:
246
247 Numero de lados: número entero de sólo lectura
248 Longitud de lado: número real que se puede leer y cambiar
249 Area: número real que se puede leer y cambiar
250
251 Para estos datos usa propiedades autoimplementadas y propiedades con campo de
respaldo, lo más adecuado en cada caso.
252
253 Crea el constructor que recibe el número de lados y la longitud de los lados
254
255 Es importante que cada vez que modifiquemos la longitud de lado, se recalcule el área
y viceversa:
256 cada vez que modifiquemos el área, se recalcule la longitud de lado.
257
258 Redefine el operador binario + para que permita sumar dos polígonos regulares.
259 Si los polígonos tienen el mismo número de lados, el resultado será un polígono
regular con el mismo número de lados y la suma de las longitudes de los lados.
260 Si los polígonos tienen la misma longitud de lado, el resultado será un polígono
regular con la suma de los lados de los dos polígonos y la misma longitud del lado
261 En cualquier otro caso, el resultado será un polígono regular con la suma de los
lados y la suma de las longitudes de los lados.
262
263 Se proporcionan:
264 El método que permiten calcular el área de un polígono regular a partir de la
longitud del lado
265 El método que permite calcular la longitud del lado a partir del área.
266 Un Main de prueba
267
268 Salida esperada:
269 Número de lados: 5, Longitud del lado: 2, Área: 6,881909602355868
270 Número de lados: 5, Longitud del lado: 2,0170865516457197, Área: 7
271 Número de lados: 5, Longitud del lado: 2, Área: 6,881909602355868
272 Suma 1: Número de lados: 5, Longitud del lado: 5, Área: 43,01193501472417
273 Suma 2: Número de lados: 11, Longitud del lado: 2, Área: 37,46255962778175
274 Suma 3: Número de lados: 11, Longitud del lado: 5, Área: 234,14099767363592
275 -----------------------------------------------------------------------------*/
276
277 // public class PoligonoRegular
278 // {
279 // // Número de lados
280
281 // // Longitud del lado
282
283 // // Área
284
285 // public PoligonoRegular(int numeroLados, double longitudLado)
286 // {
287 // if (numeroLados < 3)
288 // {
289 // throw new ArgumentException("El número de lados de un polígono regular
debe ser mayor o igual a 3");
290 // }
291 // if (longitudLado <= 0)
292 // {
293 // throw new ArgumentException("La longitud de los lados de un polígono
regular debe ser mayor a 0");
294 // }
295
296 // }
297
298 // private static double CalcularArea(double numeroLados, double longitudLado)
299 // {
300 // return (numeroLados * Math.Pow(longitudLado, 2)) / (4 * Math.Tan(Math.PI /
numeroLados));
301 // }
302
303 // private static double CalculaLongitudLado(double numeroLados, double area)
304 // {
305 // return Math.Sqrt((4 * area * Math.Tan(Math.PI / numeroLados)) /
numeroLados);
306 // }
307
308 // public override string ToString()
309 // {
310 // return $"Número de lados: {NumeroLados}, Longitud del lado:
{LongitudLado}, Área: {Area}";
311 // }
312 // }
313
314 // public class Program
315 // {
316 // static void Main()
317 // {
318 // var poligono = new PoligonoRegular(5, 2);
319 // Console.WriteLine(poligono);
320 // poligono.Area = 7;
321 // Console.WriteLine(poligono);
322 // poligono.LongitudLado = 2;
323 // Console.WriteLine(poligono);
324
325 // var poligono1 = new PoligonoRegular(5, 2);
326 // var poligono2 = new PoligonoRegular(5, 3);
327 // var poligono3 = poligono1 + poligono2;
328 // Console.WriteLine($"Suma 1: {poligono3}");
329
330 // poligono1 = new PoligonoRegular(5, 2);
331 // poligono2 = new PoligonoRegular(6, 2);
332 // poligono3 = poligono1 + poligono2;
333 // Console.WriteLine($"Suma 2: {poligono3}");
334
335 // poligono1 = new PoligonoRegular(5, 2);
336 // poligono2 = new PoligonoRegular(6, 3);
337 // poligono3 = poligono1 + poligono2;
338 // Console.WriteLine($"Suma 3: {poligono3}");
339 // }
340 // }
341
342 using System;
343
344 public class PoligonoRegular
345 {
346 public int NumeroLados { get; set; }
347 public double LongitudLado { get; set; }
348 public double Area { get; set; }
349
350 public PoligonoRegular(int numeroLados, double longitudLado)
351 {
352 if (numeroLados < 3)
353 {
354 throw new ArgumentException("El número de lados de un polígono regular
debe ser mayor o igual a 3");
355 }
356 if (longitudLado <= 0)
357 {
358 throw new ArgumentException("La longitud de los lados de un polígono
regular debe ser mayor a 0");
359 }
360 NumeroLados = numeroLados;
361 LongitudLado = longitudLado;
362 Area = CalcularArea(numeroLados, longitudLado);
363 }
364
365 private static double CalcularArea(double numeroLados, double longitudLado)
366 {
367 return (numeroLados * Math.Pow(longitudLado, 2)) / (4 * Math.Tan(Math.PI /
numeroLados));
368 }
369
370 public static PoligonoRegular operator +(PoligonoRegular poligono1,
PoligonoRegular poligono2)
371 {
372 int nuevosLados = poligono1.NumeroLados + poligono2.NumeroLados;
373 double nuevaArea = poligono1.Area + poligono2.Area;
374 double nuevaLongitudLado = CalculaLongitudLado(nuevosLados, nuevaArea);
375 return new PoligonoRegular(nuevosLados, nuevaLongitudLado);
376 }
377
378 private static double CalculaLongitudLado(double numeroLados, double area)
379 {
380 return Math.Sqrt((4 * area * Math.Tan(Math.PI / numeroLados)) / numeroLados);
381 }
382
383 public override string ToString()
384 {
385 return $"Número de lados: {NumeroLados}, Longitud del lado: {LongitudLado},
Área: {Area}";
386 }
387 }
388
389 public class Program
390 {
391 static void Main()
392 {
393 var poligono = new PoligonoRegular(5, 2);
394 Console.WriteLine(poligono);
395 poligono.Area = 7;
396 Console.WriteLine(poligono);
397 poligono.LongitudLado = 2.0170865516457197;
398 Console.WriteLine(poligono);
399
400 var poligono1 = new PoligonoRegular(5, 2);
401 var poligono2 = new PoligonoRegular(5, 3);
402 var poligono3 = poligono1 + poligono2;
403 Console.WriteLine($"Suma 1: {poligono3}");
404
405 poligono1 = new PoligonoRegular(5, 2);
406 poligono2 = new PoligonoRegular(6, 2);
407 poligono3 = poligono1 + poligono2;
408 Console.WriteLine($"Suma 2: {poligono3}");
409
410 poligono1 = new PoligonoRegular(5, 2);
411 poligono2 = new PoligonoRegular(6, 3);
412 poligono3 = poligono1 + poligono2;
413 Console.WriteLine($"Suma 3: {poligono3}");
414 }
415 }