Sunteți pe pagina 1din 12
Ejercicio 1   1 2 /** * 3 * 4 * 5 minúscula. Para 6

Ejercicio 1

 

1

2

/**

*

3

*

4

*

5

minúscula. Para

6

*

7

*

8

carácter no es

9

*

10

transformar).

*

11

12

*/

13

#include <iostream>

14

15

using namespace std;

16

17

/**

18

*

*

19

20

21

22

23

int main()

24

{

25

char mayus;

26

27

28

29

30

31

}

32

33

34

return c+32;

35

else

36

return c;

37

}

</iostream>

38

char may2Minus(char);

Escriba un programa que lea una letra mayúscula y la escriba en

ello, defina una función “May2minuscula” que recibe como parámetro un “char” y

devuelve su correspondiente minúscula. Tenga en cuenta que si el

una letra mayúscula, deberá devolver el mismo carácter (sin

@param c: Caracter en mayuscula

@return: El caracter c en minuscula. Si el parametro no es correcto, no se transforma. */

cout << "Introduce una letra en MAYUSCULA: "; cin >> mayus; cout << endl; cout << "Transformación: " << may2Minus(mayus) << endl; return 0;

char may2Minus(char c){

if (c >= 'A' && c <='Z')

Ej. 2

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

/**

*

* Escriba un programa que lea una letra e indique si corresponde a una respuesta

* afirmativa (una letra 's' o 'y'). Para ello, defina una función

“EsAfirmativo” a la que

* se le pasa un carácter y devuelve si la respuesta ha sido

afirmativa.

* Como la entrada puede ser tanto minúscula como mayúscula, use la función del

* ejercicio anterior para transformar el carácter de entrada de

forma que 'S' y 'Y' sean

* consideradas también como respuestas afirmativas.

*

*/

#include <iostream>

using namespace std;

/**

* @param c: Caracter en mayuscula

* @return: El caracter c en minuscula. Si el parametro no es correcto, no se transforma.

*/

char may2Minus(char);

/**

* @param answer: La respuesta introducida

* @return: true si la respuesta es afirmativa

*/

bool esAfirmativo(char);

int main()

{

char letra;

cout << "Introduce una letra (s ó y) para respuesta afirmativa:

";

cin >> letra;

cout << endl;

char respuesta = esAfirmativo(letra) ? 'S' : 'N';

cout << "¿La respuesta fue afirmativa?: " << respuesta << endl; return 0;

}

char may2Minus(char c){ if (c >= 'A' && c <='Z') return c+32;

}

else

return c;

bool esAfirmativo(char letra){ if (may2Minus(letra) == 's' || may2Minus(letra) == 'y')

49

50

return true;

51

else

52

return false;

53

}

54

</iostream>

55

 

Ej. 3

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

 

/**

*

*

*

Escriba un programa que reciba dos números, uno real y otro

entero, y que obtenga

* en la salida el resultado de elevar el primero al segundo. Para

ello, incluya una

*

función “Potencia” que devuelva el resultado de esa expresión.

*

Nota: no puede hacer uso de la función de biblioteca “pow”.

*

*/

#include <iostream>

using namespace std;

/**

* @param real: Base de la potencia

* @param entero: Exponente

* @return double: Resultado de real^entero

*/

double potencia(double, int);

int main()

{

int base;

double exponente;

cout << "Introduce una base y un exponente (Separados por espacios): "; cin >> base; cin >> exponente;

cout << "Potencia: " << potencia(exponente, base);

return 0;

}

double potencia(double exp, int base){

double res = base;

for (int i=1; i<exp; i++)

res *= base;

return res;

/**

* Más formas de hacerlo

* while (--exp)

41

42

43

44

45

46

*

47

*

*/

48

49

}

50

</iostream>

51

52

53

Ej. 4

* res *= base;

* return res;

*--------------------------------

for (int i=exp; i > 1; res *= base, i--);

return res;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

 

/**

*

*

Escriba un programa que lea 4 números a, b, c y d que definen el

polinomio

* ax³ + b*x² + c*x d , que lo evalúe en un punto y que muestre ese

valor. Para ello,

* defina la función “Evaluar” que recibe los cuatro valores junto con un valor x donde

* evaluarlo, y que devuelve un número resultado de la evaluación. Para resolverlo, por

* un lado deberá reutilizar la función “Potencia” del ejercicio

anterior, y por otro,

* evitar declarar ninguna variable local en la función “Evaluar”.

*

*/

#include <iostream>

using namespace std;

double potencia(double, int); double evaluar(double, double, double, double, double);

int main()

{

double a,b,c,d,x;

cout << "Introduzca números para a,b,c,d separados por espacios:

";

cin >> a; cin >> b; cin >> c; cin >> d; cout << "\nIntroduzca un valor x para evaluar el polinomio ax³ + bx² + cx + d: "; cin >> x; cout << "\nEl resultado para estos datos es: " <<

evaluar(a,b,c,d,x);

35

36

}

37

38

/**

39

40

41

42

43

}

44

/**

45

46

47

48

49

50

51

52

53

54

}

55

</iostream>

56

Ej. 9

* @param x: punto en el que evaluar el valor del polinomio

* @return: El valor de polinomio para x

*/ double evaluar(double a, double b, double c, double d, double x){ return a*potencia(3,x) + b*potencia(2,x) + c*x + d;

* @param exp: Base de la potencia

* @param base: Exponente

* @return double: Resultado de real^entero

*/ double potencia(double exp, int base){

double res=base;

for (int i=1; i < exp; i++) res*=base; return res;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

 

/**

*

*

Escriba una función “Intercambiar” para intercambiar el valor de

dos variables de

* tipo “double”. Es decir, en la llamada se pasarán dos variables y,

después de ella, los

*

valores de ambas estarán intercambiados.

*

*/

#include <iostream>

using namespace std;

/**

* Función que intercambia los valores de los parametros dados.

*/ void intercambiar(double& una, double& otra){

double aux = una;

una = otra;

otra = aux;

}

int main()

{

double una, otra;

cout << "Dame dos nunmeros y los intercambio: ";

cin >> una >> otra;

26

27

28

29

30

31

}

32

</iostream>

33

Ej. 10

1

2

/**

3

*

4

5

*

6

*

7

8

*

9

*/

10

11

12

13

14

/**

15

*

16

17

18

19

20

}

21

22

23

24

}

25

26

int main()

27

{

28

29

30

31

32

33

34

35

}

36

</iostream>

37

return 0;

cout << "Antes una= " << una << " y otra= " << otra << endl;

intercambiar(una, otra);

cout << "Ahora una= " << una << " y otra= " << otra << endl;

Escriba una función “Ordenar2” para ordenar los valores de dos

variables de tipo

“double”. Es decir, en la llamada se pasarán dos variables y, al finalizar, la primera

variable tendrá el menor y la segunda el mayor de los valores.

Para resolverlo, use la

función “Intercambiar” del ejercicio anterior.

#include <iostream>

using namespace std;

Función que intercambia los valores de los parametros dados.

*/ void intercambiar(double& una, double& otra){ double aux = una; una = otra; otra = aux;

void ordenar2(double& menor, double& mayor){ if (menor > mayor) intercambiar(menor, mayor);

double n1, n2;

cout << "Introduce dos número y te los devuelvo ordenados: "; cin >> n1 >> n2; ordenar2(n1, n2);

cout << n1 << " " << n2;

Ej. 11

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

 

/**

*

*

Escriba una función “Ordenar3” para ordenar los valores de tres

variables de tipo

* “double”. Es decir, en la llamada se pasarán tres variables y, después de ella, la

* primera variable tendrá el menor, la segunda el mediano y la

tercera el mayor de los

* valores. Para resolverlo, use la función “Ordenar2” del ejercicio anterior teniendo en

* cuenta que para que tres valores queden ordenados, basta con

ordenar los dos

*

primeros, luego los dos segundos y de nuevo los dos primeros.

*

*/

#include <iostream>

using namespace std;

/**

* Función que intercambia los valores de los parametros dados.

*/ void intercambiar(double& una, double& otra){ double aux = una; una = otra; otra = aux;

}

void ordenar2(double& menor, double& mayor){ if (menor > mayor) intercambiar(menor, mayor);

}

void ordenar3(double& a, double& b, double& c){

ordenar2(a,b);

ordenar2(b,c);

ordenar2(a,b);

}

int main()

{

double a,b,c;

cout << "Introduce 3 numeros y los ordeno de menor a mayor: "; cin >> a >> b >> c; cout << "Antes a=" << a << " b=" << b << " c=" << c << endl;

ordenar3(a,b,c);

cout << "Ahora a=" << a << " b=" << b << " c=" << c << endl;

return 0;

}

</iostream>

Ej. 12

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

 

/**

*

*

Escriba una función “Triangulo” que devuelva el tipo de un

triángulo definido a

* partir de las tres longitudes de sus lados. Como puede

* comprobar, será necesario ordenar los tres valores para usar

exactamente los

* mismos pasos, por lo que deberá usar la función “Ordenar3” del ejercicio anterior. El

* valor devuelto será 0 para indicar que no es un triángulo, 1 para

indicar que se trata

* de un triángulo isósceles, 2 para el tipo escaleno y 3 para el

equilátero.

* Finalmente, escriba una función “main” para probar este código, en

la que se

* declararán tres variables para almacenar las tres longitudes, y se

llamará a la

* función anterior para determinar el tipo de triángulo, de forma

que se pueda escribir

* en la salida estándar el mensaje correspondiente.

*

*/

#include <iostream>

using namespace std;

void intercambiar(double&, double&); void ordenar2(double&, double&); void ordenar3(double&, double&, double&);

unsigned short int triangulo(double, double, double);

int main(){

double a,b,c;

cout << "Introduzca los tres lados del triángulo: "; cin >> a >> b >> c;

switch (triangulo(a,b,c)){

case 0:

cout << "No es triángulo" << endl; break; case 1:

cout << "Isósceles" << endl;

break;

case 2:

cout << "Escaleno" << endl; break; case 3:

cout << "Equilátero" << endl;

break;

}

}

/**

* Función que intercambia los valores de los parametros dados.

49

50

51

52

53

54

55

56

}

57

58

/**

59

*

60

61

62

63

}

64

65

/**

*

66

*/

67

68

69

70

71

}

72

73

74

75

76

77

78

79

80

}

81

</iostream>

82

83

84

Ej. 14

*/ void intercambiar(double& una, double& otra){ double aux = una; una = otra; otra = aux;

Función que ordena de menor a mayor dos valores dados.

*/ void ordenar2(double& menor, double& mayor){ if (menor > mayor)

intercambiar(menor, mayor);

Función que ordena de menor a mayor 3 valores dados.

void ordenar3(double& a, double& b, double& c){

ordenar2(a,b);

ordenar2(b,c);

ordenar2(a,b);

unsigned short int triangulo(double a, double b, double c){

//Ordenamos los valores

ordenar3(a,b,c);

if (a+b<=c) return 0; else if (a==b && b==c) return 3; else if (a==b || b==c) return 1; else return 2;

1

2

3

4

5

6

7

8

9

10

/**

*

* Considere el ejercicio 12, donde han usado un par de funciones de ordenación (para

* 2 y para 3 datos). Modifique el programa de manera que las dos

funciones tengan el

* mismo nombre “Ordenar”, y compruebe que sigue funcionando correctamente.

*

*/

#include <iostream>

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

using namespace std;

void intercambiar(double&, double&); unsigned short int triangulo(double, double, double);

int main(){

double a,b,c;

cout << "Introduzca los tres lados del triángulo: ";

cin >> a >> b >> c;

switch (triangulo(a,b,c)){ case 0:

cout << "No es triángulo" << endl;

break;

case 1:

cout << "Isósceles" << endl; break; case 2:

cout << "Escaleno" << endl;

break;

case 3:

cout << "Equilátero" << endl; break;

}

}

/**

* Función que intercambia los valores de los parametros dados.

*/ void intercambiar(double& una, double& otra){ double aux = una;

una = otra;

otra = aux;

}

/**

* Función que ordena de menor a mayor dos valores dados.

*/ void ordenar(double& menor, double& mayor){ if (menor > mayor) intercambiar(menor, mayor);

}

/**

* Función que ordena de menor a mayor 3 valores dados.

*/ void ordenar(double& a, double& b, double& c){ ordenar(a,b); ordenar(b,c); ordenar(a,b);

}

unsigned short int triangulo(double a, double b, double c){

//Ordenamos los valores ordenar(a,b,c);

62

63

64

65

66

67

68

69

70

71

}

</iostream>

72

73

74

75

Ej. 17

if (a+b<=c) return 0;

else if (a==b && b==c) return 3;

else if (a==b || b==c) return 1;

else return 2;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

/**

*

* Considere el siguiente sistema de 2 ecuaciones con 2 incógnitas, así como sus

* correspondientes soluciones:

* El sistema es compatible determinado (tiene una solución) si

a e−b d≠0 mientras

* que tiene cero o infinitas soluciones en caso contrario.

* Escriba un programa para obtener la solución de un sistema

compatible

* determinado. Para ello, deberá leer los 6 valores que determinan

el problema y

* obtener por pantalla el correspondiente par de valores (x,y)

-solución del sistema- o

* un mensaje indicando que no es compatible determinado. Para ello, defina una

* función que, a partir del sistema, obtiene las soluciones. Además,

esta función

* devuelve un entero que indica si ha habido algún error, ya que es

posible que el

* sistema no tenga una solución.

*

*/

#include <iostream>

using namespace std;

/**

* @Param Double& double&: Solución del sistema.

* @return: Codigo de finalización de la función

*/

int resuleveSistema(double, double, double, double, double, double,

double&, double&);

int main()

{

double a,e,b,f,d,c,x,y;

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

cout << "Introduce a, e , b, f, d , c: "; cin >> a >> e >> b >> f >> d >> c;

if (resuleveSistema(a,e,b,f,d,c,x,y))

cout << "No es compatible determinado";

else

cout << "Solución: x=" << x << " y=" << y; return 0;

}

int resuleveSistema(double a, double e, double b, double f, double d, double c, double& x, double& y){ if (!(a*e - b*d)) return 1; else{

x = (c*e - b*f) / (a*e - b*d);

y = (a*f - c*d) / (a*e - b*d);

return 0;

}

}

</iostream>