T茅cnicas y elementos de programaci贸n
Algoritmos en PASCAL y C
Ejercicio ALG.00.01 en PASCAL (**********************************************************************) (* Alg_10_06 *) (* *) (* Programa que prueba los diferentes formatos de impresi贸n en PASCAL *) (**********************************************************************) PROGRAM ALG_10_06 (input,output); VAR dato1 dato2 dato3 , dato4 dato5 , dato6
: : : :
INTEGER; REAL; CHAR; BOOLEAN;
BEGIN WRITELN('ALG.10.06 : pruebas de formatos de impresi贸n'); WRITELN('--------------------------------------------'); WRITELN ; (* Inicializamos las variables *) dato1 := 205; dato2 := 205.5; dato3 := 'a'; dato4 := 'b'; dato5 := TRUE ; dato6 := FALSE ; (* Pruebas *) WRITELN('Entero 205 sin formato 2 veces :' , dato1 , dato1); WRITELN('Entero 205 con formato (:6) :' , dato1:6); WRITELN('Real 205.5 sin formato :' , dato2); WRITELN('Real 205.5 con formato (:6) :' , dato2:6); WRITELN('Real 205.5 con formato (:10) :' , dato2:10); WRITELN('Real 205.5 con formato (:10:0) :' , dato2:10:0); WRITELN('Real 205.5 con formato (:10:2) :' , dato2:10:2); WRITELN; WRITELN('Char "a" y "b" sin formato :' , dato3 , dato4); WRITELN('Char "a" y "b" con formato (:6) :' , dato3:6 , dato4:6); WRITELN('Literal "mesa" y "silla" sin formato :' , 'mesa' , 'silla'); WRITELN('Literal "mesa" y "silla" con formato (:6) :' , 'mesa':6 , 'silla':6); WRITELN; WRITELN('L铆nea completa con entero 205(:6), real 205.5(:8:2) y "mesa"(:8)'); WRITELN(dato1:6 , dato2:8:2 , 'mesa':8); WRITELN; WRITELN('Boolean verdad y falso sin formato :' ,dato5 , dato6) ; WRITELN('boolean verdad y falso con formato (:8) :' ,dato5:8 , dato6:8); END.
ALG.10.06 : pruebas de formatos de impresi贸n -------------------------------------------Entero 205 Entero 205 Real 205.5 Real 205.5 Real 205.5 Real 205.5 Real 205.5
sin con sin con con con con
Char "a" y "b" Char "a" y "b" Literal "mesa" Literal "mesa"
formato formato formato formato formato formato formato
2 veces :205205 (:6) : 205 : 2.0550000000E+02 (:6) : 2.1E+02 (:10) : 2.055E+02 (:10:0) : 206 (:10:2) : 205.50
sin formato :ab con formato (:6) : a b y "silla" sin formato :mesasilla y "silla" con formato (:6) : mesa silla
Linea completa con entero 205(:6), real 205.5(:8:2) y "mesa"(:8) 205 205.50 mesa Boolean verdad y falso sin formato :TRUEFALSE boolean verdad y falso con formato (:8) : TRUE
FALSE
Ejercicio ALG.00.01 en C /*****************************************************************/ /* Alg_10_06 */ /* */ /* Programa que prueba los diferentes formatos de impresión en C */ /*****************************************************************/
#include <stdio.h>
void main (void) { /* Definición de variables. En C no existe el tipo BOOLEAN */ int dato1; float dato2; char dato3 , dato4; printf("ALG.10.06 : pruebas de formatos de impresión\n"); printf("--------------------------------------------\n\n"); /* Inicializamos las variables */ dato1 = 205; dato2 = 205.5; dato3 = 'a'; dato4 = 'b'; /* Pruebas */ printf("Entero 205 printf("Entero 205 printf("Real 205.5 printf("Real 205.5 printf("Real 205.5 printf("Real 205.5 printf("Real 205.5
sin con sin con con con con
printf("Char 'a' y 'b' printf("Char 'a' y 'b' printf("Literal 'mesa' printf("Literal 'mesa'
formato formato formato formato formato formato formato
2 veces : %i %i\n" (6) : %6i\n" : %f\n" (exp) : %e\n" (12) : %12f\n" (12.0) : %12.0f\n" (12.2) : %12.2f\n\n"
, , , , , , ,
dato1 , dato1); dato1); dato2); dato2); dato2); dato2); dato2);
sin formato : %c %c\n" , dato3 , dato4); con formato (6) : %6c %6c\n" , dato3 , dato4); y 'silla' sin formato : %s %s\n" , "mesa" , "silla"); y 'silla' con formato (6) : %6s %6s\n\n" , "mesa" , "silla");
printf("Línea completa con entero 205(6), real 205.5(8.2) y 'mesa'(8)\n"); printf("%6i %8.2f %8s\n\n" , dato1 , dato2 , "mesa"); }
ALG.10.06 : pruebas de formatos de impresión -------------------------------------------Entero 205 Entero 205 Real 205.5 Real 205.5 Real 205.5 Real 205.5 Real 205.5
sin con sin con con con con
Char 'a' y 'b' Char 'a' y 'b' Literal 'mesa' Literal 'mesa'
formato formato formato formato formato formato formato
2 veces : 205 205 (6) : 205 : 205.500000 (exp) : 2.055000e+02 (12) : 205.500000 (12.0) : 206 (12.2) : 205.50
sin formato : a b con formato (6) : a b y 'silla' sin formato : mesa silla y 'silla' con formato (6) : mesa silla
Linea completa con entero 205(6), real 205.5(8.2) y 'mesa'(8) 205 205.50 mesa
Ejercicio ALG.01.01 en PASCAL (************************************) (* Alg_01_01 *) (* *) (* Algoritmo para sumar dos números *) (************************************) PROGRAM Alg_01_01(input,output); VAR a , b , s : REAL; BEGIN WRITELN('ALG.01.01 : algoritmo para sumar dos números'); WRITELN('--------------------------------------------'); WRITELN; WRITE('Introduzca dos números : '); READLN(a , b); s := a + b; WRITELN; WRITELN('El resultado es ' , s:6:2); END.
Ejercicio ALG.01.01 en C /************************************/ /* Alg_01_01 */ /* */ /* Algoritmo para sumar dos números */ /************************************/
#include <stdio.h>
void main (void) { float a , b , s; printf("ALG.01.01 : algoritmo para sumar dos números\n"); printf("--------------------------------------------\n\n"); printf("Introduzca dos números : "); scanf("%f %f", &a , &b); s = a + b; printf("\nEl resultado es %6.2f\n" , s); }
Ejercicio ALG.01.02 en PASCAL (*************************************************) (* Alg_01_02 *) (* *) (* Algoritmo para calcular el área de un círculo *) (*************************************************) PROGRAM Alg_01_02(input,output); VAR r , area : REAL; BEGIN WRITELN('ALG.01.02 : algoritmo para calcular el área de un círculo'); WRITELN('---------------------------------------------------------'); WRITELN; WRITE('Introduzca el radio : '); READLN(r); area := PI * SQR(r); WRITELN; WRITELN('El resultado es ' , area:6:2); END.
Ejercicio ALG.01.02 en C /*************************************************/ /* Alg_01_02 */ /* */ /* Algoritmo para calcular el área de un círculo */ /*************************************************/
#include <stdio.h> #include <math.h>
void main (void) { float r , area; printf("ALG.01.02 : algoritmo para calcular el área de un círculo\n"); printf("---------------------------------------------------------\n\n"); printf("Introduzca el radio : "); scanf("%f", &r); area = M_PI * r * r; printf("\nEl resultado es %6.2f\n" , area); }
Ejercicio ALG.02.01 v1 en PASCAL (**********************************************************) (* Alg_02_01_v1 *) (* *) (* Algoritmo que dados dos números enteros que entran *) (* como datos, dice si uno es divisor del otro. *) (**********************************************************) PROGRAM Alg_02_01_v1(input,output); VAR dato1 , dato2 : INTEGER; BEGIN WRITELN('ALG.02.01 v1 : divisibilidad entre números enteros'); WRITELN('--------------------------------------------------'); WRITELN ; WRITE('Introduzca dos números enteros : '); READLN(dato1 , dato2); WRITELN; IF dato1 > dato2 THEN (* dato2 puede ser divisor *) IF (dato1 mod dato2) = 0 THEN WRITELN(dato2 , ' es divisor de ' , dato1) ELSE WRITELN('No son divisores') ELSE IF dato1 < dato2 THEN (* dato1 puede ser divisor *) IF (dato2 mod dato1) = 0 THEN WRITELN(dato1 , ' es divisor de ' , dato2) ELSE WRITELN('No son divisores') ELSE WRITELN('Son iguales') ; (* FIN del IF *) END.
Ejercicio ALG.02.01 v1 en C /**********************************************************/ /* Alg_02_01_v1 */ /* */ /* Algoritmo que dados dos nĂşmeros enteros que entran */ /* como datos, dice si uno es divisor del otro. */ /**********************************************************/
#include <stdio.h>
void main (void) { int dato1 , dato2; printf("ALG.02.01 v1 : divisibilidad entre nĂşmeros enteros\n"); printf("--------------------------------------------------\n\n"); printf("Introduzca dos nĂşmeros enteros : "); scanf("%i %i", &dato1 , &dato2); if ( dato1 > dato2 ) /* dato2 puede ser divisor */ if ( ( dato1 % dato2 ) == 0 ) printf("%i es divisor de %i\n" , dato2, dato1); else printf("No son divisores\n"); else if ( dato1 < dato2 ) /* dato1 puede ser divisor */ if ( ( dato2 % dato1 ) == 0 ) printf("%i es divisor de %i\n" , dato1, dato2); else printf("No son divisores\n"); else printf("Son iguales\n"); }
Ejercicio ALG.02.01 v2 en PASCAL (**********************************************************) (* Alg_02_01_v2 *) (* *) (* Algoritmo que dados dos números enteros que entran *) (* como datos, dice si uno es divisor del otro. *) (**********************************************************) PROGRAM palg_02_01_v2(input,output); VAR dato1 , dato2 : INTEGER; mayor , menor : INTEGER; BEGIN WRITELN('ALG.02.01 v2 : divisibilidad entre números enteros'); WRITELN('--------------------------------------------------'); WRITELN ; WRITE('Introduzca dos números enteros : '); READLN(dato1 , dato2); WRITELN; IF dato1 = dato2 THEN WRITELN('Son iguales') ELSE BEGIN (* Guardamos cual es el mayor y el menor de los dos datos *) IF dato1 > dato2 THEN BEGIN mayor := dato1; menor := dato2; END ELSE BEGIN mayor := dato2; menor := dato1; END; (* Comprueba si menor es divisor de mayor *) IF (mayor mod menor) = 0 THEN WRITELN(menor , ' es divisor de ' , mayor) ELSE WRITELN('No son divisores'); END ; (* FIN del IF *) END.
Ejercicio ALG.02.01 v2 en C /**********************************************************/ /* Alg_02_01_v2 */ /* */ /* Algoritmo que dados dos nĂşmeros enteros que entran */ /* como datos, dice si uno es divisor del otro. */ /**********************************************************/
#include <stdio.h>
void main (void) { int dato1 , dato2; int mayor , menor; printf("ALG.02.01 v2 : divisibilidad entre nĂşmeros enteros\n"); printf("--------------------------------------------------\n\n"); printf("Introduzca dos nĂşmeros enteros : "); scanf("%i %i", &dato1 , &dato2); if ( dato1 == dato2 ) printf("Son iguales\n"); else { /* Guardamos cual es el mayor y el menor de los dos datos */ if ( dato1 > dato2 ) { mayor = dato1; menor = dato2; } else { mayor = dato2; menor = dato1; } /* Comprueba si menor es divisor de mayor */ if ( ( mayor % menor ) == 0 ) printf("%i es divisor de %i\n" , menor, mayor); else printf("No son divisores\n"); }; }
Ejercicio ALG.02.02 en PASCAL (*****************************************************************) (* Alg_02_02 *) (* *) (* Algoritmo que dado un número real que entra como dato, nos *) (* dice si está contenido dentro de unos límites predeterminados *) (*****************************************************************) PROGRAM Alg_02_02 (input,output); CONST LINF = 100; LSUP = 200; VAR dato : REAL; BEGIN WRITELN('ALG.02.02 : algoritmo de comprobación de límites'); WRITELN('------------------------------------------------'); WRITELN; WRITE('Introduce el número : '); READLN(dato); IF dato >=
LINF
THEN IF dato <= LSUP THEN WRITELN('Está dentro del intervalo [' , LINF , ',' , LSUP , ']') ELSE WRITELN('Supera el máximo') ELSE WRITELN('No alcanza el mínimo') ; (* FIN del IF *) END.
Ejercicio ALG.02.02 en C /*****************************************************************/ /* Alg_02_02 */ /* */ /* Algoritmo que dado un número real que entra como dato, nos */ /* dice si está contenido dentro de unos límites predeterminados */ /*****************************************************************/
#include <stdio.h>
#define LINF 100 #define LSUP 200
void main (void) { float dato; printf("ALG.02.02 : algoritmo de comprobación de límites\n"); printf("------------------------------------------------\n\n"); printf("Introduce el número : "); scanf("%f", &dato); if ( dato >=
LINF )
if ( dato <= LSUP ) printf("Está dentro del intervalo [%i,%i]\n", LINF, LSUP); else printf("Supera el máximo\n"); else printf("No alcanza el mínimo\n"); }
Ejercicio ALG.03.01 v1 en PASCAL (********************************************************************) (* Alg_03_01_v1 *) (* *) (* Algoritmo que calcula la suma de los n primeros números enteros. *) (* Utiliza la estructura iterativa WHILE. *) (********************************************************************) PROGRAM Alg_03_01_v1 (input,output); VAR n, numero, suma : INTEGER; BEGIN WRITELN('ALG.03.01 v1 : suma de los n primeros números enteros'); WRITELN('-----------------------------------------------------'); WRITELN; WRITE('¿ Hasta que entero quiere sumar ? '); READLN(n); numero := 1; suma := 0; WHILE numero <= n DO BEGIN suma := suma + numero; numero := numero + 1; END; WRITELN('La suma es ', suma); END.
Ejercicio ALG.03.01 v1 en C /********************************************************************/ /* Alg_03_01_v1 */ /* */ /* Algoritmo que calcula la suma de los n primeros nĂşmeros enteros. */ /* Utiliza la estructura iterativa 'while'. */ /********************************************************************/
#include <stdio.h>
void main (void) { int n, numero, suma; printf("ALG.03.01 v1 : suma de los n primeros nĂşmeros enteros\n"); printf("-----------------------------------------------------\n\n"); printf("Âż Hasta que entero quiere sumar ? "); scanf("%i", &n); numero = 1; suma = 0; while ( numero <= n ) { suma += numero; numero++; };
/* Equivale a /* Equivale a
printf("\nLa suma es %i\n", suma); }
suma = suma + numero; numero = numero + 1;
*/ */
Ejercicio ALG.03.01 v2 en PASCAL (********************************************************************) (* Alg_03_01_v2 *) (* *) (* Algoritmo que calcula la suma de los n primeros números enteros. *) (* Utiliza la estructura iterativa REPEAT. *) (* Nótese que falla en el caso n = 0, ya que el bucle como mínimo *) (* realiza siempre una iteración. *) (********************************************************************) PROGRAM Alg_03_01_v2 (input,output); VAR n, numero, suma : INTEGER; BEGIN WRITELN('ALG.03.01 v2 : suma de los n primeros números enteros'); WRITELN('-----------------------------------------------------'); WRITELN; WRITE('¿ Hasta que entero quiere sumar ? '); READLN(n); numero := 1; suma := 0; REPEAT suma := suma + numero; numero := numero + 1; UNTIL numero > n; WRITELN('La suma es ', suma); END.
Ejercicio ALG.03.01 v2 en C /********************************************************************/ /* Alg_03_01_v2 */ /* */ /* Algoritmo que calcula la suma de los n primeros números enteros. */ /* Utiliza la estructura iterativa 'do - while'. */ /* Nótese que falla en el caso n = 0, ya que el bucle como mínimo */ /* realiza siempre una iteración. */ /********************************************************************/
#include <stdio.h>
void main (void) { int n, numero, suma; printf("ALG.03.01 v2 : suma de los n primeros números enteros\n"); printf("-----------------------------------------------------\n\n"); printf("¿ Hasta que entero quiere sumar ? "); scanf("%i", &n); numero = 1; suma = 0; do { suma += numero; numero++; } while ( numero <= n );
/* Equivale a /* Equivale a
printf("\nLa suma es %i\n", suma); }
suma = suma + numero; numero = numero + 1;
*/ */
Ejercicio ALG.03.02 en PASCAL (********************************************************************) (* Alg_03_02_v1 *) (* *) (* Algoritmo que calcula e imprime los n primeros números de la *) (* serie de Fibonacci definida como: *) (* *) (* Fibo(0) = 0 *) (* Fibo(1) = 1 *) (* Fibo(i) = Fibo(i-1) + Fibo(i-2) para i > 1 *) (* *) (* Se supone n >= 2 *) (********************************************************************) PROGRAM Alg_03_02_v1 (input,output); VAR n fibo actual anterior contador
: : : : :
INTEGER; INTEGER; INTEGER; INTEGER; INTEGER;
(* (* (* (* (*
Número de términos a calcular Representa el término Fibo(i) Representa el término Fibo(i-1) Representa el término Fibo(i-2) Representa el índice 'i'
*) *) *) *) *)
BEGIN WRITELN('ALG.03.02 v1 : serie de Fibonacci'); WRITELN('---------------------------------'); WRITELN; WRITE('¿ Cuántos términos de la serie quiere calcular ? '); READLN(n); (* Fibo(0) = 0 anterior := 0; actual := 1;
y
Fibo(1) = 1 *)
(* Escribe los dos primeros términos *) WRITELN(anterior); WRITELN(actual); contador := 2; WHILE contador < n DO BEGIN (* Calcula el nuevo término fibo := anterior + actual; WRITELN(fibo);
Fibo(i) = Fibo(i-1) + Fibo(i-2) *)
(* Actualiza Fibo(i-2) , Fibo(i-1) y 'i' *) anterior := actual; actual := fibo; contador := contador + 1; END; END.
Ejercicio ALG.03.02 en C /********************************************************************/ /* Alg_03_02_v1 */ /* */ /* Algoritmo que calcula e imprime los n primeros números de la */ /* serie de Fibonacci definida como: */ /* */ /* Fibo(0) = 0 */ /* Fibo(1) = 1 */ /* Fibo(i) = Fibo(i-1) + Fibo(i-2) para i > 1 */ /* */ /* Se supone n >= 2 */ /********************************************************************/
#include <stdio.h>
void main (void) { int int int int int
n; fibo; actual; anterior; contador;
/* /* /* /* /*
Número de términos a calcular Representa el término Fibo(i) Representa el término Fibo(i-1) Representa el término Fibo(i-2) Representa el índice 'i'
printf("ALG.03.02 v1 : serie de Fibonacci\n"); printf("---------------------------------\n\n");
*/ */ */ */ */
printf("¿ Cuántos términos de la serie quiere calcular ? "); scanf("%i", &n); /* Fibo(0) = 0 anterior = 0; actual = 1;
y
Fibo(1) = 1 */
/* Escribe los dos primeros términos */ printf("%i\n", anterior); printf("%i\n", actual); contador = 2; while ( contador < n ) { /* Calcula el nuevo término fibo = anterior + actual; printf("%i\n", fibo);
Fibo(i) = Fibo(i-1) + Fibo(i-2) */
/* Actualiza Fibo(i-2) , Fibo(i-1) y 'i' */ anterior = actual; actual = fibo; contador++; }; }
Ejercicio ALG.03.03 v1 en PASCAL (************************************************************************) (* Alg_03_03_v1 *) (* *) (* Algoritmo que calcula el producto de los n primeros números enteros. *) (* Utiliza la estructura iterativa WHILE. *) (************************************************************************) PROGRAM Alg_03_03_v1 (input,output); VAR n, aux, factorial : INTEGER; BEGIN WRITELN('ALG.03.03 v1 : factorial'); WRITELN('------------------------'); WRITELN; WRITE('Introduzca un número entero : '); READLN(n); factorial := 1; aux := 2; WHILE aux <= n DO BEGIN factorial := factorial * aux; aux := aux + 1; END; WRITELN('El factorial de ', n, ' es ', factorial); END.
Ejercicio ALG.03.03 v1 en C /************************************************************************/ /* Alg_03_03_v1 */ /* */ /* Algoritmo que calcula el producto de los n primeros nĂşmeros enteros. */ /* Utiliza la estructura iterativa 'while'. */ /************************************************************************/
#include <stdio.h>
void main (void) { int n, aux, factorial; printf("ALG.03.03 v1 : factorial\n"); printf("------------------------\n\n"); printf("Introduzca un nĂşmero entero : "); scanf("%i", &n); factorial = 1; aux = 2; while ( aux <= n ) { factorial *= aux; aux++; };
/* Equivale a /* Equivale a
factorial = factorial * aux; aux = aux + 1;
printf("\nEl factorial de %i es %i\n", n, factorial); }
*/ */
Ejercicio ALG.03.03 v2 en PASCAL (************************************************************************) (* Alg_03_03_v2 *) (* *) (* Algoritmo que calcula el producto de los n primeros números enteros. *) (* Utiliza la estructura iterativa REPEAT. *) (* Nótese que falla en los casos n < 2, ya que el bucle como mínimo *) (* realiza siempre una iteración. *) (************************************************************************) PROGRAM Alg_03_03_v2 (input,output); VAR n, aux, factorial : INTEGER; BEGIN WRITELN('ALG.03.03 v2 : factorial'); WRITELN('------------------------'); WRITELN; WRITE('Introduzca un número entero : '); READLN(n); factorial := 1; aux := 2; REPEAT factorial := factorial * aux; aux := aux + 1; UNTIL aux > n; WRITELN('El factorial de ', n, ' es ', factorial); END.
Ejercicio ALG.03.03 v2 en C /************************************************************************/ /* Alg_03_03_v2 */ /* */ /* Algoritmo que calcula el producto de los n primeros números enteros. */ /* Utiliza la estructura iterativa 'do - while'. */ /* Nótese que falla en los casos n < 2, ya que el bucle como mínimo */ /* realiza siempre una iteración. */ /************************************************************************/
#include <stdio.h>
void main (void) { int n, aux, factorial; printf("ALG.03.03 v2 : factorial\n"); printf("------------------------\n\n"); printf("Introduzca un número entero : "); scanf("%i", &n); factorial = 1; aux = 2; do { factorial *= aux; aux++; } while ( aux <= n );
/* Equivale a /* Equivale a
factorial = factorial * aux; aux = aux + 1;
printf("\nEl factorial de %i es %i\n", n, factorial); }
*/ */
Ejercicio ALG.03.03 v3 en PASCAL (************************************************************************) (* Alg_03_03_v3 *) (* *) (* Algoritmo que calcula el producto de los n primeros números enteros. *) (* Comprobaremos que el valor entrado de n sea válido (n >= 0). *) (* Utiliza la estructura iterativa WHILE. *) (************************************************************************) PROGRAM Alg_03_03_v3 (input,output); VAR n, aux, factorial : INTEGER; BEGIN WRITELN('ALG.03.03 v3 : factorial'); WRITELN('------------------------'); WRITELN; REPEAT WRITE('Introduzca un número entero : '); READLN(n); UNTIL n >= 0; factorial := n; aux := n - 1; WHILE aux > 1 DO BEGIN factorial := factorial * aux; aux := aux - 1; END; WRITELN('El factorial de ', n, ' es ', factorial); END.
Ejercicio ALG.03.03 v3 en C /************************************************************************/ /* Alg_03_03_v3 */ /* */ /* Algoritmo que calcula el producto de los n primeros números enteros. */ /* Comprobaremos que el valor entrado de n sea válido (n >= 0). */ /* Utiliza la estructura iterativa 'while'. */ /************************************************************************/
#include <stdio.h>
void main (void) { int n, aux, factorial; printf("ALG.03.03 v3 : factorial\n"); printf("------------------------\n\n"); do { printf("Introduzca un número entero : "); scanf("%i", &n); } while ( n < 0 ); factorial = n; aux = n - 1; while ( aux > 1 ) { factorial *= aux; aux--; };
/* Equivale a /* Equivale a
factorial = factorial * aux; aux = aux - 1;
printf("\nEl factorial de %i es %i\n", n, factorial); }
*/ */
Ejercicio ALG.03.03 v4 en PASCAL (************************************************************************) (* Alg_03_03_v4 *) (* *) (* Algoritmo que calcula el producto de los n primeros números enteros. *) (* Comprobaremos que el valor entrado de n sea válido (n >= 0). *) (* Utiliza la estructura iterativa REPEAT. *) (* Nótese que falla en el caso n = 1, ya que el bucle como mínimo *) (* realiza siempre una iteración. *) (* Utiliza la variable n como contador. Esto hace que nos ahorremos el *) (* espacio de la variable auxiliar, pero destruye el valor inicial de n *) (************************************************************************) PROGRAM Alg_03_03_v4 (input,output); VAR n, factorial : INTEGER; BEGIN WRITELN('ALG.03.03 v4 : factorial'); WRITELN('------------------------'); WRITELN; REPEAT WRITE('Introduzca un número entero : '); READLN(n); UNTIL n >= 0; factorial := n; REPEAT n := n - 1; factorial := factorial * n; UNTIL n <= 2; WRITELN('Su factorial es ', factorial); END.
Ejercicio ALG.03.03 v4 en C /************************************************************************/ /* Alg_03_03_v4 */ /* */ /* Algoritmo que calcula el producto de los n primeros números enteros. */ /* Comprobaremos que el valor entrado de n sea válido (n >= 0). */ /* Utiliza la estructura iterativa 'do - while'. */ /* Nótese que falla en el caso n = 1, ya que el bucle como mínimo */ /* realiza siempre una iteración. */ /* Utiliza la variable n como contador. Esto hace que nos ahorremos el */ /* espacio de la variable auxiliar, pero destruye el valor inicial de n */ /************************************************************************/
#include <stdio.h>
void main (void) { int n, factorial; printf("ALG.03.03 v4 : factorial\n"); printf("------------------------\n\n"); do { printf("Introduzca un número entero : "); scanf("%i", &n); } while ( n < 0 ); factorial = n; do { n--; factorial *= n; } while ( n > 2 ) ;
/* Equivale a /* Equivale a
n = n - 1; factorial = factorial * n;
printf("\nSu factorial es %i\n", factorial); }
*/ */
Ejercicio ALG.03.04 en PASCAL (************************************************************************) (* Alg_03_04 *) (* *) (* Algoritmo que convierte kilómetros a millas. *) (************************************************************************) PROGRAM Alg_03_04 (input,output); VAR tope, kilometro : INTEGER; factor, milla : REAL; BEGIN WRITELN('ALG.03.04 : conversión de kilómetros a millas'); WRITELN('---------------------------------------------'); WRITELN; factor := 1.6093; REPEAT WRITE('Introduzca el máximo de kilómetros a convertir : '); READLN(tope); UNTIL tope >= 1; WRITELN; WRITELN(' Kilómetro Milla'); WRITELN('-----------------------'); kilometro := 1; WHILE kilometro <= tope DO BEGIN milla := kilometro / factor; WRITELN(kilometro:6 , ' kilometro := kilometro + 1; END; WRITELN('-----------------------'); END.
' , milla:4:1);
Ejercicio ALG.03.04 en C /************************************************************************/ /* Alg_03_04 */ /* */ /* Algoritmo que convierte kilómetros a millas. */ /************************************************************************/
#include <stdio.h>
void main (void) { int tope, kilometro; float factor, milla; printf("ALG.03.04 : conversión de kilómetros a millas\n"); printf("---------------------------------------------\n\n"); factor = 1.6093; do { printf("Introduzca el máximo de kilómetros a convertir : "); scanf("%i", &tope); } while ( tope < 1 ); printf("\n Kilómetro Milla\n"); printf("-----------------------\n"); kilometro = 1; while ( kilometro <= tope ) { milla = kilometro / factor; printf("%6i %4.1f\n", kilometro, milla); kilometro++; } printf("-----------------------\n"); }
Ejercicio ALG.04.01 en PASCAL (********************************************************************) (* Alg_04_01 *) (* *) (* Algoritmo que calcula la suma de los n primeros números enteros. *) (* Utiliza la estructura repetitiva FOR. *) (********************************************************************) PROGRAM Alg_04_01 (input,output); VAR n, numero, suma : INTEGER; BEGIN WRITELN('ALG.04.01 : suma de los n primeros números enteros'); WRITELN('--------------------------------------------------'); WRITELN; WRITE('¿ Hasta que entero quiere sumar ? '); READLN(n); suma := 0; FOR numero := 1 TO n DO suma := suma + numero; WRITELN('La suma es ', suma); END.
Ejercicio ALG.04.01 en C /********************************************************************/ /* Alg_04_01 */ /* */ /* Algoritmo que calcula la suma de los n primeros números enteros. */ /* Utiliza la estructura repetitiva 'for'. */ /********************************************************************/
#include <stdio.h>
void main (void) { int n, numero, suma; printf("ALG.04.01 : suma de los n primeros números enteros\n"); printf("--------------------------------------------------\n\n"); printf("¿ Hasta que entero quiere sumar ? "); scanf("%i", &n); suma = 0; for (numero = 1; numero <= n; numero++) suma += numero; printf("\nLa suma es %i\n", suma); }
Ejercicio ALG.04.02 en PASCAL (**********************************************************************) (* Alg_04_02 *) (* *) (* Algoritmo que calcula la suma de los números impares menores que n *) (* *) (* En la estructura FOR de PASCAL sólo podemos realizar incrementos o *) (* decrementos de una unidad. Podemos intentar incrementar en más *) (* unidades el contador dentro del bucle, pero esto no es aconsejable *) (**********************************************************************) PROGRAM Alg_04_02 (input,output); VAR n, numero, suma : INTEGER; BEGIN WRITELN('ALG.04.02 : suma de los primeros impares menores que n'); WRITELN('------------------------------------------------------'); WRITELN; WRITE('¿ Hasta que impar quiere sumar ? '); READLN(n); suma := 0; FOR numero := 1 TO n DO BEGIN IF ODD(numero) THEN suma := suma + numero; END; WRITELN('La suma es ', suma); END.
Ejercicio ALG.04.02 en C /**********************************************************************/ /* Alg_04_02 */ /* */ /* Algoritmo que calcula la suma de los nĂşmeros impares menores que n */ /**********************************************************************/
#include <stdio.h>
void main (void) { int n, numero, suma; printf("ALG.04.02 : suma de los primeros impares menores que n\n"); printf("------------------------------------------------------\n\n"); printf("Âż Hasta que impar quiere sumar ? "); scanf("%i", &n); suma = 0; for (numero = 1; numero <= n; numero+=2) suma += numero; printf("\nLa suma es %i\n", suma); }
Ejercicio ALG.04.03 en PASCAL (************************************************************************) (* Alg_04_03 *) (* *) (* Algoritmo que convierte kilómetros a millas. *) (* Utiliza la estructura repetitiva FOR. *) (************************************************************************) PROGRAM Alg_04_03 (input,output); VAR tope, kilometro : INTEGER; factor, milla : REAL; BEGIN WRITELN('ALG.04.03 : conversión de kilómetros a millas'); WRITELN('---------------------------------------------'); WRITELN; factor := 1.6093; REPEAT WRITE('Introduzca el máximo de kilómetros a convertir : '); READLN(tope); UNTIL tope >= 1; WRITELN; WRITELN(' Kilómetro Milla'); WRITELN('-----------------------'); FOR kilometro := 1 TO tope DO BEGIN milla := kilometro / factor; WRITELN(kilometro:6 , ' END; WRITELN('-----------------------'); END.
' , milla:4:1);
Ejercicio ALG.04.03 en C /************************************************************************/ /* Alg_04_03 */ /* */ /* Algoritmo que convierte kilรณmetros a millas. */ /* Utiliza la estructura repetitiva FOR. */ /************************************************************************/
#include <stdio.h>
void main (void) { int tope, kilometro; float factor, milla; printf("ALG.04.03 : conversiรณn de kilรณmetros a millas\n"); printf("---------------------------------------------\n\n"); factor = 1.6093; do { printf("Introduzca el mรกximo de kilรณmetros a convertir : "); scanf("%i", &tope); } while ( tope < 1 ); printf("\n Kilometro Milla\n"); printf("-----------------------\n"); for ( kilometro = 1; kilometro <= tope; kilometro++ ) { milla = kilometro / factor; printf("%6i %4.1f\n", kilometro, milla); } printf("-----------------------\n"); }
Ejercicio ALG.05.01 v1 en PASCAL (*************************************************************) (* Alg_05_01_v1 *) (* *) (* Algoritmo que calcula el área de una corona circular *) (* a partir de una rutina que calcula el área de un círculo. *) (* Utiliza paso de parámetros por valor y por referencia. *) (*************************************************************)
PROGRAM Alg_05_01_v1 (input,output);
VAR radio_ext, radio_int, area_ext, area_int, area_corona : REAL;
(* Procedimiento area : *) (* dado una variable y un radio pasado como parámetro retorna *) (* el área del círculo correspondiente en la primera variable. *) PROCEDURE area ( VAR area_cir : REAL ; radio : REAL ); BEGIN area_cir := PI * radio * radio; END;
(* Programa principal *) BEGIN WRITELN('ALG.05.01 v1 : área de una corona circular'); WRITELN('------------------------------------------'); WRITELN; REPEAT WRITE('Introduzca el radio exterior : '); READLN(radio_ext); UNTIL radio_ext > 0; area(area_ext , radio_ext); REPEAT WRITE('Introduzca el radio interior : '); READLN(radio_int); UNTIL (radio_int > 0) AND (radio_int < radio_ext); area(area_int , radio_int); area_corona := area_ext - area_int; WRITELN('El área de la corona circular es ', area_corona:4:2); END.
Ejercicio ALG.05.01 v1 en C /*************************************************************/ /* Alg_05_01_v1 */ /* */ /* Algoritmo que calcula el área de una corona circular */ /* a partir de una rutina que calcula el área de un círculo. */ /* Utiliza paso de parámetros por valor y por referencia. */ /*************************************************************/
#include <stdio.h> #include <math.h>
/* Procedimiento area : */ /* dado una variable y un radio pasado como parámetro retorna */ /* el área del círculo correspondiente en la primera variable. */ void area ( float *area_cir , float radio ) { *area_cir = M_PI * radio * radio; }
/* Programa principal */ void main (void) { float radio_ext, radio_int, area_ext, area_int, area_corona; printf("ALG.05.01 v1 : área de una corona circular\n"); printf("------------------------------------------\n\n"); do { printf("Introduzca el radio exterior : "); scanf("%f", &radio_ext); } while (radio_ext <= 0); area(&area_ext , radio_ext); do { printf("Introduzca el radio interior : "); scanf("%f", &radio_int); } while ( (radio_int <= 0) || (radio_int >= radio_ext) ); area(&area_int , radio_int); area_corona = area_ext - area_int; printf("El área de la corona circular es %4.2f\n", area_corona); }
Ejercicio ALG.05.01 v2 en PASCAL (*************************************************************) (* Alg_05_01_v2 *) (* *) (* Algoritmo que calcula el área de una corona circular *) (* a partir de una rutina que calcula el área de un círculo. *) (* Utiliza paso de parámetros por valor. *) (*************************************************************)
PROGRAM Alg_05_01_v2 (input,output);
VAR radio_ext, radio_int, area_corona : REAL;
(* Función farea : (* dado un radio pasado como parámetro retorna el valor (* del área del círculo correspondiente. FUNCTION farea ( radio : REAL ) : REAL; BEGIN farea := PI * radio * radio; END;
*) *) *)
(* Programa principal *) BEGIN WRITELN('ALG.05.01 v2 : área de una corona circular'); WRITELN('------------------------------------------'); WRITELN; REPEAT WRITE('Introduzca el radio exterior : '); READLN(radio_ext); UNTIL radio_ext > 0; REPEAT WRITE('Introduzca el radio interior : '); READLN(radio_int); UNTIL (radio_int > 0) AND (radio_int < radio_ext); area_corona := farea ( radio_ext ) - farea ( radio_int ); WRITELN('El área de la corona circular es ', area_corona:4:2); END.
Ejercicio ALG.05.01 v2 en C /*************************************************************/ /* Alg_05_01_v2 */ /* */ /* Algoritmo que calcula el área de una corona circular */ /* a partir de una rutina que calcula el área de un círculo. */ /* Utiliza paso de parámetros por valor. */ /*************************************************************/
#include <stdio.h> #include <math.h>
/* Función farea : /* dado un radio pasado como parámetro retorna el valor /* del área del círculo correspondiente. float farea ( float radio ) { return ( M_PI * radio * radio ); }
*/ */ */
/* Programa principal */ void main (void) { float radio_ext, radio_int, area_corona; printf("ALG.05.01 v2 : área de una corona circular\n"); printf("------------------------------------------\n\n"); do { printf("Introduzca el radio exterior : "); scanf("%f", &radio_ext); } while (radio_ext <= 0); do { printf("Introduzca el radio interior : "); scanf("%f", &radio_int); } while ( (radio_int <= 0) || (radio_int >= radio_ext) ); area_corona = farea ( radio_ext ) - farea ( radio_int ); printf("El área de la corona circular es %4.2f\n", area_corona); }
Ejercicio ALG.05.02 en PASCAL (*************************************************************) (* Alg_05_02 *) (* *) (* Algoritmo que calcula la integral definida de una función *) (* 'f' entre dos puntos. *) (* Utiliza paso de parámetros por valor. *) (*************************************************************)
PROGRAM Alg_05_02 (input,output);
VAR liminferior, limsuperior, incremento , x, integral : REAL;
(* Función f : *) (* Representa la función matemática a evaluar. En este ejemplo utilizamos *) (* f(x) = 2x , pero se puede substituir por cualquier otra. *) FUNCTION f ( x : REAL ) : REAL; BEGIN f := 2 * x; END;
(* Programa principal *) BEGIN WRITELN('ALG.05.02 : cálculo de una integral definida'); WRITELN('--------------------------------------------'); WRITELN; WRITE('Introduzca el límite inferior : '); READLN(liminferior); REPEAT WRITE('Introduzca el límite superior : '); READLN(limsuperior); UNTIL limsuperior > liminferior; REPEAT WRITE('Introduzca el incremento : '); READLN(incremento); UNTIL incremento > 0; x := liminferior; integral := 0; WHILE x < (limsuperior - incremento) DO BEGIN integral := integral + ( incremento * f( x + incremento/2 ) ); x := x + incremento; END; integral := integral + (limsuperior - x) * f( (limsuperior+x)/2 ); WRITELN('Integral = ' , integral:5:2); END.
Ejercicio ALG.05.02 en C /*************************************************************/ /* Alg_05_02 */ /* */ /* Algoritmo que calcula la integral definida de una función */ /* 'f' entre dos puntos. */ /* Utiliza paso de parámetros por valor. */ /*************************************************************/
#include <stdio.h>
/* Función f : */ /* Representa la función matemática a evaluar. En este ejemplo utilizamos */ /* f(x) = 2x , pero se puede substituir por cualquier otra. */ float f ( float x ) { return ( 2 * x ); }
/* Programa principal */ void main (void) { float liminferior, limsuperior, incremento , x, integral; printf("ALG.05.02 : cálculo de una integral definida\n"); printf("--------------------------------------------\n\n"); printf("Introduzca el límite inferior : "); scanf("%f", &liminferior); do { printf("Introduzca el límite superior : "); scanf("%f", &limsuperior); } while (limsuperior <= liminferior); do { printf("Introduzca el incremento : "); scanf("%f", &incremento); } while (incremento <= 0); x = liminferior; integral = 0; while ( x < (limsuperior - incremento) ) { integral += incremento * f( x + incremento/2 ); x += incremento; } integral += (limsuperior - x) * f( (limsuperior+x)/2 ); printf("Integral = %5.2f\n" , integral); }
Ejercicio ALG.05.03 en PASCAL (****************************************************************) (* Alg_05_03 *) (* *) (* Algoritmo que imprime una tabla de funciones trigonométricas *) (****************************************************************)
PROGRAM Alg_05_03 (input,output);
VAR valor_inicial, valor_final ,inc, grados : REAL;
(* Procedimiento imprimir : *) (* dado un ángulo pasado como parámetro, imprime por pantalla *) (* una línea con el seno, coseno y tangente de dicho ángulo. *) PROCEDURE imprimir(angulo:REAL); BEGIN WRITE(angulo:8:2); angulo := angulo * PI / 180; WRITELN(sin(angulo):11:4, cos(angulo):11:4, sin(angulo)/cos(angulo):11:4); END;
(* Programa principal *) BEGIN WRITELN('ALG.05.03 : tabla de funciones trigonométricas'); WRITELN('----------------------------------------------'); WRITELN; WRITE('Introduzca el valor inicial : '); READLN(valor_inicial); REPEAT WRITE('Introduzca el valor final : '); READLN(valor_final); UNTIL valor_final > valor_inicial; REPEAT WRITE('Introduzca el incremento : '); READLN(inc); UNTIL inc > 0; grados := valor_inicial; WRITELN(' GRADOS SENO COSENO TANGENTE'); WRITELN('============================================'); WHILE grados <= valor_final DO BEGIN imprimir( grados ); grados := grados + inc; END ; WRITELN('============================================'); END.
Ejercicio ALG.05.03 en C /****************************************************************/ /* Alg_05_03 */ /* */ /* Algoritmo que imprime una tabla de funciones trigonométricas */ /****************************************************************/
#include <stdio.h> #include <math.h>
/* Procedimiento imprimir : */ /* dado un ángulo pasado como parámetro, imprime por pantalla */ /* una línea con el seno, coseno y tangente de dicho ángulo. */ void imprimir(float angulo) { printf("%8.2f ", angulo); angulo = angulo * M_PI / 180; printf("%10.4f %10.4f %10.4f\n", sin(angulo), cos(angulo), tan(angulo)); }
/* Programa principal */ void main (void) { float valor_inicial, valor_final ,inc, grados; printf("ALG.05.03 : tabla de funciones trigonométricas\n"); printf("----------------------------------------------\n\n"); printf("Introduzca el valor inicial : "); scanf("%f", &valor_inicial); do { printf("Introduzca el valor final : "); scanf("%f", &valor_final); } while (valor_final <= valor_inicial); do { printf("Introduzca el incremento : "); scanf("%f", &inc); } while (inc <= 0); printf(" GRADOS SENO COSENO TANGENTE\n"); printf("============================================\n"); for (grados = valor_inicial; grados <= valor_final; grados += inc) { imprimir( grados ); }; printf("============================================\n"); }
Ejercicio ALG.06.01 v2 en PASCAL (************************************************************************) (* Alg_06_01_v2 *) (* *) (* Algoritmo que imprime una tabla de conversión de kilómetros a millas *) (* y de millas a kilómetros. *) (************************************************************************) PROGRAM Alg_06_01_v2 (input,output); VAR tope, kilom, millas : INTEGER; conv : REAL; BEGIN WRITELN('ALG.06.01 v2 : tabla de conversión de kilómetros y millas'); WRITELN('---------------------------------------------------------'); WRITELN; conv := 1.6093; REPEAT WRITE('Introduzca el máximo de kilómetros a convertir : '); READLN(tope); UNTIL tope >= 1; WRITELN; WRITELN(' Kilómetro Milla'); WRITELN('-----------------------'); kilom := 1; millas := 1; WHILE kilom <= tope DO BEGIN IF kilom < (millas*conv) THEN BEGIN WRITELN(kilom:6 , ' kilom := kilom + 1; END ELSE BEGIN WRITELN(millas*conv:8:1 , ' millas := millas + 1; END; END; WRITELN('-----------------------');
' , kilom/conv:5:1);
END.
' , millas:3);
Ejercicio ALG.06.01 v2 en C /************************************************************************/ /* Alg_06_01_v2 */ /* */ /* Algoritmo que imprime una tabla de conversión de kilómetros a millas */ /* y de millas a kilómetros. */ /************************************************************************/
#include <stdio.h>
/* Programa principal */ void main (void) { int tope, kilom, millas; float conv; printf("ALG.06.01 v2 : tabla de conversión de kilómetros y millas\n"); printf("---------------------------------------------------------\n\n"); conv = 1.6093; do { printf("Introduzca el máximo de kilómetros a convertir : "); scanf("%i", &tope); } while (tope < 1); printf("\n Kilómetro Milla\n"); printf("-----------------------\n"); kilom = 1; millas = 1; while ( kilom <= tope ) { if ( kilom < (millas*conv) ) { printf("%6i %5.1f\n", kilom, kilom/conv); kilom++; } else { printf("%8.1f %3i\n", millas*conv , millas); millas++; }; }; printf("-----------------------\n"); }
Ejercicio ALG.06.01 v3 en PASCAL (************************************************************************) (* Alg_06_01_v3 *) (* *) (* Algoritmo que imprime una tabla de conversión de kilómetros a millas *) (* y de millas a kilómetros. *) (************************************************************************) PROGRAM Alg_06_01_v3 (input,output); VAR tope, kilom, millas : INTEGER; conv : REAL; BEGIN WRITELN('ALG.06.01 v3 : tabla de conversión de kilómetros y millas'); WRITELN('---------------------------------------------------------'); WRITELN; conv := 1.6093; REPEAT WRITE('Introduzca el máximo de kilómetros a convertir : '); READLN(tope); UNTIL tope >= 1; WRITELN; WRITELN(' Kilómetro Milla'); WRITELN('-----------------------'); kilom := 1; millas := 1; WHILE kilom <= tope DO BEGIN IF kilom < (millas*conv) THEN BEGIN WRITELN(kilom:6 , ' ' , kilom/conv:5:1); kilom := kilom + 1; END ELSE IF kilom > (millas*conv) THEN BEGIN WRITELN(millas*conv:8:1 , ' ' , millas:3); millas := millas + 1; END ELSE BEGIN WRITELN(kilom:6 , ' ' , millas:3); kilom := kilom + 1; millas := millas + 1; END; END; WRITELN('-----------------------'); END.
Ejercicio ALG.06.01 v3 en C /************************************************************************/ /* Alg_06_01_v3 */ /* */ /* Algoritmo que imprime una tabla de conversión de kilómetros a millas */ /* y de millas a kilómetros. */ /************************************************************************/
#include <stdio.h>
/* Programa principal */ void main (void) { int tope, kilom, millas; float conv; printf("ALG.06.01 v3 : tabla de conversión de kilómetros y millas\n"); printf("---------------------------------------------------------\n\n"); conv = 1.6093; do { printf("Introduzca el máximo de kilómetros a convertir : "); scanf("%i", &tope); } while (tope < 1); printf("\n Kilómetro Milla\n"); printf("-----------------------\n"); kilom = 1; millas = 1; while ( kilom <= tope ) { if ( kilom < (millas*conv) ) { printf("%6i %5.1f\n", kilom, kilom/conv); kilom++; } else { if ( kilom > (millas*conv) ) { printf("%8.1f %3i\n", millas*conv , millas); millas++; } else { printf("%6i %3i\n", kilom, millas); kilom++; millas++; }; }; }; printf("-----------------------\n"); }
Ejercicio ALG.06.02 v1 en PASCAL (************************************************************) (* Alg_06_02_v1 *) (* *) (* Algoritmo que determina si un entero dado es o no primo. *) (************************************************************) PROGRAM Alg_06_02_v1 (input,output); VAR n, aux : INTEGER; tope : REAL; primo : BOOLEAN; BEGIN WRITELN('Alg 06.02 v1 : programa para determinar si un entero es primo'); WRITELN('-------------------------------------------------------------'); WRITELN; REPEAT WRITE('Introduzca un nĂşmero entero : '); READLN(n); UNTIL n > 0; primo := TRUE; aux := 2; tope := SQRT(n);
(* A priori suponemos que es primo *)
WHILE ( aux <= tope ) AND ( primo = TRUE ) DO IF ( n MOD aux ) = 0 THEN primo := FALSE ELSE aux := aux + 1 ; (* fin del IF y fin del WHILE *) IF primo THEN WRITELN('El numero ' , n , ' es primo') ELSE WRITELN('El numero ' , n , ' no es primo'); END.
Ejercicio ALG.06.02 v1 en C /************************************************************/ /* Alg_06_02_v1 */ /* */ /* Algoritmo que determina si un entero dado es o no primo. */ /************************************************************/
#include <stdio.h> #include <math.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe por defecto */ typedef enum {FALSE, TRUE} boolean;
/* Programa principal */ void main (void) { int n, aux; float tope; boolean primo; printf("Alg 06.02 v1 : programa para determinar si un entero es primo\n"); printf("-------------------------------------------------------------\n\n"); do { printf("Introduzca un nĂşmero entero : "); scanf("%i", &n); } while ( n <= 0 ); primo = TRUE; aux = 2; tope = sqrt(n);
/* A priori suponemos que es primo */
while ( ( aux <= tope ) && ( primo == TRUE ) ) { if ( ( n % aux ) == 0 ) primo = FALSE; else aux++; }; if (primo) printf("El numero %i es primo\n", n); else printf("El numero %i no es primo\n", n); }
Ejercicio ALG.06.02 v2 en PASCAL (************************************************************) (* Alg_06_02_v2 *) (* *) (* Algoritmo que determina si un entero dado es o no primo. *) (* Para evitar la condición doble en el bucle WHILE, coloca *) (* en la variable 'aux' un valor arbitrariamente alto. *) (************************************************************) PROGRAM Alg_06_02_v2 (input,output); VAR n, aux : INTEGER; tope : REAL; primo : BOOLEAN; BEGIN WRITELN('Alg 06.02 v2 : programa para determinar si un entero es primo'); WRITELN('-------------------------------------------------------------'); WRITELN; REPEAT WRITE('Introduzca un número entero : '); READLN(n); UNTIL n > 0; primo := TRUE; aux := 2; tope := SQRT(n);
(* A priori suponemos que es primo *)
WHILE ( aux <= tope ) DO IF ( n MOD aux ) = 0 THEN BEGIN primo := FALSE; aux := MaxInt; (* También se podía hacer aux := Trunc(tope + 1); *) END ELSE aux := aux + 1 ; (* fin del IF y fin del WHILE *) IF primo THEN WRITELN('El numero ' , n , ' es primo') ELSE WRITELN('El numero ' , n , ' no es primo'); END.
Ejercicio ALG.06.02 v2 en C /************************************************************/ /* Alg_06_02_v2 */ /* */ /* Algoritmo que determina si un entero dado es o no primo. */ /* Para evitar la condición doble en el bucle WHILE, coloca */ /* en la variable 'aux' un valor arbitrariamente alto. */ /************************************************************/
#include <stdio.h> #include <math.h> #include <values.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe por defecto */ typedef enum {FALSE, TRUE} boolean;
/* Programa principal */ void main (void) { int n, aux; float tope; boolean primo; printf("Alg 06.02 v2 : programa para determinar si un entero es primo\n"); printf("-------------------------------------------------------------\n\n"); do { printf("Introduzca un número entero : "); scanf("%i", &n); } while ( n <= 0 ); primo = TRUE; aux = 2; tope = sqrt(n);
/* A priori suponemos que es primo */
while ( aux <= tope ) { if ( ( n % aux ) == 0 ) { primo = FALSE; aux = MAXINT; /* También se podía hacer aux = (int) tope + 1; */ } else aux++; }; if (primo) printf("El numero %i es primo\n", n); else printf("El numero %i no es primo\n", n); }
Ejercicio ALG.06.02 v3 en PASCAL (*************************************************************) (* Alg_06_02_v3 *) (* *) (* Algoritmo que determina si un entero dado es o no primo. *) (* Maneja únicamente la variable 'aux' (desaparece 'primo'). *) (*************************************************************) PROGRAM Alg_06_02_v3 (input,output); VAR n, aux : INTEGER; tope : REAL; BEGIN WRITELN('Alg 06.02 v3 : programa para determinar si un entero es primo'); WRITELN('-------------------------------------------------------------'); WRITELN; REPEAT WRITE('Introduzca un número entero : '); READLN(n); UNTIL n > 0; aux tope
:= 2; := SQRT(n);
WHILE ( aux <= tope ) DO IF ( n MOD aux ) = 0 THEN aux := MaxInt (* También se podía hacer aux := Trunc(tope + 1) *) ELSE aux := aux + 1 ; (* fin del IF y fin del WHILE *) IF aux = MaxInt THEN WRITELN('El numero ' , n , ' no es primo') ELSE WRITELN('El numero ' , n , ' es primo'); END.
Ejercicio ALG.06.02 v3 en C /*************************************************************/ /* Alg_06_02_v3 */ /* */ /* Algoritmo que determina si un entero dado es o no primo. */ /* Maneja únicamente la variable 'aux' (desaparece 'primo'). */ /*************************************************************/
#include <stdio.h> #include <math.h> #include <values.h>
/* Programa principal */ void main (void) { int n, aux; float tope; printf("Alg 06.02 v3 : programa para determinar si un entero es primo\n"); printf("-------------------------------------------------------------\n\n"); do { printf("Introduzca un número entero : "); scanf("%i", &n); } while ( n <= 0 ); aux = 2; tope = sqrt(n); while ( aux <= tope ) { if ( ( n % aux ) == 0 ) aux = MAXINT; /* También se podía hacer aux = (int) tope + 1; */ else aux++; }; if ( aux == MAXINT ) printf("El numero %i no es primo\n", n); else printf("El numero %i es primo\n", n); }
Ejercicio ALG.06.02 v4 en PASCAL (*************************************************************) (* Alg_06_02_v4 *) (* *) (* Algoritmo que determina si un entero dado es o no primo. *) (* Utiliza bifurcación condicional. *) (*************************************************************) PROGRAM Alg_06_02_v4 (input,output); LABEL eti_1, eti_2, eti_3 ; VAR n, aux : INTEGER; tope : REAL; BEGIN WRITELN('Alg 06.02 v4 : programa para determinar si un entero es primo'); WRITELN('-------------------------------------------------------------'); WRITELN; REPEAT WRITE('Introduzca un número entero : '); READLN(n); UNTIL n > 0; aux tope
:= 2; := SQRT(n);
eti_1: IF ( aux <= tope ) THEN IF ( n MOD aux ) = 0 THEN GOTO eti_2 ELSE BEGIN aux := aux + 1; GOTO eti_1; END ; (* fin de los dos IF *) WRITELN('El numero ' , n , ' es primo'); GOTO eti_3; eti_2: (* Viene aquí si ha encontrado divisor *) WRITELN('El numero ' , n , ' no es primo'); eti_3: WRITELN('Fin de programa'); END.
Ejercicio ALG.06.02 v4 en C /*************************************************************/ /* Alg_06_02_v4 */ /* */ /* Algoritmo que determina si un entero dado es o no primo. */ /* Utiliza bifurcaciĂłn condicional. */ /*************************************************************/
#include <stdio.h> #include <math.h>
/* Programa principal */ void main (void) { int n, aux; float tope; printf("Alg 06.02 v4 : programa para determinar si un entero es primo\n"); printf("-------------------------------------------------------------\n\n"); do { printf("Introduzca un nĂşmero entero : "); scanf("%i", &n); } while ( n <= 0 ); aux = 2; tope = sqrt(n); eti_1: ; if ( aux <= tope ) if ( ( n % aux ) == 0 ) goto eti_2; else { aux++; goto eti_1; } ; printf("El numero %i es primo\n", n); goto eti_3; eti_2: /* Viene aquĂ si ha encontrado divisor */ ; printf("El numero %i no es primo\n", n); eti_3: ; printf("Fin de programa\n"); }
Ejercicio ALG.06.03 v1 en PASCAL (********************************************************) (* Alg_06_03_v1 *) (* *) (* Algoritmo que determina si existe un número perfecto *) (* superior a un entero dado. *) (********************************************************) PROGRAM Alg_06_03_v1 (input,output); VAR i, j, k, suma : INTEGER; BEGIN WRITELN('Alg 06.03 v1 : programa para determinar un número perfecto'); WRITELN('----------------------------------------------------------'); WRITELN; REPEAT WRITE('Introduzca un número entero : '); READLN(i); UNTIL i > 0; k := i; REPEAT k := k + 1; j := 2; suma := 1; WHILE j <= (k/2) DO BEGIN IF (k MOD j) = 0 THEN suma := suma + j; j := j + 1; END; UNTIL suma = k; WRITELN('El número perfecto superior es ', k); END.
Ejercicio ALG.06.03 v1 en C /********************************************************/ /* Alg_06_03_v1 */ /* */ /* Algoritmo que determina si existe un número perfecto */ /* superior a un entero dado. */ /********************************************************/
#include <stdio.h>
/* Programa principal */ void main (void) { int i, j, k, suma; printf("Alg 06.03 v1 : programa para determinar un número perfecto\n"); printf("----------------------------------------------------------\n\n"); do { printf("Introduzca un número entero : "); scanf("%i", &i); } while ( i <= 0 ); k = i; do { k++; j = 2; suma = 1; while ( j <= (k/2) ) { if ( (k % j) == 0 ) suma += j; j++; }; } while ( suma != k ); printf("El número perfecto superior es %i\n", k); }
Ejercicio ALG.06.03 v2 en PASCAL (********************************************************) (* Alg_06_03_v2 *) (* *) (* Algoritmo que determina si existe un número perfecto *) (* superior a un entero dado. *) (********************************************************) PROGRAM Alg_06_03_v2 (input,output); VAR i, j, k, suma, tope : INTEGER; x : REAL; BEGIN WRITELN('Alg 06.03 v2 : programa para determinar un número perfecto'); WRITELN('----------------------------------------------------------'); WRITELN; REPEAT WRITE('Introduzca un número entero : '); READLN(i); UNTIL i > 0; k := i; REPEAT k := k + 1; j := 2; suma := 1; tope := TRUNC(SQRT(k)); WHILE j <= tope DO BEGIN x := k/j; IF FRAC(x) = 0 THEN suma := suma + j + TRUNC(x); j := j + 1; END; UNTIL suma = k; WRITELN('El número perfecto superior es ', k); END.
Ejercicio ALG.06.03 v2 en C /********************************************************/ /* Alg_06_03_v2 */ /* */ /* Algoritmo que determina si existe un número perfecto */ /* superior a un entero dado. */ /********************************************************/
#include <stdio.h> #include <math.h>
/* Programa principal */ void main (void) { int i, j, k, suma, tope; float x; printf("Alg 06.03 v2 : programa para determinar un número perfecto\n"); printf("----------------------------------------------------------\n\n"); do { printf("Introduzca un número entero : "); scanf("%i", &i); } while ( i <= 0 ); k = i; do { k++; j = 2; suma = 1; tope = (int) sqrt(k); while ( j <= tope ) { x = (float) k/j; if ( x == floor(x) ) suma += j + x; j++; }; } while ( suma != k ); printf("El número perfecto superior es %i\n", k); }
Ejercicio ALG.06.03 v3 en PASCAL (********************************************************) (* Alg_06_03_v3 *) (* *) (* Algoritmo que determina si existe un número perfecto *) (* superior a un entero dado. *) (********************************************************) PROGRAM Alg_06_03_v3 (input,output); VAR i, j, k, suma : INTEGER; tope, x : REAL; BEGIN WRITELN('Alg 06.03 v3 : programa para determinar un número perfecto'); WRITELN('----------------------------------------------------------'); WRITELN; REPEAT WRITE('Introduzca un número entero : '); READLN(i); UNTIL i > 0; k := i; REPEAT k := k + 1; j := 2; suma := 1 ; tope := SQRT(k); WHILE j < tope DO BEGIN x := k/j; IF FRAC(x) = 0 THEN suma := suma + j + TRUNC(x); j := j + 1; END; IF j = tope THEN suma := suma + j; UNTIL suma = k; WRITELN('El número perfecto superior es ', k); END.
Ejercicio ALG.06.03 v3 en C /********************************************************/ /* Alg_06_03_v3 */ /* */ /* Algoritmo que determina si existe un número perfecto */ /* superior a un entero dado. */ /********************************************************/
#include <stdio.h> #include <math.h>
/* Programa principal */ void main (void) { int i, j, k, suma; float tope, x; printf("Alg 06.03 v3 : programa para determinar un número perfecto\n"); printf("----------------------------------------------------------\n\n"); do { printf("Introduzca un número entero : "); scanf("%i", &i); } while ( i <= 0 ); k = i; do { k++; j = 2; suma = 1; tope = sqrt(k); while ( j < tope ) { x = (float) k/j; if ( x == floor(x) ) suma += j + x; j++; }; if ( j == tope ) suma += j; } while ( suma != k ); printf("El número perfecto superior es %i\n", k); }
Ejercicio ALG.07.01 v1 en PASCAL (*******************************************************) (* Alg_07_01_v1 *) (* *) (* Algoritmo que rellena una matriz con una constante. *) (*******************************************************) PROGRAM Alg_07_01_v1 (input,output); CONST f = 3; c = 3;
(* Número de filas de la matriz *) (* Número de columnas de la matriz *)
VAR i, j, k : INTEGER; a : ARRAY [ 1..f, 1..c ] OF INTEGER; BEGIN WRITELN('Alg 07.01 v1 : relleno de una matriz con una constante'); WRITELN('------------------------------------------------------'); WRITELN; WRITE('Introduzca la constante del relleno : '); READLN(k); (* Rellenamos la matriz *) FOR i := 1 TO f DO FOR j := 1 TO c DO a[i,j] := k; (* Imprimimos la matriz *) FOR i := 1 TO f DO FOR j := 1 TO c DO WRITELN('El elemento [' , i , ',' , j , '] es ' , a[i,j] ); END.
Ejercicio ALG.07.01 v1 en C /*******************************************************/ /* Alg_07_01_v1 */ /* */ /* Algoritmo que rellena una matriz con una constante. */ /*******************************************************/
#include <stdio.h>
#define f 3 #define c 3
/* NĂşmero de filas de la matriz */ /* NĂşmero de columnas de la matriz */
/* Programa principal */ void main (void) { int i, j, k; int a[f][c]; printf("Alg 07.01 v1 : relleno de una matriz con una constante\n"); printf("------------------------------------------------------\n\n"); printf("Introduzca la constante del relleno : "); scanf("%i",&k); /* Rellenamos la matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) a[i][j] = k; /* Imprimimos la matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) printf("El elemento [%i,%i] es %i\n" , i , j , a[i][j] ); }
Ejercicio ALG.07.01 v2 en PASCAL (*******************************************************************) (* Alg_07_01_v2 *) (* *) (* Algoritmo que rellena una matriz con la suma de fila y columna. *) (*******************************************************************) PROGRAM Alg_07_01_v2 (input,output); CONST f = 3; c = 3;
(* Número de filas de la matriz *) (* Número de columnas de la matriz *)
VAR i , j : INTEGER; a : ARRAY [ 1..f, 1..c ] OF INTEGER; BEGIN WRITELN('Alg 07.01 v2 : relleno de una matriz con la suma de fila y columna'); WRITELN('------------------------------------------------------------------'); WRITELN; (* Rellenamos la matriz *) FOR i := 1 TO f DO FOR j := 1 TO c DO a[i,j] := i + j; (* Imprimimos la matriz *) FOR i := 1 TO f DO FOR j := 1 TO c DO WRITELN('El elemento [' , i , ',' , j , '] es ' , a[i,j] ); END.
Ejercicio ALG.07.01 v2 en C /*******************************************************************/ /* Alg_07_01_v2 */ /* */ /* Algoritmo que rellena una matriz con la suma de fila y columna. */ /*******************************************************************/
#include <stdio.h>
#define f 3 #define c 3
/* NĂşmero de filas de la matriz */ /* NĂşmero de columnas de la matriz */
/* Programa principal */ void main (void) { int i, j; int a[f][c]; printf("Alg 07.01 v2 : relleno de una matriz con la suma de fila y columna\n"); printf("------------------------------------------------------------------\n\n"); /* Rellenamos la matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) a[i][j] = i + j; /* Imprimimos la matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) printf("El elemento [%i,%i] es %i\n" , i , j , a[i][j] ); }
Ejercicio ALG.07.01 v3 en PASCAL (*****************************************************************************) (* Alg_07_01_v3 *) (* *) (* Algoritmo que rellena una matriz con valores introducidos por el usuario. *) (*****************************************************************************) PROGRAM Alg_07_01_v3 (input,output); CONST f = 3; c = 3;
(* Número de filas de la matriz *) (* Número de columnas de la matriz *)
VAR i , j : INTEGER; a : ARRAY [ 1..f, 1..c ] OF INTEGER; BEGIN WRITELN('Alg 07.01 v3 : relleno de una matriz con valores leidos por teclado'); WRITELN('-------------------------------------------------------------------'); WRITELN; (* Rellenamos la matriz *) FOR i := 1 TO f DO FOR j := 1 TO c DO BEGIN WRITE('Introduzca el elemento [' , i , ',' , j , '] : ' ); READLN(a[i,j]); END; (* Una línea de separación mejora la presentación *) WRITELN; (* Imprimimos la matriz *) FOR i := 1 TO f DO FOR j := 1 TO c DO WRITELN('El elemento [' , i , ',' , j , '] es ' , a[i,j] ); END.
Ejercicio ALG.07.01 v3 en C /*****************************************************************************/ /* Alg_07_01_v3 */ /* */ /* Algoritmo que rellena una matriz con valores introducidos por el usuario. */ /*****************************************************************************/
#include <stdio.h>
#define f 3 #define c 3
/* Número de filas de la matriz */ /* Número de columnas de la matriz */
/* Programa principal */ void main (void) { int i, j; int a[f][c]; printf("Alg 07.01 v3 : relleno de una matriz con valores leidos por teclado\n"); printf("---------------------------------------------------------------\n\n"); /* Rellenamos la matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) { printf("Introduzca el elemento [%i,%i] : " , i , j ); scanf("%i", &a[i][j] ); } /* Una línea de separación mejora la presentación */ printf("\n"); /* Imprimimos la matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) printf("El elemento [%i,%i] es %i\n" , i , j , a[i][j] ); }
Ejercicio ALG.07.02 en PASCAL (*************************************************) (* Alg_07_02 *) (* *) (* Algoritmo que suma matrices. *) (* Las matrices son introducidas por el usuario. *) (*************************************************) PROGRAM Alg_07_02 (input,output); CONST f = 3; c = 3;
(* Número de filas de la matriz *) (* Número de columnas de la matriz *)
VAR i, j : INTEGER; a, b1, b2 : ARRAY [ 1..f, 1..c ] OF INTEGER; BEGIN WRITELN('Alg 07.02 : algoritmo para sumar matrices'); WRITELN('-----------------------------------------'); WRITELN; (* Rellenamos la primera matriz *) FOR i := 1 TO f DO FOR j := 1 TO c DO BEGIN WRITE('Introduzca el elemento [' , i , ',' , j , '] de la primera matriz : '); READLN(b1[i,j]); END; (* Una línea de separación mejora la presentación *) WRITELN; (* Rellenamos la segunda matriz *) FOR i := 1 TO f DO FOR j := 1 TO c DO BEGIN WRITE('Introduzca el elemento [' , i , ',' , j , '] de la segunda matriz : '); READLN(b2[i,j]); END; (* Una línea de separación mejora la presentación *) WRITELN; (* Calculamos la suma de las dos matrices *) FOR i := 1 TO f DO FOR j := 1 TO c DO a[i,j] := b1[i,j] + b2[i,j]; (* Imprimimos la matriz resultado *) FOR i := 1 TO f DO FOR j := 1 TO c DO WRITELN('El elemento [' , i , ',' , j , '] de la matriz suma es ' , a[i,j]); END.
Ejercicio ALG.07.02 en C /*************************************************/ /* Alg_07_02 */ /* */ /* Algoritmo que suma matrices. */ /* Las matrices son introducidas por el usuario. */ /*************************************************/
#include <stdio.h>
#define f 3 #define c 3
/* Número de filas de la matriz */ /* Número de columnas de la matriz */
/* Programa principal */ void main (void) { int i, j; int a[f][c], b1[f][c], b2[f][c]; printf("Alg 07.02 : algoritmo para sumar matrices\n"); printf("-----------------------------------------\n\n"); /* Rellenamos la primera matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) { printf("Introduzca el elemento [%i,%i] de la primera matriz : ", i, j); scanf("%i", &b1[i][j]); } /* Una línea de separación mejora la presentación */ printf("\n"); /* Rellenamos la segunda matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) { printf("Introduzca el elemento [%i,%i] de la segunda matriz : ", i, j); scanf("%i", &b2[i][j]); } /* Una línea de separación mejora la presentación */ printf("\n"); /* Calculamos la suma de las dos matrices */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) a[i][j] = b1[i][j] + b2[i][j]; /* Imprimimos la matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) printf("El elemento [%i,%i] de la matriz resultado es %i\n", i, j, a[i][j]); }
Ejercicio ALG.07.03 v1 en PASCAL (*************************************************) (* Alg_07_03_v1 *) (* *) (* Algoritmo que transpone matrices. *) (*************************************************) PROGRAM Alg_07_03_v1 (input,output); CONST f = 4; c = 2;
(* Número de filas de la matriz *) (* Número de columnas de la matriz *)
VAR i , j : INTEGER; M : ARRAY [ 1..f, 1..c ] OF INTEGER; T : ARRAY [ 1..c, 1..f ] OF INTEGER; BEGIN WRITELN('Alg 07.03 v1 : algoritmo para transponer matrices'); WRITELN('-------------------------------------------------'); WRITELN; (* Rellenamos la primera matriz *) FOR i := 1 TO f DO FOR j := 1 TO c DO BEGIN WRITE('Introduzca el elemento [' , i , ',' , j , '] de la matriz : '); READLN(M[i,j]); END; (* Calculamos la matriz transpuesta *) FOR i := 1 TO f DO FOR j := 1 TO c DO T[j,i] := M[i,j]; (* Imprimimos las matrices. A diferencia de los algoritmos 7.1 y 7.2 anteriores, utilizaremos un nuevo formato de presentación de matrices por pantalla. Comparad las instrucciones y el resultado, a ver cual os agrada más *) WRITELN; WRITELN('La matriz introducida es:'); FOR i := 1 TO f DO BEGIN WRITE('['); FOR j := 1 TO c DO WRITE(M[i,j]:6); WRITELN(' ]'); END; WRITELN; WRITELN('La matriz transpuesta es:'); FOR i := 1 TO c DO BEGIN WRITE('['); FOR j := 1 TO f DO WRITE(T[i,j]:6); WRITELN(' ]'); END; END.
Ejercicio ALG.07.03 v1 en C /*************************************************/ /* Alg_07_03_v1 */ /* */ /* Algoritmo que transpone matrices. */ /*************************************************/
#include <stdio.h>
#define f 4 #define c 2
/* Número de filas de la matriz */ /* Número de columnas de la matriz */
/* Programa principal */ void main (void) { int i, j; int M[f][c], T[c][f]; printf("Alg 07.03 v1 : algoritmo para transponer matrices\n"); printf("-------------------------------------------------\n\n"); /* Rellenamos la primera matriz */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) { printf("Introduzca el elemento [%i,%i] de la matriz : " , i , j ); scanf("%i", &M[i][j] ); } /* Calculamos la matriz transpuesta */ for (i = 0; i < f; i++) for (j = 0; j < c; j++) T[j][i] = M[i][j]; /* Imprimimos las matrices. A diferencia de los algoritmos 7.1 y 7.2 anteriores, utilizaremos un nuevo formato de presentación de matrices por pantalla. Comparad las instrucciones y el resultado, a ver cual os agrada más */ printf("\nLa matriz introducida es:\n"); for (i = 0; i < f; i++) { printf("[ "); for (j = 0; j < c; j++) printf("%5i " , M[i][j] ); printf("]\n"); }; printf("\nLa matriz transpuesta es:\n"); for (i = 0; i < c; i++) { printf("[ "); for (j = 0; j < f; j++) printf("%5i " , T[i][j] ); printf("]\n"); }; }
Ejercicio ALG.07.03 v2 en PASCAL (***************************************************************) (* Alg_07_03_v2 *) (* *) (* Algoritmo que transpone matrices cuadradas sobre sí mismas. *) (***************************************************************) PROGRAM Alg_07_03_v2 (input,output); CONST n = 3;
(* Número de filas y de columnas de la matriz *)
VAR i , j , aux : INTEGER; M : ARRAY [ 1..n, 1..n ] OF INTEGER; BEGIN WRITELN('Alg 07.03 v2 : algoritmo para transponer matrices cuadradas'); WRITELN('-----------------------------------------------------------'); WRITELN; (* Rellenamos la matriz *) FOR i := 1 TO n DO FOR j := 1 TO n DO BEGIN WRITE('Introduzca el elemento [' , i , ',' , j , '] de la matriz : '); READLN(M[i,j]); END; (* Imprimimos la matriz sin transponer en un nuevo formato *) WRITELN; WRITELN('La matriz introducida es:'); FOR i := 1 TO n DO BEGIN WRITE('['); FOR j := 1 TO n DO WRITE(M[i,j]:6); WRITELN(' ]'); END; (* Calculamos la matriz transpuesta *) FOR i := 1 TO n-1 DO FOR j := i+1 TO n DO BEGIN aux := M[i,j]; M[i,j] := M[j,i]; M[j,i] := aux; END; (* Imprimimos la matriz transpuesta en un nuevo formato *) WRITELN; WRITELN('La matriz transpuesta es:'); FOR i := 1 TO n DO BEGIN WRITE('['); FOR j := 1 TO n DO WRITE(M[i,j]:6); WRITELN(' ]'); END; END.
Ejercicio ALG.07.03 v2 en C /***************************************************************/ /* Alg_07_03_v2 */ /* */ /* Algoritmo que transpone matrices cuadradas sobre sĂ mismas. */ /***************************************************************/
#include <stdio.h>
#define n 3
/* NĂşmero de filas y de columnas de la matriz */
/* Programa principal */ void main (void) { int i, j, aux; int M[n][n]; printf("Alg 07.03 v2 : algoritmo para transponer matrices cuadradas\n"); printf("-----------------------------------------------------------\n\n"); /* Rellenamos la matriz */ for (i = 0; i < n; i++) for (j = 0; j < n; j++) { printf("Introduzca el elemento [%i,%i] de la matriz : " , i , j ); scanf("%i", &M[i][j] ); } /* Imprimimos la matriz sin transponer en un nuevo formato */ printf("\nLa matriz introducida es:\n"); for (i = 0; i < n; i++) { printf("[ "); for (j = 0; j < n; j++) printf("%5i " , M[i][j] ); printf("]\n"); }; /* Calculamos la matriz transpuesta */ for (i = 0; i < n-1; i++) for (j = i+1; j < n; j++) { aux = M[i][j]; M[i][j] = M[j][i]; M[j][i] = aux; }; /* Imprimimos la matriz sin transponer en un nuevo formato */ printf("\nLa matriz transpuesta es:\n"); for (i = 0; i < n; i++) { printf("[ "); for (j = 0; j < n; j++) printf("%5i " , M[i][j] ); printf("]\n"); }; }
Ejercicio ALG.07.04 v1 en PASCAL (******************************************************************) (* Alg_07_04_v1 *) (* *) (* Algoritmo que multiplica matrices. *) (* Las dimensiones son introducidas por el usuario desde teclado. *) (******************************************************************) PROGRAM Alg_07_04_v1 (input,output); CONST max_f = 10; max_c = 10;
(* Máximo de filas de la matriz *) (* Máximo de columnas de la matriz *)
VAR i , j , k f1 , f2 c1 , c2 P , M1 , M2
: : : :
INTEGER; 1..max_f; 1..max_c; ARRAY [ 1..max_f, 1..max_c ] OF REAL;
BEGIN WRITELN('Alg 07.04 v1 : algoritmo para multiplicar matrices'); WRITELN('--------------------------------------------------'); (* Pedimos el número de filas y de columnas de la primera matriz *) WRITELN; REPEAT WRITE('Introduzca el número de filas y columnas de la primera matriz : '); READLN(f1, c1); UNTIL (f1 >= 1) AND (f1 <= max_f) AND (c1 >= 1) AND (c1 <= max_c); (* Rellenamos la primera matriz *) FOR i := 1 TO f1 DO FOR j := 1 TO c1 DO BEGIN WRITE('Introduzca el elemento [' , i , ',' , j , '] de la matriz : '); READLN(M1[i,j]); END; (* Pedimos el número de filas y de columnas de la segunda matriz *) WRITELN; REPEAT WRITE('Introduzca el número de filas y columnas de la segunda matriz : '); READLN(f2, c2); UNTIL (f2 >= 1) AND (f2 <= max_f) AND (c2 >= 1) AND (c2 <= max_c) AND (c1 = f2); (* Rellenamos la segunda matriz *) FOR i := 1 TO f2 DO FOR j := 1 TO c2 DO BEGIN WRITE('Introduzca el elemento [' , i , ',' , j , '] de la matriz : '); READLN(M2[i,j]); END; (* Calculamos la matriz producto *) FOR i := 1 TO f1 DO FOR j := 1 TO c2 DO BEGIN P[i,j] := 0; FOR k := 1 TO c1 DO P[i,j] := P[i,j] + M1[i,k]*M2[k,j]; END; (* Imprimimos la matriz producto *) WRITELN; WRITELN('La matriz producto es:'); FOR i := 1 TO f1 DO BEGIN WRITE('['); FOR j := 1 TO c2 DO WRITE(P[i,j]:9:2);
WRITELN(' ]'); END; END.
Ejercicio ALG.07.04 v1 en C /******************************************************************/ /* Alg_07_04_v1 */ /* */ /* Algoritmo que multiplica matrices. */ /* Las dimensiones son introducidas por el usuario desde teclado. */ /******************************************************************/
#include <stdio.h>
#define max_f 10 #define max_c 10
/* Máximo de filas de la matriz */ /* Máximo de columnas de la matriz */
/* Programa principal */ void main (void) { int i, j, k; int f1, c1, f2, c2; float P[max_f][max_c] , M1[max_f][max_c] , M2[max_f][max_c]; printf("Alg 07.04 v1 : algoritmo para multiplicar matrices\n"); printf("--------------------------------------------------\n"); /* Pedimos el número de filas y de columnas de la primera matriz */ do { printf("\nIntroduzca el número de filas y columnas de la primera matriz : "); scanf("%i %i", &f1, &c1); } while ( (f1 < 1) || (f1 > max_f) || (c1 < 1) || (c1 > max_c) ); /* Rellenamos la primera matriz */ for (i = 0; i < f1; i++) for (j = 0; j < c1; j++) { printf("Introduzca el elemento [%i,%i] de la matriz : " , i , j ); scanf("%f", &M1[i][j] ); } /* Pedimos el número de filas y de columnas de la segunda matriz */ do { printf("\nIntroduzca el número de filas y columnas de la segunda matriz : "); scanf("%i %i", &f2, &c2); } while ( (f2 < 1) || (f2 > max_f) || (c2 < 1) || (c2 > max_c) || (c1 != f2) ); /* Rellenamos la segunda matriz */ for (i = 0; i < f2; i++) for (j = 0; j < c2; j++) { printf("Introduzca el elemento [%i,%i] de la matriz : " , i , j ); scanf("%f", &M2[i][j] ); } /* Calculamos la matriz producto */ for (i = 0; i < f1; i++) for (j = 0; j < c2; j++) for (P[i][j] = 0, k = 0; k < c1; k++) P[i][j] += M1[i][k] * M2[k][j]; /* Imprimimos la matriz producto */ printf("\nLa matriz introducida es:\n"); for (i = 0; i < f1; i++) { printf("[ "); for (j = 0; j < c2; j++) printf("%8.2f " , P[i][j] ); printf("]\n"); }; }
Ejercicio ALG.07.04 v2 en PASCAL (******************************************************************) (* Alg_07_04_v2 *) (* *) (* Algoritmo que multiplica matrices. *) (* Las dimensiones son introducidas por el usuario desde teclado. *) (******************************************************************) PROGRAM Alg_07_04_v2 (input,output); CONST max_f = 10; max_c = 10;
(* Máximo de filas de la matriz *) (* Máximo de columnas de la matriz *)
VAR i , j , k f1 , f2 c1 , c2 P , M1 , M2 aux
: : : : :
INTEGER; 1..max_f; 1..max_c; ARRAY [ 1..max_f, 1..max_c ] OF REAL; REAL;
BEGIN WRITELN('Alg 07.04 v2 : algoritmo para multiplicar matrices'); WRITELN('--------------------------------------------------'); (* Pedimos el número de filas y de columnas de la primera matriz *) WRITELN; REPEAT WRITE('Introduzca el número de filas y columnas de la primera matriz : '); READLN(f1, c1); UNTIL (f1 >= 1) AND (f1 <= max_f) AND (c1 >= 1) AND (c1 <= max_c); (* Rellenamos la primera matriz *) FOR i := 1 TO f1 DO FOR j := 1 TO c1 DO BEGIN WRITE('Introduzca el elemento [' , i , ',' , j , '] de la matriz : ' ); READLN(M1[i,j]); END; (* Pedimos el número de filas y de columnas de la segunda matriz *) WRITELN; REPEAT WRITE('Introduzca el número de filas y columnas de la segunda matriz : '); READLN(f2, c2); UNTIL (f2 >= 1) AND (f2 <= max_f) AND (c2 >= 1) AND (c2 <= max_c) AND (c1 = f2); (* Rellenamos la segunda matriz *) FOR i := 1 TO f2 DO FOR j := 1 TO c2 DO BEGIN WRITE('Introduzca el elemento [' , i , ',' , j , '] de la matriz : ' ); READLN(M2[i,j]); END; (* Calculamos la matriz producto *) FOR i := 1 TO f1 DO FOR j := 1 TO c2 DO BEGIN aux := 0; FOR k := 1 TO c1 DO aux := aux + M1[i,k]*M2[k,j]; P[i,j] := aux; END; (* Imprimimos la matriz producto *) WRITELN; WRITELN('La matriz producto es:'); FOR i := 1 TO f1 DO BEGIN
WRITE('['); FOR j := 1 TO c2 DO WRITE(P[i,j]:9:2); WRITELN(' ]'); END; END.
Ejercicio ALG.07.04 v2 en C /******************************************************************/ /* Alg_07_04_v2 */ /* */ /* Algoritmo que multiplica matrices. */ /* Las dimensiones son introducidas por el usuario desde teclado. */ /******************************************************************/
#include <stdio.h>
#define max_f 10 #define max_c 10
/* Máximo de filas de la matriz */ /* Máximo de columnas de la matriz */
/* Programa principal */ void main (void) { int i, j, k; int f1, c1, f2, c2; float P[max_f][max_c] , M1[max_f][max_c] , M2[max_f][max_c]; float aux; printf("Alg 07.04 v2 : algoritmo para multiplicar matrices\n"); printf("--------------------------------------------------\n"); /* Pedimos el número de filas y de columnas de la primera matriz */ do { printf("\nIntroduzca el número de filas y columnas de la primera matriz : "); scanf("%i %i", &f1, &c1); } while ( (f1 < 1) || (f1 > max_f) || (c1 < 1) || (c1 > max_c) ); /* Rellenamos la primera matriz */ for (i = 0; i < f1; i++) for (j = 0; j < c1; j++) { printf("Introduzca el elemento [%i,%i] de la matriz : " , i , j ); scanf("%f", &M1[i][j] ); } /* Pedimos el número de filas y de columnas de la segunda matriz */ do { printf("\nIntroduzca el número de filas y columnas de la segunda matriz : "); scanf("%i %i", &f2, &c2); } while ( (f2 < 1) || (f2 > max_f) || (c2 < 1) || (c2 > max_c) || (c1 != f2) ); /* Rellenamos la segunda matriz */ for (i = 0; i < f2; i++) for (j = 0; j < c2; j++) { printf("Introduzca el elemento [%i,%i] de la matriz : " , i , j ); scanf("%f", &M2[i][j] ); } /* Calculamos la matriz producto */ for (i = 0; i < f1; i++) for (j = 0; j < c2; j++) { aux = 0; for (k = 0; k < c1; k++) aux += M1[i][k] * M2[k][j]; P[i][j] = aux; }; /* Imprimimos la matriz producto */ printf("\nLa matriz introducida es:\n"); for (i = 0; i < f1; i++) { printf("[ "); for (j = 0; j < c2; j++) printf("%8.2f " , P[i][j] ); printf("]\n"); }; }
Ejercicio ALG.07.05 en PASCAL (********************************************************************) (* Alg_07_05 *) (* *) (* Algoritmo que calcula e imprime los n primeros números de la *) (* serie de Fibonacci definida como: *) (* *) (* Fibo(0) = 1 *) (* Fibo(1) = 1 *) (* Fibo(i) = Fibo(i-1) + Fibo(i-2) para i > 1 *) (* *) (* Se supone n >= 2 *) (********************************************************************) PROGRAM Alg_07_05 (input,output); CONST max_el = 45;
(* Máximo de elementos del vector *)
VAR i , n : INTEGER; fibo : ARRAY [ 0..max_el-1 ] OF LONGINT; BEGIN WRITELN('Alg 07.05 : calcular números de Fibonacci'); WRITELN('-----------------------------------------'); WRITELN; (* Pedimos el número de términos a calcular *) REPEAT WRITE('¿ Cuántos términos quiere calcular (2 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 2) AND (n <= max_el); (* Rellenamos el vector *) fibo[0] := 1; fibo[1] := 1; FOR i := 2 TO n-1 DO fibo[i] := fibo[i - 1] + fibo[i - 2]; (* Imprimimos el vector *) WRITELN('La serie de Fibonacci es:'); FOR i := 0 TO n-1 DO WRITELN( 'Fibo(' , i , ') = ', fibo[i] ); END.
Ejercicio ALG.07.05 en C /********************************************************************/ /* Alg_07_05 */ /* */ /* Algoritmo que calcula e imprime los n primeros números de la */ /* serie de Fibonacci definida como: */ /* */ /* Fibo(0) = 1 */ /* Fibo(1) = 1 */ /* Fibo(i) = Fibo(i-1) + Fibo(i-2) para i > 1 */ /* */ /* Se supone n >= 2 */ /********************************************************************/
#include <stdio.h>
#define max_el 45
/* Máximo de elementos del vector */
/* Programa principal */ void main (void) { int i, n; long fibo[max_el]; printf("Alg 07.05 : calcular números de Fibonacci\n"); printf("-----------------------------------------\n\n"); /* Pedimos el número de términosa calcular */ do { printf("¿ Cuántos términosquiere calcular (2 .. %i) ? ", max_el); scanf("%i", &n); } while ( (n < 2) || (n > max_el) ); /* Rellenamos el vector */ fibo[0] = 1; fibo[1] = 1; for (i = 2; i < n; i++) fibo[i] = fibo[i - 1] + fibo[i - 2]; /* Imprimimos el vector */ printf("La serie de Fibonacci es:\n"); for (i = 0; i < n; i++) printf( "Fibo(%i) = %li\n", i, fibo[i] ); }
Ejercicio ALG.07.06 en PASCAL (*********************************************************************) (* Alg_07_06 *) (* *) (* Algoritmo que dados unos datos contenidos en un vector, calcula e *) (* imprime el máximo, el mínimo, la media y la desviación tipo. *) (*********************************************************************) PROGRAM Alg_07_06 (input,output); CONST max_el = 100;
(* Máximo de elementos del vector *)
VAR indice , n : INTEGER; tabla : ARRAY [ 1..max_el ] OF REAL; maximo, minimo, suma, cuadrados, media, sigma : REAL; BEGIN WRITELN('Alg 07.06 : estadística sobre un vector de datos'); WRITELN('------------------------------------------------'); WRITELN; (* Pedimos el número de elementos del vector de datos *) REPEAT WRITE('¿ Cuántos datos desea introducir (2 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 2) AND (n <= max_el); (* Rellenamos el vector *) FOR indice := 1 TO n DO BEGIN WRITE('Introduce el dato número ' , indice , ' : '); READLN(tabla[indice]); END; (* Calculamos las variables estadísticas *) maximo := minimo := suma := cuadrados
tabla[1]; tabla[1]; tabla[1]; := tabla[1]*tabla[1];
FOR indice := 2 TO n DO BEGIN suma := suma + tabla[indice]; IF tabla[indice] > maximo THEN maximo := tabla[indice] ELSE IF tabla[indice] < minimo THEN minimo := tabla[indice]; cuadrados := cuadrados + tabla[indice]*tabla[indice]; END; media := suma / n; sigma := sqrt(cuadrados/n - media*media); (* Imprimimos los resultados *) WRITELN('Resultados'); WRITELN('------------------'); WRITELN('Máximo : ', maximo:8:2); WRITELN('Mínimo : ', minimo:8:2); WRITELN('Media : ', media:8:2); WRITELN('Desv. : ', sigma:8:2); END.
Ejercicio ALG.07.06 en C /*********************************************************************/ /* Alg_07_06 */ /* */ /* Algoritmo que dados unos datos contenidos en un vector, calcula e */ /* imprime el máximo, el mínimo, la media y la desviación tipo. */ /*********************************************************************/
#include <stdio.h> #include <math.h>
#define max_el 100
/* Máximo de elementos del vector */
/* Programa principal */ void main (void) { int indice, n; float tabla[max_el]; float maximo, minimo, suma, cuadrados, media, sigma; printf("Alg 07.06 : estadística sobre un vector de datos\n"); printf("------------------------------------------------\n\n"); /* Pedimos el número de elementos del vector de datos */ do { printf("¿ Cuántos datos desea introducir (2 .. %i) ? ", max_el); scanf("%i", &n); } while ( (n < 2) || (n > max_el) ); /* Rellenamos el vector */ for (indice = 0; indice < n; indice++) { printf("Introduce el dato número %i : ", indice+1); scanf("%f", &tabla[indice]); }; /* Calculamos las variables estadísticas */ maximo = tabla[0]; minimo = tabla[0]; suma = tabla[0]; cuadrados = tabla[0]*tabla[0]; for (indice = 1; indice < n; indice++) { suma += tabla[indice]; if ( tabla[indice] > maximo ) maximo = tabla[indice]; else if ( tabla[indice] < minimo ) minimo = tabla[indice]; cuadrados += tabla[indice]*tabla[indice]; }; media = suma / n; sigma = sqrt(cuadrados/n - media*media); /* Imprimimos los resultados */ printf("Resultados\n"); printf("------------------\n"); printf("Máximo : %8.2f\n", maximo); printf("Mínimo : %8.2f\n", minimo); printf("Media : %8.2f\n", media); printf("Desv. : %8.2f\n", sigma); }
Ejercicio ALG.07.07 v1 en PASCAL (***********************************************************) (* Alg_07_07_v1 *) (* *) (* Algoritmo que indica si una clave (o valor determinado) *) (* existe o no en un vector de n posiciones. *) (***********************************************************) PROGRAM Alg_07_07_v1 (input,output); CONST max_el = 100;
(* Máximo de elementos del vector *)
VAR i , n : INTEGER; clave : INTEGER; tabla : ARRAY [ 1..max_el ] OF INTEGER; indicador : BOOLEAN; BEGIN WRITELN('Alg 07.07 v1 : localización de una clave en un vector'); WRITELN('-----------------------------------------------------'); WRITELN; (* Pedimos el número de elementos del vector de claves *) REPEAT WRITE('¿ Cuántos valores contendrá el vector (1 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 1) AND (n <= max_el); (* Rellenamos el vector *) FOR i := 1 TO n DO BEGIN WRITE('Introduce el valor entero de la posición ' , i , ' : '); READLN(tabla[i]); END; (* Solicitamos la clave *) WRITELN; WRITE('¿ Cuál es la clave ? '); READLN(clave); WRITELN; (* Buscamos la clave *) indicador := FALSE; FOR i := 1 TO n DO IF tabla[i] = clave THEN indicador := TRUE; (* Imprimimos la conclusión *) IF indicador = TRUE THEN WRITELN('Clave encontrada') ELSE WRITELN('Clave no encontrada'); END.
Ejercicio ALG.07.07 v1 en C /***********************************************************/ /* Alg_07_07_v1 */ /* */ /* Algoritmo que indica si una clave (o valor determinado) */ /* existe o no en un vector de n posiciones. */ /***********************************************************/
#include <stdio.h>
#define max_el 100
/* Máximo de elementos del vector */
/* Creamos el nuevo tipo 'boolean'. En C no existe por defecto */ typedef enum {FALSE, TRUE} boolean;
/* Programa principal */ void main (void) { int i, n; int clave; int tabla[max_el]; boolean indicador; printf("Alg 07.07 v1 : localización de una clave en un vector\n"); printf("-----------------------------------------------------\n\n"); /* Pedimos el número de elementos del vector de datos */ do { printf("¿ Cuántos valores contendrá el vector (1 .. %i) ? ", max_el); scanf("%i", &n); } while ( (n < 1) || (n > max_el) ); /* Rellenamos el vector */ for (i = 0; i < n; i++) { printf("Introduce el valor entero de la posición %i : ", i+1); scanf("%i", &tabla[i]); }; /* Solicitamos la clave */ printf("\n¿ Cuál es la clave ? "); scanf("%i", &clave); /* Buscamos la clave */ indicador = FALSE; for (i = 0; i < n; i++) if ( tabla[i] == clave ) indicador = TRUE; /* Imprimimos la conclusión */ if (indicador == TRUE) printf("\nClave encontrada\n"); else printf("\nClave no encontrada\n"); }
Ejercicio ALG.07.07 v2 en PASCAL (***************************************************************************) (* Alg_07_07_v2 *) (* *) (* Algoritmo que indica si una clave (o valor determinado) existe o no en *) (* un vector de n posiciones. *) (* Mejoramos la eficiencia saliendo del bucle cuando encontramos la clave. *) (***************************************************************************) PROGRAM Alg_07_07_v2 (input,output); CONST max_el = 100;
(* Máximo de elementos del vector *)
VAR i , n : INTEGER; clave : INTEGER; tabla : ARRAY [ 1..max_el ] OF INTEGER; BEGIN WRITELN('Alg 07.07 v2 : localización de una clave en un vector'); WRITELN('-----------------------------------------------------'); WRITELN; (* Pedimos el número de elementos del vector de claves *) REPEAT WRITE('¿ Cuántos valores contendrá el vector (1 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 1) AND (n <= max_el); (* Rellenamos el vector *) FOR i := 1 TO n DO BEGIN WRITE('Introduce el valor entero de la posición ' , i , ' : '); READLN(tabla[i]); END; (* Solicitamos la clave *) WRITELN; WRITE('¿ Cuál es la clave ? '); READLN(clave); WRITELN; (* Buscamos la clave *) i := 1; WHILE (i <= n) AND (tabla[i] <> clave) DO i := i + 1; (* Imprimimos la conclusión *) IF i <= n THEN WRITELN('Clave encontrada en la posición ', i ) ELSE WRITELN('Clave no encontrada'); END.
Ejercicio ALG.07.07 v2 en C /***************************************************************************/ /* Alg_07_07_v2 */ /* */ /* Algoritmo que indica si una clave (o valor determinado) existe o no en */ /* un vector de n posiciones. */ /* Mejoramos la eficiencia saliendo del bucle cuando encontramos la clave. */ /***************************************************************************/
#include <stdio.h>
#define max_el 100
/* Máximo de elementos del vector */
/* Programa principal */ void main (void) { int i, n; int clave; int tabla[max_el]; printf("Alg 07.07 v2 : localización de una clave en un vector\n"); printf("-----------------------------------------------------\n\n"); /* Pedimos el número de elementos del vector de datos */ do { printf("¿ Cuántos valores contendrá el vector (1 .. %i) ? ", max_el); scanf("%i", &n); } while ( (n < 1) || (n > max_el) ); /* Rellenamos el vector */ for (i = 0; i < n; i++) { printf("Introduce el valor entero de la posición %i : ", i+1); scanf("%i", &tabla[i]); }; /* Solicitamos la clave */ printf("\n¿ Cuál es la clave ? "); scanf("%i", &clave); /* Buscamos la clave */ i = 0; while ( (i < n) && (tabla[i] != clave) ) i++; /* Imprimimos la conclusión */ if (i < n) printf("\nClave encontrada en la posición %i\n", i+1); else printf("\nClave no encontrada\n"); }
Ejercicio ALG.07.07 v3 en PASCAL (**************************************************************************) (* Alg_07_07_v3 *) (* *) (* Algoritmo que indica si una clave (o valor determinado) existe o no en *) (* un vector de n posiciones. *) (* Mejoramos la eficiencia del algoritmo Alg_07_07_v2 eliminando la *) (* condición doble del bucle WHILE. Colocamos la clave en la última *) (* posición de la tabla, por lo que siempre la encontraremos. *) (**************************************************************************) PROGRAM Alg_07_07_v3 (input,output); CONST max_el = 100;
(* Máximo de elementos del vector *)
VAR i , n : INTEGER; clave : INTEGER; tabla : ARRAY [ 1 .. max_el + 1 ] OF INTEGER; BEGIN WRITELN('Alg 07.07 v3 : localización de una clave en un vector'); WRITELN('-----------------------------------------------------'); WRITELN; (* Pedimos el número de elementos del vector de claves *) REPEAT WRITE('¿ Cuántos valores contendrá el vector (1 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 1) AND (n <= max_el); (* Rellenamos el vector *) FOR i := 1 TO n DO BEGIN WRITE('Introduce el valor entero de la posición ' , i , ' : '); READLN(tabla[i]); END; (* Solicitamos la clave *) WRITELN; WRITE('¿ Cuál es la clave ? '); READLN(clave); WRITELN; (* Buscamos la clave *) i := 1; tabla[n + 1] := clave; WHILE tabla[i] <> clave DO i := i + 1; (* Imprimimos la conclusión *) IF i = n+1 THEN WRITELN('Clave no encontrada') ELSE WRITELN('Clave encontrada en la posición ', i); END.
Ejercicio ALG.07.07 v3 en C /**************************************************************************/ /* Alg_07_07_v3 */ /* */ /* Algoritmo que indica si una clave (o valor determinado) existe o no en */ /* un vector de n posiciones. */ /* Mejoramos la eficiencia del algoritmo Alg_07_07_v2 eliminando la */ /* condición doble del bucle WHILE. Colocamos la clave en la última */ /* posición de la tabla, por lo que siempre la encontraremos. */ /**************************************************************************/
#include <stdio.h>
#define max_el 100
/* Máximo de elementos del vector */
/* Programa principal */ void main (void) { int i, n; int clave; int tabla[max_el+1]; printf("Alg 07.07 v2 : localización de una clave en un vector\n"); printf("-----------------------------------------------------\n\n"); /* Pedimos el número de elementos del vector de datos */ do { printf("¿ Cuántos valores contendrá el vector (1 .. %i) ? ", max_el); scanf("%i", &n); } while ( (n < 1) || (n > max_el) ); /* Rellenamos el vector */ for (i = 0; i < n; i++) { printf("Introduce el valor entero de la posición %i : ", i+1); scanf("%i", &tabla[i]); }; /* Solicitamos la clave */ printf("\n¿ Cuál es la clave ? "); scanf("%i", &clave); /* Buscamos la clave */ i = 0; tabla[n] = clave; while ( tabla[i] != clave ) i++; /* Imprimimos la conclusión */ if (i == n) printf("\nClave no encontrada\n"); else printf("\nClave encontrada en la posición %i\n", i+1); }
Ejercicio ALG.07.08 v1 en PASCAL (**************************************************************) (* Alg_07_08_v1 *) (* *) (* Algoritmo que realiza la fusión (merge) de dos vectores *) (* ordenados para obtener un nuevo vector también ordenado. *) (* *) (* Suponemos inicialmente que no conocemos la longitud de los *) (* vectores, sino que cada uno de los vectores termina en un *) (* valor arbitrariamente alto y previamente conocido. *) (**************************************************************) PROGRAM Alg_07_08_v1 (input,output); CONST max_el = 25; val_alto = MaxInt;
(* Máximo de elementos de los vectores *) (* Valor alto con que acaban los vectores *)
VAR n : INTEGER; ind_1 , ind_2 , ind_3 : INTEGER; tabla_1 , tabla_2 : ARRAY [ 1 .. max_el+1 ] OF INTEGER; tabla_3 : ARRAY [ 1 .. 2*max_el+1 ] OF INTEGER; BEGIN WRITELN('Alg 07.08 v1 : fusión de dos vectores ordenados'); WRITELN('-----------------------------------------------'); WRITELN; WRITELN('Ahora deberá introducir dos vectores ordenados'); (* Pedimos el número de elementos del primer vector *) WRITELN; REPEAT WRITE('¿ Cuántos valores contendrá el primer vector (1 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 1) AND (n <= max_el); (* Rellenamos el primer vector *) FOR ind_1 := 1 TO n DO BEGIN WRITE('Introduce el valor entero de la posición ' , ind_1 , ' : '); READLN(tabla_1[ind_1]); END; tabla_1[n+1] := val_alto; (* Pedimos el número de elementos del segundo vector *) WRITELN; REPEAT WRITE('¿ Cuántos valores contendrá el segundo vector (1 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 1) AND (n <= max_el); (* Rellenamos el segon vector *) FOR ind_2 := 1 TO n DO BEGIN WRITE('Introduce el valor entero de la posición ' , ind_2 , ' : '); READLN(tabla_2[ind_2]); END; tabla_2[n+1] := val_alto; (* Realizamos la fusión de los vectores *) ind_1 := 1; ind_2 := 1; ind_3 := 1; REPEAT IF tabla_1[ind_1] < tabla_2[ind_2] THEN BEGIN tabla_3[ind_3] := tabla_1[ind_1]; ind_1 := ind_1 + 1;
END ELSE BEGIN tabla_3[ind_3] := tabla_2[ind_2]; ind_2 := ind_2 + 1; END; ind_3 := ind_3 + 1; UNTIL (tabla_1[ind_1] = val_alto) AND (tabla_2[ind_2] = val_alto); tabla_3[ind_3] := val_alto; (* Imprimimos el vector fusionado *) WRITELN; WRITELN('El vector fusionado es :'); ind_3 := 1; WHILE tabla_3[ind_3] <> val_alto DO BEGIN WRITELN('El elemento de la posici贸n ' , ind_3:2 , ' es ', tabla_3[ind_3]:6); ind_3 := ind_3 + 1; END; END.
Ejercicio ALG.07.08 v1 en C /**************************************************************/ /* Alg_07_08_v1 */ /* */ /* Algoritmo que realiza la fusión (merge) de dos vectores */ /* ordenados para obtener un nuevo vector también ordenado. */ /* */ /* Suponemos inicialmente que no conocemos la longitud de los */ /* vectores, sino que cada uno de los vectores termina en un */ /* valor arbitrariamente alto y previamente conocido. */ /**************************************************************/
#include <stdio.h> #include <values.h>
#define max_el 25 #define val_alto MAXINT
/* Máximo de elementos de los vectores */ /* Valor alto con que acaban los vectores */
/* Programa principal */ void main (void) { int n; int ind_1 , ind_2 , ind_3; int tabla_1[max_el+1] , tabla_2[max_el+1] , tabla_3[2*max_el+1]; printf("Alg 07.08 v1 : fusión de dos vectores ordenados\n"); printf("-----------------------------------------------\n\n"); printf("Ahora deberá introducir dos vectores ordenados\n"); /* Pedimos el número de elementos del primer vector */ printf("\n"); do { printf("¿ Cuántos valores contendrá el primer vector (1 .. %i) ? ", max_el); scanf("%i", &n); } while ( (n < 1) || (n > max_el) ); /* Rellenamos el primer vector */ for (ind_1 = 0; ind_1 < n; ind_1++) { printf("Introduce el valor entero de la posición %i : ", ind_1+1); scanf("%i", &tabla_1[ind_1]); }; tabla_1[n] = val_alto; /* Pedimos el número de elementos del segundo vector */ printf("\n"); do { printf("¿ Cuántos valores contendrá el segundo vector (1 .. %i) ? ", max_el); scanf("%i", &n); } while ( (n < 1) || (n > max_el) ); /* Rellenamos el segundo vector */ for (ind_2 = 0; ind_2 < n; ind_2++) { printf("Introduce el valor entero de la posición %i : ", ind_2+1); scanf("%i", &tabla_2[ind_2]); }; tabla_2[n] = val_alto; /* Realizamos la fusión de los vectores */ ind_1 = 0; ind_2 = 0; ind_3 = 0; do { if ( tabla_1[ind_1] < tabla_2[ind_2] ) { tabla_3[ind_3] = tabla_1[ind_1]; ind_1++; }
else { tabla_3[ind_3] = tabla_2[ind_2]; ind_2++; }; ind_3++; } while ( (tabla_1[ind_1] != val_alto) || (tabla_2[ind_2] != val_alto) ); tabla_3[ind_3] = val_alto; /* Imprimimos el vector fusionado */ printf("\nEl vector fusionado es :\n"); ind_3 = 0; while ( tabla_3[ind_3] != val_alto ) { printf("El elemento de la posici贸n %2i es %6i\n", ind_3+1, tabla_3[ind_3]); ind_3++; }; }
Ejercicio ALG.07.08 v2 en PASCAL (**************************************************************) (* Alg_07_08_v2 *) (* *) (* Algoritmo que realiza la fusión (merge) de dos vectores *) (* ordenados para obtener un nuevo vector también ordenado. *) (* *) (* Suponemos inicialmente que no conocemos la longitud de los *) (* vectores, sino que cada uno de los vectores termina en un *) (* valor arbitrariamente alto y previamente conocido. *) (**************************************************************) PROGRAM Alg_07_08_v2 (input,output); CONST max_el = 25; delim = MaxInt;
(* Máximo de elementos de los vectores *) (* Valor alto con que acaban los vectores *)
VAR n : INTEGER; ind_1 , ind_2 , ind_3 : INTEGER; tabla_1 , tabla_2 : ARRAY [ 1 .. max_el+1 ] OF INTEGER; tabla_3 : ARRAY [ 1 .. 2*max_el+1 ] OF INTEGER; BEGIN WRITELN('Alg 07.08 v2 : fusión de dos vectores ordenados'); WRITELN('-----------------------------------------------'); WRITELN; WRITELN('Ahora deberá introducir dos vectores ordenados'); (* Pedimos el número de elementos del primer vector *) WRITELN; REPEAT WRITE('¿ Cuántos valores contendrá el primer vector (1 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 1) AND (n <= max_el); (* Rellenamos el primer vector *) FOR ind_1 := 1 TO n DO BEGIN WRITE('Introduce el valor entero de la posición ' , ind_1 , ' : '); READLN(tabla_1[ind_1]); END; tabla_1[n+1] := delim; (* Pedimos el número de elementos del segundo vector *) WRITELN; REPEAT WRITE('¿ Cuántos valores contendrá el segundo vector (1 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 1) AND (n <= max_el); (* Rellenamos el segon vector *) FOR ind_2 := 1 TO n DO BEGIN WRITE('Introduce el valor entero de la posición ' , ind_2 , ' : '); READLN(tabla_2[ind_2]); END; tabla_2[n+1] := delim; (* Realizamos la fusión de los vectores *) ind_1 := 1; ind_2 := 1; ind_3 := 1; REPEAT IF tabla_1[ind_1] < tabla_2[ind_2] THEN BEGIN tabla_3[ind_3] := tabla_1[ind_1]; ind_1 := ind_1 + 1; END
ELSE BEGIN tabla_3[ind_3] := tabla_2[ind_2]; ind_2 := ind_2 + 1; END; ind_3 := ind_3 + 1; UNTIL (tabla_1[ind_1] = delim) OR (tabla_2[ind_2] = delim); IF tabla_1[ind_1] = delim THEN REPEAT tabla_3[ind_3] := tabla_2[ind_2]; ind_2 := ind_2 + 1; ind_3 := ind_3 + 1; UNTIL tabla_2[ind_2] = delim ELSE REPEAT tabla_3[ind_3] := tabla_1[ind_1]; ind_1 := ind_1 + 1; ind_3 := ind_3 + 1; UNTIL tabla_1[ind_1] = delim; tabla_3[ind_3] := delim; (* Imprimimos el vector fusionado *) WRITELN; WRITELN('El vector fusionado es :'); ind_3 := 1; WHILE tabla_3[ind_3] <> delim DO BEGIN WRITELN('El elemento de la posici贸n ' , ind_3:2 , ' es ', tabla_3[ind_3]:6); ind_3 := ind_3 + 1; END; END.
Ejercicio ALG.07.08 v2 en C /**************************************************************/ /* Alg_07_08_v2 */ /* */ /* Algoritmo que realiza la fusión (merge) de dos vectores */ /* ordenados para obtener un nuevo vector también ordenado. */ /* */ /* Suponemos inicialmente que no conocemos la longitud de los */ /* vectores, sino que cada uno de los vectores termina en un */ /* valor arbitrariamente alto y previamente conocido. */ /**************************************************************/
#include <stdio.h> #include <values.h>
#define max_el 25 #define delim MAXINT
/* Máximo de elementos de los vectores */ /* Valor alto con que acaban los vectores */
/* Programa principal */ void main (void) { int n; int ind_1 , ind_2 , ind_3; int tabla_1[max_el+1] , tabla_2[max_el+1] , tabla_3[2*max_el+1]; printf("Alg 07.08 v2 : fusión de dos vectores ordenados\n"); printf("-----------------------------------------------\n\n"); printf("Ahora deberá introducir dos vectores ordenados\n"); /* Pedimos el número de elementos del primer vector */ printf("\n"); do { printf("¿ Cuántos valores contendrá el primer vector (1 .. %i) ? ", max_el); scanf("%i", &n); } while ( (n < 1) || (n > max_el) ); /* Rellenamos el primer vector */ for (ind_1 = 0; ind_1 < n; ind_1++) { printf("Introduce el valor entero de la posición %i : ", ind_1+1); scanf("%i", &tabla_1[ind_1]); }; tabla_1[n] = delim; /* Pedimos el número de elementos del segundo vector */ printf("\n"); do { printf("¿ Cuántos valores contendrá el segundo vector (1 .. %i) ? ", max_el); scanf("%i", &n); } while ( (n < 1) || (n > max_el) ); /* Rellenamos el segundo vector */ for (ind_2 = 0; ind_2 < n; ind_2++) { printf("Introduce el valor entero de la posición %i : ", ind_2+1); scanf("%i", &tabla_2[ind_2]); }; tabla_2[n] = delim; /* Realizamos la fusión de los vectores */ ind_1 = 0; ind_2 = 0; ind_3 = 0; do { if ( tabla_1[ind_1] < tabla_2[ind_2] ) { tabla_3[ind_3] = tabla_1[ind_1]; ind_1++; }
else { tabla_3[ind_3] = tabla_2[ind_2]; ind_2++; }; ind_3++; } while ( (tabla_1[ind_1] != delim) && (tabla_2[ind_2] != delim) ); if ( tabla_1[ind_1] == delim ) do { tabla_3[ind_3] = tabla_2[ind_2]; ind_2++; ind_3++; } while ( tabla_2[ind_2] != delim ); else do { tabla_3[ind_3] = tabla_1[ind_1]; ind_1++; ind_3++; } while ( tabla_1[ind_1] != delim ); tabla_3[ind_3] = delim; /* Imprimimos el vector fusionado */ printf("\nEl vector fusionado es :\n"); ind_3 = 0; while ( tabla_3[ind_3] != delim ) { printf("El elemento de la posici贸n %2i es %6i\n", ind_3+1, tabla_3[ind_3]); ind_3++; }; }
Ejercicio ALG.07.09 v1 en PASCAL (**********************************************************************) (* Alg_07_09_v1 *) (* *) (* Algoritmo para evaluar el total de ventas por artículo y el total *) (* de ventas por periodo, así como el valor global de las ventas. *) (* La información se almacena en una tabla de nombre VENTAS de dos *) (* dimensiones: *) (* - Cada artículo en una fila. Existen n artículos diferentes. *) (* - Cada periodo en una columna. Existen p periodos diferentes. *) (* La sumarización de ventas por artículo la almacenamos en el vector *) (* VENTAS_ARTICULOS, y la sumarización de ventas por periodo la *) (* almacenamos en el vector VENTAS_PERIODO. *) (**********************************************************************) PROGRAM Alg_07_09_v1 (input,output); CONST max_n = 10; max_p = 10;
(* Máximo número de artículos *) (* Máximo número de periodos *)
VAR n , articulo : 1..max_n; p , periodo : 1..max_p; ventas : ARRAY [ 1..max_n , 1..max_p ] OF LONGINT; ventas_articulo : ARRAY [ 1..max_n ] OF LONGINT; ventas_periodo : ARRAY [ 1..max_p ] OF LONGINT; suma , total_ventas : LONGINT; BEGIN WRITELN('Alg 07.09 v1 : algoritmo para evaluar el total de ventas'); WRITELN('--------------------------------------------------------'); WRITELN; (* Pedimos el número de artículos y de periodos *) REPEAT WRITE('Introduzca el número de artículos (max. ',max_n,') : '); READLN(n); WRITE('Introduzca el número de periodos (max. ',max_p,') : '); READLN(p); UNTIL (n >= 1) AND (n <= max_n) AND (p >= 1) AND (p <= max_p); (* Rellenamos la matriz de ventas *) WRITELN; FOR articulo := 1 TO n DO FOR periodo := 1 TO p DO BEGIN WRITE('Introduzca las ventas del artículo ' , articulo , ' en el periodo ' , periodo , ' : '); READLN(ventas[articulo , periodo]); END; (* Calculamos las ventas por artículo y el total de ventas *) total_ventas := 0; FOR articulo := 1 TO n DO BEGIN suma := 0; FOR periodo := 1 TO p DO suma := suma + ventas[articulo , periodo]; ventas_articulo[articulo] := suma; total_ventas := total_ventas + suma; END; (* Calculamos las ventas por periodo *) FOR periodo := 1 TO p DO BEGIN suma := 0; FOR articulo := 1 TO n DO suma := suma + ventas[articulo , periodo]; ventas_periodo[periodo] := suma;
END; (* Imprimimos las matriz de ventas, el total de ventas *) (* y los vectores de ventas por artĂculo y por periodo. *) WRITELN; WRITE('art/per|'); FOR periodo := 1 TO p DO WRITE(periodo:7); WRITELN(' |v. art.'); WRITE('-------+'); FOR periodo := 1 TO p DO WRITE('-------'); WRITELN('-+-------'); FOR articulo := 1 TO n DO BEGIN WRITE(articulo:6,' |'); FOR periodo := 1 TO p DO WRITE(ventas[articulo , periodo]:7); WRITELN(' |' , ventas_articulo[articulo]:7); END; WRITE('-------+'); FOR periodo := 1 TO p DO WRITE('-------'); WRITELN('-+-------'); WRITE('v. per.|'); FOR periodo := 1 to p DO WRITE(ventas_periodo[periodo]:7); WRITE(' |', total_ventas:7); END.
Ejercicio ALG.07.09 v1 en C /**********************************************************************/ /* Alg_07_09_v1 */ /* */ /* Algoritmo para evaluar el total de ventas por artículo y el total */ /* de ventas por periodo, así como el valor global de las ventas. */ /* La información se almacena en una tabla de nombre VENTAS de dos */ /* dimensiones: */ /* - Cada artículo en una fila. Existen n artículos diferentes. */ /* - Cada periodo en una columna. Existen p periodos diferentes. */ /* La sumarización de ventas por artículo la almacenamos en el vector */ /* VENTAS_ARTICULOS, y la sumarización de ventas por periodo la */ /* almacenamos en el vector VENTAS_PERIODO. */ /**********************************************************************/
#include <stdio.h>
#define max_n 10 #define max_p 10
/* Máximo número de artículos */ /* Máximo número de periodos */
/* Programa principal */ void main (void) { int n , articulo; int p , periodo; long ventas[max_n][max_p]; long ventas_articulo[max_n]; long ventas_periodo[max_p]; long suma , total_ventas; printf("Alg 07.09 v1 : algoritmo para evaluar el total de ventas\n"); printf("--------------------------------------------------------\n\n"); /* Pedimos el número de artículos y de periodos */ do { printf("Introduzca el número de artículos (max. %i) : ", max_n); scanf("%i", &n); printf("Introduzca el número de periodos (max. %i) : ", max_p); scanf("%i", &p); } while ( (n < 1) || (n > max_n) || (p < 1) || (p > max_p) ); /* Rellenamos la matriz de ventas */ printf("\n"); for (articulo = 0; articulo < n; articulo++) for (periodo = 0; periodo < p; periodo++) { printf("Introduzca las ventas del artículo %i en el periodo %i : ", articulo+1, periodo+1); scanf("%li", &ventas[articulo][periodo]); }; /* Calculamos las ventas por artículo y el total de ventas */ total_ventas = 0; for (articulo = 0; articulo < n; articulo++) { suma = 0; for (periodo = 0; periodo < p; periodo++) suma += ventas[articulo][periodo]; ventas_articulo[articulo] = suma; total_ventas += suma; }; /* Calculamos las ventas por periodo */ for (periodo = 0; periodo < p; periodo++) { suma = 0; for (articulo = 0; articulo < n; articulo++) suma += ventas[articulo][periodo]; ventas_periodo[periodo] = suma; };
/* Imprimimos las matriz de ventas, el total de ventas */ /* y los vectores de ventas por artĂculo y por periodo. */ printf("\nart/per|"); for (periodo = 0; periodo < p; periodo++) printf("%7i", periodo+1); printf(" |v. art.\n"); printf("-------+"); for (periodo = 0; periodo < p; periodo++) printf("-------"); printf("-+-------\n"); for (articulo = 0; articulo < n; articulo++) { printf("%6i |", articulo+1); for (periodo = 0; periodo < p; periodo++) printf("%7li", ventas[articulo][periodo]); printf(" |%7li\n" , ventas_articulo[articulo]); }; printf("-------+"); for (periodo = 0; periodo < p; periodo++) printf("-------"); printf("-+-------\n"); printf("v. per.|"); for (periodo = 0; periodo < p; periodo++) printf("%7li", ventas_periodo[periodo]); printf(" |%7li\n", total_ventas); }
Ejercicio ALG.07.09 v2 en PASCAL (**********************************************************************) (* Alg_07_09_v2 *) (* *) (* Algoritmo para evaluar el total de ventas por artículo y el total *) (* de ventas por periodo, así como el valor global de las ventas. *) (* La información se almacena en una tabla de nombre VENTAS de dos *) (* dimensiones: *) (* - Cada artículo en una fila. Existen n artículos diferentes. *) (* - Cada periodo en una columna. Existen p periodos diferentes. *) (* La sumarización de ventas por artículo la almacenamos en el vector *) (* VENTAS_ARTICULOS, y la sumarización de ventas por periodo la *) (* almacenamos en el vector VENTAS_PERIODO. *) (**********************************************************************) PROGRAM Alg_07_09_v1 (input,output); CONST max_n = 10; max_p = 10;
(* Máximo número de artículos *) (* Máximo número de periodos *)
VAR n , articulo : 1..max_n; p , periodo : 1..max_p; ventas : ARRAY [ 1..max_n , 1..max_p ] OF LONGINT; ventas_articulo : ARRAY [ 1..max_n ] OF LONGINT; ventas_periodo : ARRAY [ 1..max_p ] OF LONGINT; total_ventas : LONGINT; BEGIN WRITELN('Alg 07.09 v1 : algoritmo para evaluar el total de ventas'); WRITELN('--------------------------------------------------------'); WRITELN; (* Pedimos el número de artículos y de periodos *) REPEAT WRITE('Introduzca el número de artículos (max. ',max_n,') : '); READLN(n); WRITE('Introduzca el número de periodos (max. ',max_p,') : '); READLN(p); UNTIL (n >= 1) AND (n <= max_n) AND (p >= 1) AND (p <= max_p); (* Rellenamos la matriz de ventas *) WRITELN; FOR articulo := 1 TO n DO FOR periodo := 1 TO p DO BEGIN WRITE('Introduzca las ventas del artículo ' , articulo , ' en el periodo ' , periodo , ' : '); READLN(ventas[articulo , periodo]); END; (* Calculamos las ventas por artículo y el total de ventas *) total_ventas := 0; FOR periodo := 1 TO p DO ventas_periodo[periodo] := 0; FOR articulo := 1 TO n DO BEGIN ventas_articulo[articulo] := 0; FOR periodo := 1 TO p DO BEGIN ventas_articulo[articulo] := ventas_articulo[articulo] + ventas[articulo , periodo]; ventas_periodo[periodo] := ventas_periodo[periodo] + ventas[articulo , periodo]; END; total_ventas := total_ventas + ventas_articulo[articulo]; END;
(* Imprimimos las matriz de ventas, el total de ventas *) (* y los vectores de ventas por artĂculo y por periodo. *) WRITELN; WRITE('art/per|'); FOR periodo := 1 TO p DO WRITE(periodo:7); WRITELN(' |v. art.'); WRITE('-------+'); FOR periodo := 1 TO p DO WRITE('-------'); WRITELN('-+-------'); FOR articulo := 1 TO n DO BEGIN WRITE(articulo:6,' |'); FOR periodo := 1 TO p DO WRITE(ventas[articulo , periodo]:7); WRITELN(' |' , ventas_articulo[articulo]:7); END; WRITE('-------+'); FOR periodo := 1 TO p DO WRITE('-------'); WRITELN('-+-------'); WRITE('v. per.|'); FOR periodo := 1 to p DO WRITE(ventas_periodo[periodo]:7); WRITE(' |', total_ventas:7); END.
Ejercicio ALG.07.09 v2 en C /**********************************************************************/ /* Alg_07_09_v2 */ /* */ /* Algoritmo para evaluar el total de ventas por artículo y el total */ /* de ventas por periodo, así como el valor global de las ventas. */ /* La información se almacena en una tabla de nombre VENTAS de dos */ /* dimensiones: */ /* - Cada artículo en una fila. Existen n artículos diferentes. */ /* - Cada periodo en una columna. Existen p periodos diferentes. */ /* La sumarización de ventas por artículo la almacenamos en el vector */ /* VENTAS_ARTICULOS, y la sumarización de ventas por periodo la */ /* almacenamos en el vector VENTAS_PERIODO. */ /**********************************************************************/
#include <stdio.h>
#define max_n 10 #define max_p 10
/* Máximo número de artículos */ /* Máximo número de periodos */
/* Programa principal */ void main (void) { int n , articulo; int p , periodo; long ventas[max_n][max_p]; long ventas_articulo[max_n]; long ventas_periodo[max_p]; long total_ventas; printf("Alg 07.09 v2 : algoritmo para evaluar el total de ventas\n"); printf("--------------------------------------------------------\n\n"); /* Pedimos el número de artículos y de periodos */ do { printf("Introduzca el número de artículos (max. %i) : ", max_n); scanf("%i", &n); printf("Introduzca el número de periodos (max. %i) : ", max_p); scanf("%i", &p); } while ( (n < 1) || (n > max_n) || (p < 1) || (p > max_p) ); /* Rellenamos la matriz de ventas */ printf("\n"); for (articulo = 0; articulo < n; articulo++) for (periodo = 0; periodo < p; periodo++) { printf("Introduzca las ventas del artículo %i en el periodo %i : ", articulo+1, periodo+1); scanf("%li", &ventas[articulo][periodo]); }; /* Calculamos las ventas por artículo y periodo */ total_ventas = 0; for (periodo = 0; periodo < p; periodo++) ventas_periodo[periodo] = 0; for (articulo = 0; articulo < n; articulo++) { ventas_articulo[articulo] = 0; for (periodo = 0; periodo < p; periodo++) { ventas_articulo[articulo] += ventas[articulo][periodo]; ventas_periodo[periodo] += ventas[articulo][periodo]; }; total_ventas += ventas_articulo[articulo]; }; /* Imprimimos las matriz de ventas, el total de ventas */ /* y los vectores de ventas por artículo y por periodo. */
printf("\nart/per|"); for (periodo = 0; periodo < p; periodo++) printf("%7i", periodo+1); printf(" |v. art.\n"); printf("-------+"); for (periodo = 0; periodo < p; periodo++) printf("-------"); printf("-+-------\n"); for (articulo = 0; articulo < n; articulo++) { printf("%6i |", articulo+1); for (periodo = 0; periodo < p; periodo++) printf("%7li", ventas[articulo][periodo]); printf(" |%7li\n" , ventas_articulo[articulo]); }; printf("-------+"); for (periodo = 0; periodo < p; periodo++) printf("-------"); printf("-+-------\n"); printf("v. per.|"); for (periodo = 0; periodo < p; periodo++) printf("%7li", ventas_periodo[periodo]); printf(" |%7li\n", total_ventas); }
Ejercicio ALG.07.09 v3 en PASCAL (**********************************************************************) (* Alg_07_09_v3 *) (* *) (* Algoritmo para evaluar el total de ventas por artículo, por zona y *) (* por periodo, así como el valor global de las ventas. *) (* La información se almacena en una tabla de nombre VENTAS de tres *) (* dimensiones: *) (* - Cada artículo en una fila. Existen n artículos diferentes. *) (* - Cada periodo en una columna. Existen p periodos diferentes. *) (* - Cada zona en una hilera profund. Existen z zonas diferentes. *) (* La sumarización de ventas por artículo y zona la almacenamos en la *) (* matriz VENTAS_RESUM. *) (**********************************************************************) PROGRAM Alg_07_09_v3 (input,output); CONST max_n = 10; max_p = 10; max_z = 10;
(* Máximo número de artículos *) (* Máximo número de periodos *) (* Máximo número de zonas *)
VAR n , articulo : p , periodo : z , zona : ventas : ARRAY ventas_resum :
1..max_n; 1..max_p; 1..max_z; [ 1..max_n , 1..max_p , 1..max_z ] OF LONGINT; ARRAY [ 1..max_n , 1..max_z ] OF LONGINT;
BEGIN WRITELN('Alg 07.09 v3 : algoritmo para evaluar las ventas'); WRITELN('------------------------------------------------'); WRITELN; (* Pedimos el número de artículos, de periodos y de zonas *) REPEAT WRITE('Introduzca el número de artículos (max. ',max_n,') : '); READLN(n); WRITE('Introduzca el número de periodos (max. ',max_p,') : '); READLN(p); WRITE('Introduzca el número de zonas (max. ',max_z,') : '); READLN(z); UNTIL (n >= 1) AND (p >= 1) AND (z >= 1) AND (n <= max_n) AND (p <= max_p) AND (z <= max_p); (* Rellenamos la matriz de ventas *) WRITELN; FOR articulo := 1 TO n DO FOR periodo := 1 TO p DO FOR zona := 1 TO z DO BEGIN WRITE('Introduzca las ventas del artículo ' , articulo , ' en el periodo ' , periodo , ' y la zona ' , zona , ' : '); READLN(ventas[articulo , periodo , zona]); END; (* Calculamos las ventas por artículo y zona *) FOR articulo := 1 TO n DO FOR zona := 1 to z DO BEGIN ventas_resum[articulo , zona] := 0; FOR periodo := 1 TO p DO ventas_resum[articulo , zona] := ventas_resum[articulo , zona] + ventas[articulo , periodo , zona]; END; (* Imprimimos las matriz de ventas, el total de ventas *) (* y los vectores de ventas por artículo y por periodo. *) WRITELN; WRITELN('Resumen de ventas por artículo y zona');
WRITELN('-------------------------------------'); WRITELN; WRITE('art. / zon. |'); FOR zona := 1 TO z DO WRITE(zona:7); WRITELN; WRITE('------------+'); FOR zona := 1 TO z DO WRITE('-------'); WRITELN; FOR articulo := 1 TO n DO BEGIN WRITE(articulo:4,' |'); FOR zona := 1 TO z DO WRITE(ventas_resum[articulo , zona]:7); WRITELN; END; END.
Ejercicio ALG.07.09 v3 en C /**********************************************************************/ /* Alg_07_09_v3 */ /* */ /* Algoritmo para evaluar el total de ventas por artículo, por zona y */ /* por periodo, así como el valor global de las ventas. */ /* La información se almacena en una tabla de nombre VENTAS de tres */ /* dimensiones: */ /* - Cada artículo en una fila. Existen n artículos diferentes. */ /* - Cada periodo en una columna. Existen p periodos diferentes. */ /* - Cada zona en una hilera profund. Existen z zonas diferentes. */ /* La sumarización de ventas por artículo y zona la almacenamos en la */ /* matriz VENTAS_RESUM. */ /**********************************************************************/
#include <stdio.h>
#define max_n 10 #define max_p 10 #define max_z 10
/* Máximo número de artículos */ /* Máximo número de periodos */ /* Máximo número de zonas */
/* Programa principal */ void main (void) { int n , articulo; int p , periodo; int z , zona; long ventas[max_n][max_p][max_z]; long ventas_resum[max_n][max_z]; printf("Alg 07.09 v3 : algoritmo para evaluar las ventas\n"); printf("------------------------------------------------\n\n"); /* Pedimos el número de artículos, de periodos y de zonas */ do { printf("Introduzca el número de artículos (max. %i) : ", max_n); scanf("%i", &n); printf("Introduzca el número de periodos (max. %i) : ", max_p); scanf("%i", &p); printf("Introduzca el número de zonas (max. %i) : ", max_z); scanf("%i", &z); } while ( (n < 1) || (p < 1) || (z < 1) || (n > max_n) || (p > max_p) || (z > max_z) ); /* Rellenamos la matriz de ventas */ printf("\n"); for (articulo = 0; articulo < n; articulo++) for (periodo = 0; periodo < p; periodo++) for (zona = 0; zona < z; zona++) { printf("Introduzca ventas del artículo %i en el periodo %i y la zona %i : ", articulo+1, periodo+1, zona+1); scanf("%li", &ventas[articulo][periodo][zona]); }; /* Calculamos las ventas por artículo y zona */ for (articulo = 0; articulo < n; articulo++) for (zona = 0; zona < z; zona++) { ventas_resum[articulo][zona] = 0; for (periodo = 0; periodo < p; periodo++) ventas_resum[articulo][zona] += ventas[articulo][periodo][zona]; }; /* Imprimimos las matriz de ventas, el total de ventas */ /* y los vectores de ventas por artículo y por periodo. */ printf("\nResumen de ventas por artículo y zona\n"); printf("-------------------------------------\n\n");
printf("art. / zon. |"); for (zona = 0; zona < z; zona++) printf("%7i", zona+1); printf("\n"); printf("------------+"); for (zona = 0; zona < z; zona++) printf("-------"); printf("\n"); for (articulo = 0; articulo < n; articulo++) { printf("%4i |", articulo+1); for (zona = 0; zona < z; zona++) printf("%7li", ventas_resum[articulo][zona]); printf("\n"); }; }
Ejercicio ALG.07.10 v1 en PASCAL (*******************************************************************) (* Alg_07_10_v1 *) (* *) (* Algoritmo que ordena los elementos de un vector numérico de n *) (* posiciones. Método de ordenación por selección con intercambio. *) (*******************************************************************) PROGRAM Alg_07_10_v1 (input,output); CONST max_el = 100;
(* Máximo de elementos del vector *)
VAR i , j , n : INTEGER; tabla : ARRAY [ 1..max_el ] OF INTEGER; aux : INTEGER; BEGIN WRITELN('Alg 07.10 v1 : ordenación de vectores'); WRITELN('-------------------------------------'); WRITELN; (* Pedimos el número de elementos del vector *) REPEAT WRITE('¿ Cuántos valores contendrá el vector (1 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 1) AND (n <= max_el); (* Rellenamos el vector *) FOR i := 1 TO n DO BEGIN WRITE('Introduce el valor entero de la posición ' , i , ' : '); READLN(tabla[i]); END; (* Ordenamos el vector. Para ello comparamos cada elemento con todos *) (* los que le siguen y si encuentra uno menor lo intercambia con él. *) FOR i := 1 TO n-1 DO FOR j := i+1 TO n DO IF tabla[j] < tabla[i] THEN BEGIN aux := tabla[i]; tabla[i] := tabla[j]; tabla[j] := aux; END; (* Imprimimos el vector ordenado *) FOR i := 1 TO n DO WRITELN('El elemento de la posición ' , i:2 , ' es ', tabla[i]:6); END.
Ejercicio ALG.07.10 v1 en C /*******************************************************************/ /* Alg_07_10_v1 */ /* */ /* Algoritmo que ordena los elementos de un vector numérico de n */ /* posiciones. Método de ordenación por selección con intercambio. */ /*******************************************************************/
#include <stdio.h>
#define max_el 100
/* Máximo de elementos del vector */
/* Programa principal */ void main (void) { int i, j, n; int aux; int tabla[max_el]; printf("Alg 07.10 v1 : ordenación de vectores\n"); printf("-------------------------------------\n\n"); /* Pedimos el número de elementos del vector */ do { printf("¿ Cuántos valores contendrá el vector (1 .. scanf("%i", &n); } while ( (n < 1) || (n > max_el) );
%i) ? ", max_el);
/* Rellenamos el vector */ for (i = 0; i < n; i++) { printf("Introduce el valor entero de la posición %i : ", i+1); scanf("%i", &tabla[i]); }; /* Ordenamos el vector. Para ello comparamos cada elemento con todos */ /* los que le siguen y si encuentra uno menor lo intercambia con él. */ for (i = 0; i < n-1; i++) for (j = i+1; j < n; j++) if ( tabla[j] < tabla[i] ) { aux = tabla[i]; tabla[i] = tabla[j]; tabla[j] = aux; }; /* Imprimimos el vector ordenado */ for (i = 0; i < n; i++) printf("El elemento de la posición %2i es %6i\n", i+1, tabla[i]); }
Ejercicio ALG.07.10 v2 en PASCAL (*******************************************************************) (* Alg_07_10_v2 *) (* *) (* Algoritmo que ordena los elementos de un vector numérico de n *) (* posiciones. Método de ordenación por selección con intercambio. *) (*******************************************************************) PROGRAM Alg_07_10_v2 (input,output); CONST max_el = 100;
(* Máximo de elementos del vector *)
VAR i , j , n , pos_min : INTEGER; tabla : ARRAY [ 1..max_el ] OF INTEGER; aux : INTEGER; BEGIN WRITELN('Alg 07.10 v2 : ordenación de vectores'); WRITELN('-------------------------------------'); WRITELN; (* Pedimos el número de elementos del vector *) REPEAT WRITE('¿ Cuántos valores contendrá el vector (1 .. ', max_el, ') ? '); READLN(n); UNTIL (n >= 1) AND (n <= max_el); (* Rellenamos el vector *) FOR i := 1 TO n DO BEGIN WRITE('Introduce el valor entero de la posición ' , i , ' : '); READLN(tabla[i]); END; (* Ordenamos el vector. Para ello comparamos cada elemento con todos *) (* los que le siguen y lo intercambia con el menor elemento encontrado. *) FOR i := 1 TO n-1 DO BEGIN pos_min := i; FOR j := i+1 TO n DO IF tabla[j] < tabla[pos_min] THEN pos_min := j; aux := tabla[i]; tabla[i] := tabla[pos_min]; tabla[pos_min] := aux; END; (* Imprimimos el vector ordenado *) FOR i := 1 TO n DO WRITELN('El elemento de la posición ' , i:2 , ' es ', tabla[i]:6); END.
Ejercicio ALG.07.10 v2 en C /*******************************************************************/ /* Alg_07_10_v2 */ /* */ /* Algoritmo que ordena los elementos de un vector numérico de n */ /* posiciones. Método de ordenación por selección con intercambio. */ /*******************************************************************/
#include <stdio.h>
#define max_el 100
/* Máximo de elementos del vector */
/* Programa principal */ void main (void) { int i, j, n, pos_min; int aux; int tabla[max_el]; printf("Alg 07.10 v2 : ordenación de vectores\n"); printf("-------------------------------------\n\n"); /* Pedimos el número de elementos del vector */ do { printf("¿ Cuántos valores contendrá el vector (1 .. scanf("%i", &n); } while ( (n < 1) || (n > max_el) );
%i) ? ", max_el);
/* Rellenamos el vector */ for (i = 0; i < n; i++) { printf("Introduce el valor entero de la posición %i : ", i+1); scanf("%i", &tabla[i]); }; /* Ordenamos el vector. Para ello comparamos cada elemento con todos */ /* los que le siguen y lo intercambia con el menor elemento encontrado. */ for (i = 0; i < n-1; i++) { pos_min = i; for (j = i+1; j < n; j++) if ( tabla[j] < tabla[pos_min] ) pos_min = j; aux = tabla[i]; tabla[i] = tabla[pos_min]; tabla[pos_min] = aux; }; /* Imprimimos el vector ordenado */ for (i = 0; i < n; i++) printf("El elemento de la posición %2i es %6i\n", i+1, tabla[i]); }
Ejercicio ALG.08.01 en PASCAL (****************************************************) (* Alg_08_01 *) (* *) (* Algoritmo que imprime el triángulo de Pascal : *) (* *) (* 1 *) (* 1 1 *) (* 1 2 1 *) (* 1 3 3 1 *) (* 1 4 6 4 1 *) (* ... *) (* Observación: a partir de la fila 13 hay OVERFLOW *) (****************************************************) PROGRAM Alg_08_01 (input,output); VAR i , j , f : INTEGER; coeficiente : LONGINT; (* Función que calcula el factorial de 'n' *) FUNCTION FACTORIAL(n:INTEGER):LONGINT; VAR i : INTEGER; fact : LONGINT; BEGIN fact := 1; FOR i := 2 TO n DO fact := fact * i; FACTORIAL := fact; END; (* Función que calcula el número 'a' sobre 'b' *) FUNCTION SOBRE(a, b : INTEGER):LONGINT; BEGIN SOBRE := FACTORIAL(a) DIV (FACTORIAL(b)*FACTORIAL(a-b)); END; (* Programa principal *) BEGIN WRITELN('Alg 08.01 : triángulo de Pascal'); WRITELN('-------------------------------'); WRITELN; (* Pedimos el número de filas del triángulo *) REPEAT WRITE('¿ Hasta qué fila quieres el triángulo ? '); READLN(f); UNTIL (f >= 0); (* Calculamos el triángulo *) FOR i := 0 TO f DO BEGIN FOR j := 0 TO i DO BEGIN coeficiente := SOBRE(i,j); WRITE(coeficiente:4 , ' '); END; WRITELN; END; END.
Ejercicio ALG.08.01 en C /****************************************************/ /* Alg_08_01 */ /* */ /* Algoritmo que imprime el triángulo de Pascal : */ /* */ /* 1 */ /* 1 1 */ /* 1 2 1 */ /* 1 3 3 1 */ /* 1 4 6 4 1 */ /* ... */ /* Observación: a partir de la fila 13 hay OVERFLOW */ /****************************************************/
#include <stdio.h>
/* Función que calcula el factorial de 'n' */ unsigned long factorial(int n) { int i; unsigned long fact; fact = 1; for (i = 2; i <= n; i++) fact *= i; return fact; }; /* Función que calcula el número 'a' sobre 'b' */ unsigned long sobre(int a, int b) { return ( factorial(a) / (factorial(b)*factorial(a-b)) ); } /* Programa principal */ void main (void) { int i, j , f; unsigned long coeficiente; printf("Alg 08.01 : triángulo de Pascal\n"); printf("-------------------------------\n\n"); /* Pedimos el número de filas del triángulo */ do { printf("¿ Hasta qué fila quieres el triángulo ? "); scanf("%i", &f); } while (f < 0); /* Calculamos el triángulo */ for (i = 0; i <= f; i++) { for (j = 0; j <= i; j++) { coeficiente = sobre(i,j); printf("%4li ", coeficiente); }; printf("\n"); }; }
Ejercicio ALG.09.01 v1 en PASCAL (*******************************************************) (* Alg_09_01_v1 *) (* *) (* Algoritmo que indica el número de ocurrencias de un *) (* carácter dado en una frase. *) (*******************************************************) PROGRAM Alg_09_01_v1 (input,output); VAR frase : STRING[100]; caracter : CHAR; i , numero : INTEGER; BEGIN WRITELN('Alg 09.01 v1 : ocurrencias de un carácter en una frase'); WRITELN('------------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca la frase *) WRITE('Introduzca una frase : '); READLN(frase); (* Pedimos que el usuario introduzca el carácter a localizar *) WRITE('¿ Qué carácter quiere localizar ? '); READLN(caracter); (* Calculamos cuantas veces aparece el carácter en la frase *) numero := 0; i := 1; REPEAT IF frase[i] = caracter THEN numero := numero + 1; i := i + 1; UNTIL i > LENGTH(frase); (* UNTIL ORD(frase[i]) = 0 hubiera sido otra opción válida *) (* Imprimimos el resultado *) WRITELN(' El carácter aparece ', numero, ' veces en la frase.'); END.
Ejercicio ALG.09.01 v1 en C /*******************************************************/ /* Alg_09_01_v1 */ /* */ /* Algoritmo que indica el número de ocurrencias de un */ /* carácter dado en una frase. */ /*******************************************************/
#include <stdio.h>
/* Programa principal */ void main (void) { char frase[100]; char caracter; int i , numero; printf("Alg 09.01 v1 : ocurrencias de un carácter en una frase\n"); printf("------------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca la frase */ printf("Introduzca una frase : "); scanf("%99s", frase); /* Pedimos que el usuario introduzca el carácter a localizar */ printf("¿ Qué carácter quiere localizar ? "); scanf("\n%c", &caracter); /* Calculamos cuantas veces aparece el carácter en la frase */ numero = 0; for (i = 0; frase[i] != '\0'; i++) if ( frase[i] == caracter ) numero++; /* Imprimimos el resultado */ printf(" El carácter aparece %i veces en la frase.\n", numero); }
Ejercicio ALG.09.02 en PASCAL (*******************************************************) (* Alg_09_02 *) (* *) (* Algoritmo que comprueba el menor de dos apellidos *) (* en orden alfabĂŠtico. *) (*******************************************************) PROGRAM Alg_09_02 (input,output); VAR apellido1, apellido2 : STRING[25]; BEGIN WRITELN('Alg 09.02 : el menor de dos apellidos'); WRITELN('-------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca los apellidos *) WRITE('Introduzca el primer apellido : '); READLN(apellido1); WRITE('Introduzca el segundo apellido : '); READLN(apellido2); (* Imprimimos si el primer apellido es menor, *) (* igual o mayor que el segundo apellido. *) IF apellido1 = apellido2 THEN WRITELN('Los apellidos son iguales') ELSE IF apellido1 < apellido2 THEN WRITELN('El primer apellido es menor que el segundo') ELSE WRITELN('El primer apellido es mayor que el segundo'); END.
Ejercicio ALG.09.02 en C /*******************************************************/ /* Alg_09_02 */ /* */ /* Algoritmo que comprueba el menor de dos apellidos */ /* en orden alfabĂŠtico. */ /*******************************************************/
#include <stdio.h> #include <string.h>
/* Programa principal */ void main (void) { char apellido1[25], apellido2[25]; printf("Alg 09.02 : el menor de dos apellidos\n"); printf("-------------------------------------\n\n"); /* Pedimos que el usuario introduzca los apellidos */ printf("Introduzca el primer apellido : "); scanf("%24s", apellido1); printf("Introduzca el segundo apellido : "); scanf("%24s", apellido2); /* Imprimimos si el primer apellido es menor, /* igual o mayor que el segundo apellido. if ( strcmpi(apellido1,apellido2) == 0 ) printf("Los apellidos son iguales\n"); else if ( strcmpi(apellido1,apellido2) < 0 ) printf("El primer apellido es menor que else printf("El primer apellido es mayor que }
*/ */
el segundo\n"); el segundo\n");
Ejercicio ALG.09.03 v1 en PASCAL (*******************************************************) (* Alg_09_03_v1 *) (* *) (* Algoritmo que pasa de cifras decimales a romanas. *) (*******************************************************) PROGRAM Alg_09_03_v1 (input,output); VAR numero : INTEGER; unidades, decenas, centenas, miles : INTEGER; tabla_unidades, tabla_decenas, tabla_centenas, tabla_miles : ARRAY [1..9] OF STRING[4]; BEGIN WRITELN('Alg 09.03 v1 : convertir cifras decimales y romanas'); WRITELN('---------------------------------------------------'); WRITELN; (* Inicializamos las tabla_unidades[1] := tabla_unidades[3] := tabla_unidades[5] := tabla_unidades[7] := tabla_unidades[9] :=
tablas *) 'I' ; 'III'; 'V' ; 'VII'; 'IX' ;
tabla_decenas[1] tabla_decenas[3] tabla_decenas[5] tabla_decenas[7] tabla_decenas[9]
:= := := := :=
tabla_centenas[1] tabla_centenas[3] tabla_centenas[5] tabla_centenas[7] tabla_centenas[9]
:= := := := :=
tabla_miles[1] tabla_miles[3]
:= 'M' ; := 'MMM';
tabla_unidades[2] tabla_unidades[4] tabla_unidades[6] tabla_unidades[8]
:= := := :=
'II' ; 'IV' ; 'VI' ; 'VIII';
'X' ; 'XXX'; 'L' ; 'LXX'; 'XC' ;
tabla_decenas[2] tabla_decenas[4] tabla_decenas[6] tabla_decenas[8]
:= := := :=
'XX' ; 'XL' ; 'LX' ; 'LXXX';
'C' ; 'CCC'; 'D' ; 'DCC'; 'CM' ;
tabla_centenas[2] tabla_centenas[4] tabla_centenas[6] tabla_centenas[8]
:= := := :=
'CC' ; 'CD' ; 'DC' ; 'DCCC';
tabla_miles[2]
:= 'MM';
(* Pedimos que el usuario introduzca un nĂşmero *) REPEAT WRITE('Introduzca un entero entre 1 y 3999 : '); READLN(numero); UNTIL (numero > 0) AND (numero < 4000); (* Determinamos los miles *) miles := numero DIV 1000; IF miles <> 0 THEN WRITE(tabla_miles[miles]); (* Determinamos las centenas *) centenas := (numero MOD 1000) DIV 100; IF centenas <> 0 THEN WRITE(tabla_centenas[centenas]); (* Determinamos las decenas *) decenas := (numero MOD 100) DIV 10; IF decenas <> 0 THEN WRITE(tabla_decenas[decenas]); (* Determinamos las unidades *) unidades := numero MOD 10; IF unidades <> 0 THEN WRITE(tabla_unidades[unidades]); WRITELN; END.
Ejercicio ALG.09.03 v1 en C /*******************************************************/ /* Alg_09_03_v1 */ /* */ /* Algoritmo que pasa de cifras decimales a romanas. */ /*******************************************************/
#include <stdio.h>
/* Programa principal */ void main (void) { int numero; int unidades, decenas, centenas, miles; char tabla_unidades[9][5] = {"I","II","III","IV","V","VI","VII","VIII","IX"} , tabla_decenas[9][5] = {"X","XX","XXX","XL","L","LX","LXX","LXXX","XC"} , tabla_centenas[9][5] = {"C","CC","CCC","CD","D","DC","DCC","DCCC","CM"} , tabla_miles[9][5] = {"M","MM","MMM"}; printf("Alg 09.03 v1 : convertir cifras decimales y romanas\n"); printf("---------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca un nĂşmero */ do { printf("Introduzca un entero entre 1 y 3999 : "); scanf("%d", &numero); } while ( (numero < 1) || (numero > 3999) ); /* Determinamos los miles */ miles = numero / 1000; if ( miles != 0 ) printf("%s", tabla_miles[miles-1]); /* Determinamos las centenas */ centenas = (numero % 1000) / 100; if ( centenas != 0 ) printf("%s", tabla_centenas[centenas-1]); /* Determinamos las decenas */ decenas = (numero % 100) / 10; if ( decenas != 0 ) printf("%s", tabla_decenas[decenas-1]); /* Determinamos las unidades */ unidades = numero % 10; if ( unidades != 0 ) printf("%s", tabla_unidades[unidades-1]); printf("\n"); }
Ejercicio ALG.09.03 v2 en PASCAL (*******************************************************) (* Alg_09_03_v2 *) (* *) (* Algoritmo que pasa de cifras decimales a romanas. *) (*******************************************************) PROGRAM Alg_09_03_v1 (input,output); VAR numero , longitud , digito , i : INTEGER; numero_str : STRING[4]; tabla : ARRAY [1..4,1..9] OF STRING[4]; BEGIN WRITELN('Alg 09.03 v1 : convertir cifras decimales y romanas'); WRITELN('---------------------------------------------------'); WRITELN; (* Inicializamos las tablas *) tabla[1,1] := 'I' ; tabla[2,1] tabla[1,2] := 'II' ; tabla[2,2] tabla[1,3] := 'III' ; tabla[2,3] tabla[1,4] := 'IV' ; tabla[2,4] tabla[1,5] := 'V' ; tabla[2,5] tabla[1,6] := 'VI' ; tabla[2,6] tabla[1,7] := 'VII' ; tabla[2,7] tabla[1,8] := 'VIII'; tabla[2,8] tabla[1,9] := 'IX' ; tabla[2,9] tabla[3,1] tabla[3,2] tabla[3,3] tabla[3,4] tabla[3,5] tabla[3,6] tabla[3,7] tabla[3,8] tabla[3,9]
:= := := := := := := := :=
'C' ; 'CC' ; 'CCC' ; 'CD' ; 'D' ; 'DC' ; 'DCC' ; 'DCCC'; 'CM' ;
:= := := := := := := := :=
'X' ; 'XX' ; 'XXX'; 'XL' ; 'L' ; 'LX' ; 'LXX'; 'LXXX'; 'XC' ;
tabla[4,1] := 'M' ; tabla[4,2] := 'MM'; tabla[4,3] := 'MMM';
(* Pedimos que el usuario introduzca un número *) REPEAT WRITE('Introduzca un entero entre 1 y 3999 : '); READLN(numero); UNTIL (numero > 0) AND (numero < 4000); (* Convertimos el número en una cadena de carácteres alfanumérica, *) (* para así trabajar comodamente con su longitud y sus dígitos. *) STR( numero , numero_str ); (* Obtenemos la longitud del número *) longitud := LENGTH( numero_str ); (* Escribimos el número con cifras romanas *) FOR i := longitud DOWNTO 1 DO BEGIN digito := ORD(numero_str[longitud+1-i]) - ORD('0'); IF digito <> 0 THEN WRITE(tabla[i,digito]); END; WRITELN; END.
Ejercicio ALG.09.03 v2 en C /*******************************************************/ /* Alg_09_03_v2 */ /* */ /* Algoritmo que pasa de cifras decimales a romanas. */ /*******************************************************/
#include <stdio.h> #include <stdlib.h> #include <string.h>
/* Programa principal */ void main (void) { int numero , longitud , digito , i; char numero_str[5]; char tabla[4][9][5] = { {"I","II","III","IV","V","VI","VII","VIII","IX"} , {"X","XX","XXX","XL","L","LX","LXX","LXXX","XC"} , {"C","CC","CCC","CD","D","DC","DCC","DCCC","CM"} , {"M","MM","MMM"} }; printf("Alg 09.03 v2 : convertir cifras decimales y romanas\n"); printf("---------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca un número */ do { printf("Introduzca un entero entre 1 y 3999 : "); scanf("%d", &numero); } while ( (numero < 1) || (numero > 3999) ); /* Convertimos el número en una cadena de carácteres alfanumérica, */ /* para así trabajar comodamente con su longitud y sus dígitos. */ itoa(numero , numero_str , 10 ); /* Obtenemos la longitud del número */ longitud = strlen(numero_str); /* Escribimos el número con cifras romanas */ for (i = longitud; i > 0; i--) { digito = numero_str[longitud-i] - '0'; if ( digito != 0 ) printf("%s", tabla[i-1][digito-1]); }; printf("\n"); }
Ejercicio ALG.09.04 en PASCAL (**********************************************************) (* Alg_09_04 *) (* *) (* Algoritmo que conjuga un tiempo determinado los verbos *) (* regulares de una conjugación en cualquier idioma. *) (**********************************************************) PROGRAM Alg_09_04 (input,output); CONST num_personas = 6; VAR i , persona verbo raiz conjugacion pronombre terminacion
: : : : : :
INTEGER; STRING[15]; STRING[13]; STRING[2]; ARRAY [1..num_personas] OF STRING[8]; ARRAY [1..3 , 1..num_personas] OF STRING[4];
BEGIN WRITELN('Alg 09.04 : conjugar un verbo regular'); WRITELN('-------------------------------------'); WRITELN; (* Inicializamos las tablas. (* En nuestro caso la conjugación es el presente de pronombre[1] := 'yo'; terminacion[1,1] pronombre[2] := 'tú'; terminacion[1,2] pronombre[3] := 'él'; terminacion[1,3] pronombre[4] := 'nosotros'; terminacion[1,4] pronombre[5] := 'vosotros'; terminacion[1,5] pronombre[6] := 'ellos'; terminacion[1,6]
*) indicativo. *) := 'o'; := 'as'; := 'a'; := 'amos'; := 'ais'; := 'an';
terminacion[2,1] terminacion[2,2] terminacion[2,3] terminacion[2,4] terminacion[2,5] terminacion[2,6]
:= := := := := :=
:= := := := := :=
'o'; 'es'; 'e'; 'emos'; 'eis'; 'en';
terminacion[3,1] terminacion[3,2] terminacion[3,3] terminacion[3,4] terminacion[3,5] terminacion[3,6]
'o'; 'es'; 'e'; 'imos'; 'ís'; 'en';
(* Pedimos que el usuario introduzca una verbo regular. *) (* Suponemos que lo introduce en minúsculas. *) REPEAT WRITE('Escriba en minúsculas el infinitivo de un verbo regular : '); READLN(verbo); i := LENGTH(verbo); raiz := COPY(verbo, 1, i-2); conjugacion := COPY(verbo, i-1, i); UNTIL (conjugacion = 'ar') OR (conjugacion = 'er') OR (conjugacion = 'ir'); CASE conjugacion[1] OF 'a' : i := 1; 'e' : i := 2; 'i' : i := 3; END; WRITELN; WRITELN('Presente de indicativo'); WRITELN('----------------------'); FOR persona := 1 TO 6 DO WRITELN(pronombre[persona], ' ', raiz, terminacion[i,persona]); END.
Ejercicio ALG.09.04 en C /**********************************************************/ /* Alg_09_04 */ /* */ /* Algoritmo que conjuga un tiempo determinado los verbos */ /* regulares de una conjugación en cualquier idioma. */ /**********************************************************/
#include <stdio.h> #include <string.h>
#define num_personas 6
/* Programa principal */ void main (void) { int i , persona; char verbo[16] , raiz[14]; char conjugacion[3]; char pronombre[num_personas][9] = {"yo", "tú", "él", "nosotros", "vosotros", "ellos"}; char terminacion[3][num_personas][5] = { {"o", "as", "a", "amos", "ais", "an"} , {"o", "es", "e", "emos", "eis", "en"} , {"o", "es", "e", "imos", "ís", "en"} }; printf("Alg 09.04 : conjugar un verbo regular\n"); printf("-------------------------------------\n\n"); /* Pedimos que el usuario introduzca una verbo regular. */ /* Suponemos que lo introduce en minúsculas. */ do { printf("Escriba en minúsculas el infinitivo de un verbo regular : "); scanf("%15s", verbo); i = strlen(verbo); strncpy(raiz, verbo, i-2); raiz[i-2] = '\0'; strncpy(conjugacion, &verbo[i-2], 3); } while ( ( (conjugacion[0] != 'a') && (conjugacion[0] != 'e') && (conjugacion[0] != 'i') ) || (conjugacion[1] != 'r') ); switch ( conjugacion[0] ) { case 'a' : i = 0; break; case 'e' : i = 1; break; case 'i' : i = 2; break; }; printf("\nPresente de indicativo\n"); printf("----------------------\n"); for (persona = 0; persona < 6; persona++) printf("%s %s%s\n", pronombre[persona], raiz, terminacion[i][persona]); }
Ejercicio ALG.10.01 v1 en PASCAL (*******************************************************) (* Alg_10_01_v1 *) (* *) (* Algoritmo que valida un dato entero sin signo. *) (*******************************************************) PROGRAM Alg_10_01_v1 (input,output); VAR dato : STRING; error : BOOLEAN;
(* ValidarEntero: *) (* Procedimiento que valida un dato entero sin signo. *) (* - La variable 'entero' contiene el dato. *) (* - En la variable 'error' devuelve un valor booleano segĂşn si el dato *) (* es entero o no. *) PROCEDURE ValidarEntero(entero:STRING; VAR error:BOOLEAN); VAR i , longitud : INTEGER; BEGIN longitud := LENGTH(entero); IF longitud = 0 THEN error := TRUE ELSE BEGIN error := FALSE; i := 1; WHILE (i <= longitud) AND (error = FALSE) DO IF (entero[i] < '0') OR (entero[i] > '9') THEN error := TRUE ELSE i := i + 1; END; END;
BEGIN WRITELN('Alg 10.01 v1 : algoritmo para validar un dato entero'); WRITELN('----------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca el dato *) WRITE('Introduzca un entero : '); READLN(dato); (* Comprobamos que sea un dato entero *) ValidarEntero(dato, error); IF error THEN WRITELN('Entero incorrecto') ELSE WRITELN('Entero correcto'); END.
Ejercicio ALG.10.01 v1 en C /*******************************************************/ /* Alg_10_01_v1 */ /* */ /* Algoritmo que valida un dato entero sin signo. */ /*******************************************************/
#include <stdio.h> #include <string.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* ValidarEntero: */ /* Procedimiento que valida un dato entero sin signo. */ /* - La variable 'entero' contiene el dato. */ /* - En la variable 'error' devuelve un valor booleano segĂşn si el dato */ /* es entero o no. */ void ValidarEntero(char *entero, boolean *error) { int i , longitud; longitud = strlen(entero); if (longitud == 0) *error = TRUE; else { *error = FALSE; i = 0; while ((i < longitud) && (*error == FALSE)) { if ((entero[i] < '0') || (entero[i] > '9')) *error = TRUE; else i++; }; }; }
/* Programa principal */ void main (void) { char dato[25+1]; boolean error; printf("Alg 10.01 v1 : algoritmo para validar un dato entero\n"); printf("----------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca el dato */ printf("Introduzca un entero : "); scanf("%25s", dato); /* Comprobamos que sea un dato entero */ ValidarEntero(dato, &error); if (error) printf("Entero incorrecto\n"); else printf("Entero correcto\n"); }
Ejercicio ALG.10.01 v2 en PASCAL (*******************************************************) (* Alg_10_01_v2 *) (* *) (* Algoritmo que valida un dato entero con signo. *) (*******************************************************) PROGRAM Alg_10_01_v2 (input,output); VAR dato : STRING; error : BOOLEAN;
(* ValidarEntero: *) (* Procedimiento que valida un dato entero con signo. *) (* - La variable 'entero' contiene el dato. *) (* - En la variable 'error' devuelve un valor booleano segĂşn si el dato *) (* es entero o no. *) PROCEDURE ValidarEntero(entero:STRING; VAR error:BOOLEAN); VAR i , longitud : INTEGER; BEGIN longitud := LENGTH(entero); IF longitud = 0 THEN error := TRUE ELSE BEGIN error := FALSE; i := 1; IF (entero[1] = '+') OR (entero[1] = '-') THEN IF longitud = 1 THEN BEGIN error := TRUE; i := longitud + 1; END ELSE i := 2; WHILE i <= longitud DO IF (entero[i] < '0') OR (entero[i] > '9') THEN BEGIN error := TRUE; i := longitud + 1; END ELSE i := i + 1; END; END;
BEGIN WRITELN('Alg 10.01 v2 : algoritmo para validar un dato entero'); WRITELN('----------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca el dato *) WRITE('Introduzca un entero : '); READLN(dato); (* Comprobamos que sea un dato entero *) ValidarEntero(dato, error); IF error THEN WRITELN('Entero incorrecto') ELSE WRITELN('Entero correcto'); END.
Ejercicio ALG.10.01 v2 en C /*******************************************************/ /* Alg_10_01_v2 */ /* */ /* Algoritmo que valida un dato entero con signo. */ /*******************************************************/
#include <stdio.h> #include <string.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* ValidarEntero: */ /* Procedimiento que valida un dato entero con signo. */ /* - La variable 'entero' contiene el dato. */ /* - En la variable 'error' devuelve un valor booleano segĂşn si el dato */ /* es entero o no. */ void ValidarEntero(char *entero, boolean *error) { int i , longitud; longitud = strlen(entero); if (longitud == 0) *error = TRUE; else { *error = FALSE; i = 0; if ((entero[0] == '+') || (entero[0] == '-')) if (longitud == 1) { *error = TRUE; i = longitud + 1; } else i = 1; while (i < longitud) { if ((entero[i] < '0') || (entero[i] > '9')) { *error = TRUE; i = longitud + 1; } else i++; }; }; }
/* Programa principal */ void main (void) { char dato[25+1]; boolean error; printf("Alg 10.01 v2 : algoritmo para validar un dato entero\n"); printf("----------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca el dato */ printf("Introduzca un entero : "); scanf("%25s", dato); /* Comprobamos que sea un dato entero */ ValidarEntero(dato, &error); if (error) printf("Entero incorrecto\n"); else printf("Entero correcto\n"); }
Ejercicio ALG.10.01 v3 en PASCAL (**************************************************************************) (* Alg_10_01_v3 *) (* *) (* Algoritmo que valida un dato entero con signo a partir de un aut贸mata. *) (**************************************************************************) PROGRAM Alg_10_01_v3 (input,output); VAR dato : STRING; error : BOOLEAN;
(* ValidarEntero: *) (* Procedimiento que valida un dato entero con signo. *) (* - La variable 'entero' contiene el dato. *) (* - En la variable 'error' devuelve un valor booleano seg煤n si el dato *) (* es entero o no. *) PROCEDURE ValidarEntero(entero:STRING; VAR error:BOOLEAN); VAR i : INTEGER; caracter : CHAR; estado : (e_I , e_1 , e_2, e_F, e_E); BEGIN entero := entero + #0; estado := e_I; i := 0; REPEAT i := i + 1; caracter := entero[i]; CASE estado OF e_I : CASE caracter OF '+', '-' : estado := e_1; '0'..'9' : estado := e_2; ELSE estado := e_E; END; e_1 : CASE caracter OF '0'..'9' : estado := e_2; ELSE estado := e_E; END; e_2 : CASE caracter OF '0'..'9' : estado := e_2; #0 : estado := e_F; ELSE estado := e_E; END; END; UNTIL (estado = e_E) OR (estado = e_F); error := (estado = e_E); END;
BEGIN WRITELN('Alg 10.01 v3 : algoritmo para validar un dato entero'); WRITELN('----------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca el dato *) WRITE('Introduzca un entero : '); READLN(dato); (* Comprobamos que sea un dato entero *) ValidarEntero(dato, error); IF error THEN WRITELN('Entero incorrecto') ELSE WRITELN('Entero correcto'); END.
Ejercicio ALG.10.01 v3 en C /**************************************************************************/ /* Alg_10_01_v3 */ /* */ /* Algoritmo que valida un dato entero con signo a partir de un aut贸mata. */ /**************************************************************************/
#include <stdio.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* ValidarEntero: */ /* Procedimiento que valida un dato entero con signo. */ /* - La variable 'entero' contiene el dato. */ /* - En la variable 'error' devuelve un valor booleano seg煤n si el dato */ /* es entero o no. */ void ValidarEntero(char *entero, boolean *error) { int i; char caracter; enum {e_I, e_1, e_2, e_F, e_E} estado; estado = e_I; i = 0; do { caracter = entero[i++]; switch (estado) { case e_I : switch(caracter) { case '+' : case '-' : estado case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado default : estado }; break; case e_1 : switch(caracter) { case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado default : estado }; break; case e_2 : switch(caracter) { case '0' : case '1' : case '2' : case '3' : case '4' :
= e_1; break;
= e_2; break; = e_E;
= e_2; break; = e_E;
case '5' case '6' case '7' case '8' case '9' case 0 default }; break;
: : : : : estado = e_2; break; : estado = e_F; break; : estado = e_E;
}; } while ((estado != e_E) && (estado != e_F)); *error = (estado == e_E); }
/* Programa principal */ void main (void) { char dato[25+1]; boolean error; printf("Alg 10.01 v3 : algoritmo para validar un dato entero\n"); printf("----------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca el dato */ printf("Introduzca un entero : "); scanf("%25s", dato); /* Comprobamos que sea un dato entero */ ValidarEntero(dato, &error); if (error) printf("Entero incorrecto\n"); else printf("Entero correcto\n"); }
Ejercicio ALG.10.01 v4 en PASCAL (**************************************************************************) (* Alg_10_01_v4 *) (* *) (* Algoritmo que valida un dato entero con signo a partir de un aut贸mata. *) (* En esta ocasi贸n el dato se valida al mismo tiempo que se lee. *) (**************************************************************************) PROGRAM Alg_10_01_v4 (input,output); USES CRT; VAR dato
: STRING;
(* ValidarEntero: *) (* Procedimiento que valida un dato entero con signo leido por teclado. *) (* - En la variable 'entero' devuelve el dato leido. *) PROCEDURE ValidarEntero(VAR entero:STRING); VAR caracter : CHAR; estado : (e_I , e_1 , e_2, e_F, e_E); BEGIN estado := e_I; REPEAT caracter := READKEY; CASE estado OF e_I : CASE caracter OF '+', '-' : BEGIN estado := e_1; WRITE(caracter); entero := entero + caracter; END; '0'..'9' : BEGIN estado := e_2; WRITE(caracter); entero := entero + caracter; END; #8 : (* No hace falta hacer nada *) END; e_1 : CASE caracter OF '0'..'9' : BEGIN estado := e_2; WRITE(caracter); entero := entero + caracter; END; #8 : BEGIN estado := e_I; WRITELN; entero := ''; END; END; e_2 : CASE caracter OF '0'..'9' : BEGIN estado := e_2; WRITE(caracter); entero := entero + caracter; END; #13 : BEGIN estado := e_F; WRITELN; END; #8 : BEGIN estado := e_I; WRITELN; entero := ''; END; END; END;
UNTIL estado = e_F; END;
BEGIN WRITELN('Alg 10.01 v4 : algoritmo para validar un dato entero'); WRITELN('----------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca el dato *) WRITELN('Introduzca un entero : '); ValidarEntero(dato); (* Imprimimos el dato introducido por el usuario *) WRITELN('El dato introducido es ' , dato); END.
Ejercicio ALG.10.01 v4 en C /**************************************************************************/ /* Alg_10_01_v4 */ /* */ /* Algoritmo que valida un dato entero con signo a partir de un aut贸mata. */ /* En esta ocasi贸n el dato se valida al mismo tiempo que se lee. */ /**************************************************************************/
#include <stdio.h> #include <conio.h>
/* ValidarEntero: */ /* Procedimiento que valida un dato entero con signo leido por teclado. */ /* - En la variable 'entero' devuelve el dato leido. */ void ValidarEntero(char *entero) { int i; char caracter; enum {e_I, e_1, e_2, e_F, e_E} estado; estado = e_I; i = 0; do { caracter = getch(); switch (estado) { case e_I : switch(caracter) { case '+' : case '-' : entero[i++] = caracter; printf("%c",caracter); estado = e_1; break; case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : entero[i++] = caracter; printf("%c",caracter); estado = e_2; break; case 8 : /* No hace falta hacer nada */; }; break; case e_1 : switch(caracter) { case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : entero[i++] = caracter; printf("%c",caracter); estado = e_2; break; case 8 : i = 0; printf("\n"); estado = e_I; }; break; case e_2 : switch(caracter) { case '0' :
case case case case case case case case case
'1' '2' '3' '4' '5' '6' '7' '8' '9'
: : : : : : : : : entero[i++] = caracter; printf("%c",caracter); estado = e_2; break; case '\r': entero[i++] = caracter; entero[i] = 0; printf("\n"); estado = e_F; break; case 8 : i = 0; printf("\n"); estado = e_I; }; break; }; } while (estado != e_F); }
/* Programa principal */ void main (void) { char dato[25+1]; printf("Alg 10.01 v4 : algoritmo para validar un dato entero\n"); printf("----------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca el dato */ printf("Introduzca un entero : \n"); ValidarEntero(dato); /* Imprimimos el dato introducido por el usuario */ printf("El dato introducido es %s\n", dato); }
Ejercicio ALG.10.02 v1 en PASCAL (******************************************************************) (* Alg_10_02_v1 *) (* *) (* Algoritmo que valida un dato numérico a partir de un autómata. *) (******************************************************************) PROGRAM Alg_10_02_v1 (input,output); VAR dato : STRING; error : BOOLEAN;
(* ValidarNumero: (* Procedimiento que valida un dato numérico con signo y decimales. (* - La variable 'numero' contiene el dato. (* - En la variable 'error' devuelve un valor booleano según si el dato (* es numérico o no. PROCEDURE ValidarNumero(numero:STRING; VAR error:BOOLEAN); VAR i : INTEGER; caracter : CHAR; estado : (e_I , e_1 , e_2, e_3, e_4, e_F, e_E); BEGIN numero := numero + #0; estado := e_I; i := 0; REPEAT i := i + 1; caracter := numero[i]; CASE estado OF e_I : CASE caracter OF '+', '-' : estado := e_3; '.' : estado := e_4; '0'..'9' : estado := e_1; ELSE estado := e_E; END; e_1 : CASE caracter OF '.' : estado := e_2; '0'..'9' : estado := e_1; #0 : estado := e_F; ELSE estado := e_E; END; e_2 : CASE caracter OF '0'..'9' : estado := e_2; #0 : estado := e_F; ELSE estado := e_E; END; e_3 : CASE caracter OF '.' : estado := e_4; '0'..'9' : estado := e_1; ELSE estado := e_E; END; e_4 : CASE caracter OF '0'..'9' : estado := e_2; ELSE estado := e_E; END; END; UNTIL (estado = e_E) OR (estado = e_F); error := (estado = e_E); END;
BEGIN WRITELN('Alg 10.02 v1 : algoritmo para validar un dato numérico'); WRITELN('------------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca el dato *) WRITE('Introduzca un número : ');
*) *) *) *) *)
READLN(dato); (* Comprobamos que sea un dato numérico *) ValidarNumero(dato, error); IF error THEN WRITELN('Número incorrecto') ELSE WRITELN('Número correcto'); END.
Ejercicio ALG.10.02 v1 en C /******************************************************************/ /* Alg_10_02_v1 */ /* */ /* Algoritmo que valida un dato numérico a partir de un autómata. */ /******************************************************************/
#include <stdio.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* ValidarNumero: /* Procedimiento que valida un dato numérico con signo y decimales. /* - La variable 'numero' contiene el dato. /* - En la variable 'error' devuelve un valor booleano según si el dato /* es numérico o no. void ValidarNumero(char *numero, boolean *error) { int i; char caracter; enum {e_I, e_1, e_2, e_3, e_4, e_F, e_E} estado; estado = e_I; i = 0; do { caracter = numero[i++]; switch (estado) { case e_I : switch(caracter) { case '+' : case '-' : estado case '.' : estado case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado default : estado }; break; case e_1 : switch(caracter) { case '.' : estado case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado case 0 : estado default : estado }; break; case e_2 : switch(caracter) { case '0' : case '1' :
= e_3; break; = e_4; break;
= e_1; break; = e_E;
= e_2; break;
= e_1; break; = e_F; break; = e_E;
*/ */ */ */ */
case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado = e_2; break; case 0 : estado = e_F; break; default : estado = e_E; }; break; case e_3 : switch(caracter) { case '.' : estado = e_4; break; case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado = e_1; break; default : estado = e_E; }; break; case e_4 : switch(caracter) { case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado = e_2; break; default : estado = e_E; }; break; }; } while ((estado != e_E) && (estado != e_F)); *error = (estado == e_E); }
/* Programa principal */ void main (void) { char dato[25+1]; boolean error; printf("Alg 10.02 v1 : algoritmo para validar un dato numérico\n"); printf("------------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca el dato */ printf("Introduzca un numero : "); scanf("%25s", dato); /* Comprobamos que sea un dato numérico */ ValidarNumero(dato, &error); if (error) printf("Número incorrecto\n"); else printf("Número correcto\n"); }
Ejercicio ALG.10.02 v2 en PASCAL (******************************************************************) (* Alg_10_02_v2 *) (* *) (* Algoritmo que valida un dato numérico a partir de un autómata. *) (******************************************************************) PROGRAM Alg_10_02_v1 (input,output); CONST MAX_INT = 11; MAX_FRAC = 11; VAR dato : STRING; error : BOOLEAN;
(* ValidarNumero: (* Procedimiento que valida un dato numérico con signo y decimales. (* - La variable 'numero' contiene el dato. (* - En la variable 'error' devuelve un valor booleano según si el dato (* es numérico o no. PROCEDURE ValidarNumero(numero:STRING; VAR error:BOOLEAN); VAR i, j, k : INTEGER; caracter : CHAR; estado : (e_I , e_1 , e_2, e_3, e_4, e_F, e_E); BEGIN numero := numero + #0; estado := e_I; i := 0; j := 0; k := 0; REPEAT i := i + 1; caracter := numero[i]; CASE estado OF e_I : CASE caracter OF '+', '-' : estado := e_3; '.' : estado := e_4; '0'..'9' : BEGIN estado := e_1; k := 1; END; ELSE estado := e_E; END; e_1 : CASE caracter OF '.' : estado := e_2; '0'..'9' : k := k + 1; #0 : estado := e_F; ELSE estado := e_E; END; e_2 : CASE caracter OF '0'..'9' : j := j + 1; #0 : estado := e_F; ELSE estado := e_E; END; e_3 : CASE caracter OF '.' : estado := e_4; '0'..'9' : BEGIN estado := e_1; k := 1; END; ELSE estado := e_E; END; e_4 : CASE caracter OF '0'..'9' : BEGIN estado := e_2; j := 1; END;
*) *) *) *) *)
ELSE END;
estado := e_E;
END; IF (k > MAX_INT) OR (j > MAX_FRAC) THEN estado := e_E; UNTIL (estado = e_E) OR (estado = e_F); error := (estado = e_E); END;
BEGIN WRITELN('Alg 10.02 v2 : algoritmo para validar un dato numérico'); WRITELN('------------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca el dato *) WRITE('Introduzca un número : '); READLN(dato); (* Comprobamos que sea un dato numérico *) ValidarNumero(dato, error); IF error THEN WRITELN('Número incorrecto') ELSE WRITELN('Número correcto'); END.
Ejercicio ALG.10.02 v2 en C /******************************************************************/ /* Alg_10_02_v2 */ /* */ /* Algoritmo que valida un dato numérico a partir de un autómata. */ /******************************************************************/
#include <stdio.h>
#define MAX_INT 11 #define MAX_FRAC 11
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* ValidarNumero: /* Procedimiento que valida un dato numérico con signo y decimales. /* - La variable 'numero' contiene el dato. /* - En la variable 'error' devuelve un valor booleano según si el dato /* es numérico o no. void ValidarNumero(char *numero, boolean *error) { int i = 0, j = 0, k = 0; char caracter; enum {e_I, e_1, e_2, e_3, e_4, e_F, e_E} estado; estado = e_I; do { caracter = numero[i++]; switch (estado) { case e_I : switch(caracter) { case '+' : case '-' : estado = e_3; case '.' : estado = e_4; case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado = e_1; default : estado = e_E; }; break; case e_1 : switch(caracter) { case '.' : estado = e_2; case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : k++; break; case 0 : estado = e_F; default : estado = e_E; }; break;
break; break;
k = 1; break;
break;
break;
*/ */ */ */ */
case e_2 : switch(caracter) { case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : j++; break; case 0 : estado = e_F; break; default : estado = e_E; }; break; case e_3 : switch(caracter) { case '.' : estado = e_4; break; case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado = e_1; k = 1; break; default : estado = e_E; }; break; case e_4 : switch(caracter) { case '0' : case '1' : case '2' : case '3' : case '4' : case '5' : case '6' : case '7' : case '8' : case '9' : estado = e_2; j = 1; break; default : estado = e_E; }; break; }; if ((k > MAX_INT) || (j > MAX_FRAC)) estado = e_E; } while ((estado != e_E) && (estado != e_F)); *error = (estado == e_E); }
/* Programa principal */ void main (void) { char dato[25+1]; boolean error; printf("Alg 10.02 v2 : algoritmo para validar un dato numérico\n"); printf("------------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca el dato */ printf("Introduzca un numero : "); scanf("%25s", dato); /* Comprobamos que sea un dato numérico */ ValidarNumero(dato, &error); if (error) printf("Número incorrecto\n");
else printf("NĂşmero correcto\n"); }
Ejercicio ALG.10.03 v1 en PASCAL (**************************************************************) (* Alg_10_03_v1 *) (* *) (* Algoritmo que valida un código numérico de formato NNNN-D. *) (**************************************************************) PROGRAM Alg_10_03_v1 (input,output); CONST p1 p2 p3 p4
= = = =
0.4; 0.3; 0.2; 0.1;
VAR dato : STRING; error : BOOLEAN; BEGIN WRITELN('Alg 10.03 v1 : algoritmo para validar un código numérico'); WRITELN('--------------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca el código *) WRITE('Introduzca un código de formato NNNN-D : '); READLN(dato); (* Comprobamos que sea un código correcto *) error := FALSE; IF (LENGTH(dato) = 6) AND (dato[5] = '-') THEN IF (dato[1] IN ['0'..'9']) AND (dato[2] IN ['0'..'9']) AND (dato[3] IN ['0'..'9']) AND (dato[4] IN ['0'..'9']) THEN BEGIN IF p1*(ORD(dato[1])-ORD('0')) - p2*(ORD(dato[2])-ORD('0')) + p3*(ORD(dato[3])-ORD('0')) - p4*(ORD(dato[4])-ORD('0')) <> ORD(dato[6])-ORD('0') THEN error := TRUE; END ELSE error := TRUE ELSE error := TRUE; IF error THEN WRITELN('Código incorrecto') ELSE WRITELN('Código correcto'); END.
Ejercicio ALG.10.03 v1 en C /**************************************************************/ /* Alg_10_03_v1 */ /* */ /* Algoritmo que valida un código numérico de formato NNNN-D. */ /**************************************************************/
#include <stdio.h> #include <string.h>
#define #define #define #define
p1 p2 p3 p4
0.4 0.3 0.2 0.1
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* Programa principal */ void main (void) { char dato[25+1]; boolean error; printf("Alg 10.03 v1 : algoritmo para validar un código numérico\n"); printf("--------------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca el código */ printf("Introduzca un código de formato NNNN-D : "); scanf("%25s", dato); /* Comprobamos que sea un código correcto */ error = FALSE; if ((strlen(dato) == 6) && (dato[4] == '-')) if ((dato[0] > '0') && (dato[0] < '9') && (dato[1] > '0') && (dato[1] < '9') && (dato[2] > '0') && (dato[2] < '9') && (dato[3] > '0') && (dato[3] < '9')) { if (p1*(dato[0]-'0') - p2*(dato[1]-'0') + p3*(dato[2]-'0') - p4*(dato[3]-'0') != dato[5]-'0') error = TRUE; } else error = TRUE; else error = TRUE; if (error) printf("Código incorrecto\n"); else printf("Código correcto\n"); }
Ejercicio ALG.10.03 v2 en PASCAL (**************************************************************) (* Alg_10_03_v2 *) (* *) (* Algoritmo que valida un código numérico de formato NNNN-D. *) (**************************************************************) PROGRAM Alg_10_03_v2 (input,output); CONST p1 p2 p3 p4
= = = =
0.4; 0.3; 0.2; 0.1;
VAR dato : STRING; error : BOOLEAN; BEGIN WRITELN('Alg 10.03 v2 : algoritmo para validar un código numérico'); WRITELN('--------------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca el código *) WRITE('Introduzca un código de formato NNNN-D : '); READLN(dato); (* Comprobamos que sea un código correcto *) error := TRUE; IF (LENGTH(dato) = 6) AND (dato[5] = '-') THEN IF (dato[1] IN ['0'..'9']) AND (dato[2] IN ['0'..'9']) AND (dato[3] IN ['0'..'9']) AND (dato[4] IN ['0'..'9']) THEN IF p1*(ORD(dato[1])-ORD('0')) - p2*(ORD(dato[2])-ORD('0')) + p3*(ORD(dato[3])-ORD('0')) - p4*(ORD(dato[4])-ORD('0')) = ORD(dato[6])-ORD('0') THEN error := FALSE; IF error THEN WRITELN('Código incorrecto') ELSE WRITELN('Código correcto'); END.
Ejercicio ALG.10.03 v2 en C /**************************************************************/ /* Alg_10_03_v2 */ /* */ /* Algoritmo que valida un código numérico de formato NNNN-D. */ /**************************************************************/
#include <stdio.h> #include <string.h>
#define #define #define #define
p1 p2 p3 p4
0.4 0.3 0.2 0.1
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* Programa principal */ void main (void) { char dato[25+1]; boolean error; printf("Alg 10.03 v2 : algoritmo para validar un código numérico\n"); printf("--------------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca el código */ printf("Introduzca un código de formato NNNN-D : "); scanf("%25s", dato); /* Comprobamos que sea un código correcto */ error = TRUE; if ((strlen(dato) == 6) && (dato[4] == '-')) if ((dato[0] > '0') && (dato[0] < '9') && (dato[1] > '0') && (dato[1] < '9') && (dato[2] > '0') && (dato[2] < '9') && (dato[3] > '0') && (dato[3] < '9')) if (p1*(dato[0]-'0') - p2*(dato[1]-'0') + p3*(dato[2]-'0') - p4*(dato[3]-'0') == dato[5]-'0') error = FALSE; if (error) printf("Código incorrecto\n"); else printf("Código correcto\n"); }
Ejercicio ALG.10.04 v1 en PASCAL (********************************************************) (* Alg_10_04_v1 *) (* *) (* Algoritmo que valida una fecha con formato DD/MM/AA. *) (********************************************************) PROGRAM Alg_10_04_v1 (input,output); VAR dato : STRING; dia , mes , ano : INTEGER; error : BOOLEAN; error_int : INTEGER;
(* dias: (* Función que devuelve el número de días del mes pasado como parámetro. (* Si el mes es incorrecto devuelve -1. (* No funciona para febrero, que puede tener 29 dias si el año es bisiesto FUNCTION dias(mes:INTEGER):INTEGER; BEGIN CASE mes OF 1,3,5,7,8,10,12 : dias := 31; 4,6,9,11 : dias := 30; 2 : dias := 28; ELSE dias := -1; END; END;
BEGIN WRITELN('Alg 10.04 v1 : algoritmo para validar una fecha DD/MM/AA'); WRITELN('--------------------------------------------------------'); WRITELN; (* Pedimos que el usuario introduzca la fecha *) WRITE('Introduzca una fecha con formato DD/MM/AA : '); READLN(dato); (* Comprobamos que sea una fecha correcta *) error := FALSE; IF NOT ((LENGTH(dato) = 8) AND (dato[1] IN ['0'..'9']) AND (dato[2] IN ['0'..'9']) AND (dato[3] = '/') AND (dato[4] IN ['0'..'9']) AND (dato[5] IN ['0'..'9']) AND (dato[6] = '/') AND (dato[7] IN ['0'..'9']) AND (dato[8] IN ['0'..'9'])) THEN error := TRUE ELSE BEGIN VAL(dato[1] + dato[2], dia, error_int); VAL(dato[4] + dato[5], mes, error_int); VAL(dato[7] + dato[8], ano, error_int); IF (mes < 1) OR (mes > 12) THEN error := TRUE ELSE IF dia < 1 THEN error := TRUE ELSE IF mes <> 2 THEN BEGIN IF dia > dias(mes) THEN error := TRUE END ELSE
*) *) *) *)
IF (ano MOD BEGIN IF dia > error END ELSE IF dia > error
4) = 0 THEN 29 THEN := TRUE
28 THEN := TRUE;
END; IF error THEN WRITELN('Fecha incorrecta') ELSE WRITELN('Fecha correcta'); END.
Ejercicio ALG.10.04 v1 en C /********************************************************/ /* Alg_10_04_v1 */ /* */ /* Algoritmo que valida una fecha con formato DD/MM/AA. */ /********************************************************/
#include <stdio.h> #include <string.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* dias: /* Función que devuelve el número de dias del mes pasado como parámetro. /* Si el mes es incorrecto devuelve -1. /* No funciona para febrero, que puede tener 29 dias si el año es bisiesto int dias(int mes) { switch (mes) { case 1 : case 3 : case 5 : case 7 : case 8 : case 10 : case 12 : return(31); case 4 : case 6 : case 9 : case 11 : return(30); case 2 : return(28); default : return(-1); }; };
*/ */ */ */
/* Programa principal */ void main (void) { char dato[8+1]; char dato_aux[2+1]; int dia , mes , ano; boolean error; printf("Alg 10.04 v1 : algoritmo para validar una fecha DD/MM/AA\n"); printf("--------------------------------------------------------\n\n"); /* Pedimos que el usuario introduzca la fecha */ printf("Introduzca una fecha con formato DD/MM/AA : "); scanf("%8s", dato); /* Comprobamos que sea una error = FALSE; if (! ((strlen(dato) == 8) (dato[0] >= '0') && (dato[1] >= '0') && (dato[2] == '/') && (dato[3] >= '0') && (dato[4] >= '0') && (dato[5] == '/') && (dato[6] >= '0') && (dato[7] >= '0') && error = TRUE; else { dato_aux[2] = '\0'; dato_aux[0] = dato[0]; dato_aux[0] = dato[3];
fecha correcta */ && (dato[0] <= '9') && (dato[1] <= '9') && (dato[3] <= '9') && (dato[4] <= '9') && (dato[6] <= '9') && (dato[7] <= '9')) )
dato_aux[1] = dato[1]; dato_aux[1] = dato[4];
dia = atoi(dato_aux); mes = atoi(dato_aux);
dato_aux[0] = dato[6];
dato_aux[1] = dato[7];
if ((mes < 1) || (mes > 12)) error = TRUE; else if (dia < 1) error = TRUE; else if (mes != 2) { if (dia > dias(mes)) error = TRUE; } else if ((ano % 4) == 0) { if (dia > 29) error = TRUE; } else if (dia > 28) error = TRUE; }; if (error) printf("Fecha incorrecta\n"); else printf("Fecha correcta\n"); }
ano = atoi(dato_aux);
Ejercicio ALG.11.01 en PASCAL (********************************************************) (* Alg_11_01 *) (* *) (* Algoritmo que resuelve una ecuación de segundo grado *) (* del tipo a x^2 + b x + c = 0 *) (********************************************************) PROGRAM Alg_11_01 (input,output); VAR a, b, c x x1, x2 re, im discrim
: : : : :
REAL; REAL; REAL; REAL; REAL;
(* (* (* (* (*
Coeficientes de la ecuación Solución única Solución doble real Solución doble compleja Discriminante
*) *) *) *) *)
BEGIN WRITELN('Alg 11.01 : resolución de ecuaciones de segundo grado'); WRITELN('-----------------------------------------------------'); WRITELN; (* Pedimos los coeficientes de la equación *) WRITE('Introduce el coeficiente del término de grado 2 : '); READLN(a); WRITE('Introduce el coeficiente del término de grado 1 : '); READLN(b); WRITE('Introduce el coeficiente del término de grado 0 : '); READLN(c); IF a = 0 THEN (* La ecuación no es de segundo grado *) BEGIN IF b <> 0 THEN WRITELN('Solución real x = ' , -c/b) ELSE IF c = 0 THEN WRITELN('Infinitas soluciones.') ELSE WRITELN('Ninguna solución.') END ELSE (* La ecuación es de segundo grado *) BEGIN discrim := b*b - 4*a*c; IF discrim = 0 THEN BEGIN x := -b/(2*a); WRITELN('Solución real doble'); WRITELN('x = ',x); END ELSE IF discrim > 0 THEN BEGIN x1 := (-b + SQRT(discrim))/(2*a); x2 := (-b - SQRT(discrim))/(2*a); WRITELN('Dos soluciones reales'); WRITELN('x = ', x1); WRITELN('x = ', x2); END ELSE BEGIN re := -b/(2*a); im := SQRT(-discrim)/(2*a); WRITELN('Dos soluciones imaginarias'); WRITELN('x = ', re, ' + ', im, 'i');
WRITELN('x = ', re, ' - ', im, 'i'); END END; END.
Ejercicio ALG.11.01 en C /********************************************************/ /* Alg_11_01 */ /* */ /* Algoritmo que resuelve una ecuación de segundo grado */ /* del tipo a x^2 + b x + c = 0 */ /********************************************************/
#include <stdio.h> #include <math.h>
/* Programa principal */ void main (void) { float float float float float
a, b, c; x; x1, x2; re, im; discrim;
/* /* /* /* /*
Coeficientes de la ecuación Solución única Solución doble real Solución doble compleja Discriminante
*/ */ */ */ */
printf("Alg 11.01 : resolución de ecuaciones de segundo grado\n"); printf("-----------------------------------------------------\n\n"); /* Pedimos los coeficientes de la equación */ printf("Introduce el coeficiente del término de grado 2 : "); scanf("%f", &a); printf("Introduce el coeficiente del término de grado 1 : "); scanf("%f", &b); printf("Introduce el coeficiente del término de grado 0 : "); scanf("%f", &c); if (a == 0) { /* La ecuación no es de segundo grado */ if (b != 0) printf("Solución real x = %f\n" , -c/b); else if (c == 0) printf("Infinitas soluciones.\n"); else printf("Ninguna solución.\n"); } else { /* La ecuación es de segundo grado */ discrim = b*b - 4*a*c; if (discrim == 0) { x = -b/(2*a); printf("Solución real doble\n"); printf("x = %f\n",x); } else if (discrim > 0) { x1 = (-b + sqrt(discrim))/(2*a); x2 = (-b - sqrt(discrim))/(2*a); printf("Dos soluciones reales\n"); printf("x = %f\n", x1); printf("x = %f\n", x2); } else { re = -b/(2*a); im = sqrt(-discrim)/(2*a); printf("Dos soluciones imaginarias\n"); printf("x = %f + %fi\n", re, im); printf("x = %f - %fi\n", re, im); }
}; }
Ejercicio ALG.11.02 en PASCAL (********************************************************) (* Alg_11_02 *) (* *) (* Algoritmo que calcula el valor de una peseta dentro *) (* de t años en función del tipo de interés r, según la *) (* expresión C = C0 (1 + r)^t , C0 = C/(1 + r)^t *) (********************************************************) PROGRAM Alg_11_02 (input,output); VAR t, t0, tf, tinc : INTEGER; r, int_inicial, int_final, int_increm : REAL; BEGIN WRITELN('Alg 11.02 : Calculo del valor de la peseta'); WRITELN('------------------------------------------'); WRITELN; (* Pedimos el año inicial, el final y el incremento *) WRITE('Año inicial : '); READLN(t0); WRITE('Año final : '); READLN(tf); WRITE('Incremento : '); READLN(tinc); (* Pedimos el interés inicial, el final y el incremento *) WRITE('Interés inicial : '); READLN(int_inicial); WRITE('Interés final : '); READLN(int_final); WRITE('Incremento : '); READLN(int_increm); (* En Pascal la instrucción FOR (DESDE) solo se incrementa en 1 *) (* La sustituiremos por la instrucción WHILE *) (* Escribimos la cabecera *) WRITE(' '); t := t0; WHILE t <= tf DO BEGIN WRITE( t:10 ); t := t + tinc; END; WRITELN; (* Escribimos la cabecera *) WRITE(' +-'); t := t0; WHILE t <= tf DO BEGIN WRITE('----------'); t := t + tinc; END; WRITELN; (* Calculamos y escribimos la tabla de valores *) r := int_inicial; WHILE r <= int_final DO BEGIN WRITE( r:10:1 , '% |'); t := t0; WHILE t <= tf DO BEGIN (* (1 + r/100)^t = e^(t LN(1 + r/100)) WRITE( EXP(t*LN(1+r/100)):10:2 ); t := t + tinc;
*)
END; WRITELN; r := r + int_increm; END END.
Ejercicio ALG.11.02 en C /********************************************************/ /* Alg_11_02 */ /* */ /* Algoritmo que calcula el valor de una peseta dentro */ /* de t años en función del tipo de interés r, según la */ /* expresión C = C0 (1 + r)^t , C0 = C/(1 + r)^t */ /********************************************************/
#include <stdio.h> #include <math.h>
/* Programa principal */ void main (void) { int t, t0, tf, tinc; float r, int_inicial, int_final, int_increm; printf("Alg 11.02 : Calculo del valor de la peseta\n"); printf("------------------------------------------\n\n"); /* Pedimos el año inicial, el final y el incremento */ printf("Año inicial : "); scanf("%i", &t0); printf("Año final : "); scanf("%i", &tf); printf("Incremento : "); scanf("%i", &tinc); /* Pedimos el interés inicial, el final y el incremento */ printf("Interés inicial : "); scanf("%f", &int_inicial); printf("Interés final : "); scanf("%f", &int_final); printf("Incremento : "); scanf("%f", &int_increm); /* Escribimos la cabecera */ printf(" "); for (t = t0; t <= tf; t += tinc) printf("%10i", t); printf("\n"); /* Escribimos la cabecera */ printf(" +-"); for (t = t0; t <= tf; t += tinc) printf("----------"); printf("\n"); /* Calculamos y escribimos la tabla de valores */ for (r = int_inicial; r <= int_final; r += int_increm) { printf("%6.1f%% |", r); for (t = t0; t <= tf; t += tinc) /* (1 + r/100)^t = e^(t LN(1 + r/100)) */ printf("%10.2f", exp(t*log(1+r/100))); printf("\n"); }; };
Ejercicio ALG.11.03 en PASCAL (************************************************************) (* Alg_11_03 *) (* *) (* Algoritmo que dibuja una funci贸n senoidal en el terminal *) (************************************************************) PROGRAM Alg_11_03 (input,output); VAR columna : INTEGER; col_media : INTEGER; desplazamiento : INTEGER; x : REAL; tope : REAL; inc : REAL; BEGIN WRITELN('Alg 11.03 : dibujo de una funci贸n senoidal'); WRITELN('------------------------------------------'); WRITELN; col_media := 35; desplazamiento := 30; WRITE('Hasta que valor desea dibujar : '); READLN(tope); WRITE('Incremento : '); READLN(inc); (* En Pascal la instrucci贸n FOR (DESDE) solo se incrementa en 1 *) (* La sustituiremos por la instrucci贸n WHILE *) x := 0; WHILE x <= tope DO BEGIN WRITE( x:5:3 , ' | ' ); columna := ROUND(col_media + desplazamiento*SIN(x)); IF columna = col_media THEN WRITELN('*':columna) ELSE IF columna < col_media THEN WRITELN('*':columna, '.':col_media-columna) ELSE WRITELN('.':col_media, '*':columna-col_media); x := x + inc; END; END.
Ejercicio ALG.11.03 en C /************************************************************/ /* Alg_11_03 */ /* */ /* Algoritmo que dibuja una funci贸n senoidal en el terminal */ /************************************************************/
#include <stdio.h> #include <math.h>
/* tab: */ /* Subrutina que mueve el cursor a la derecha */ /* imprimiendo el n煤mero de espacios especificado. */ void tab (int n) { int i; for (i = 0; i < n; i++) putchar(' '); }
/* Programa principal */ void main (void) { int columna; int col_media; int desplazamiento; float x; float tope; float inc; printf("Alg 11.03 : dibujo de una funci贸n senoidal\n"); printf("------------------------------------------\n\n"); col_media = 35; desplazamiento = 30; printf("Hasta que valor desea dibujar : "); scanf("%f", &tope); printf("Incremento : "); scanf("%f", &inc); for (x = 0; x <= tope; x+= inc) { printf("%5.3f | ", x); columna = (int)(col_media + desplazamiento*sin(x)); if (columna == col_media) { tab(columna - 1); putchar('*'); putchar('\n'); } else if (columna < col_media) { tab(columna - 1); putchar('*'); tab(col_media - columna - 1); putchar('.'); putchar('\n'); } else { tab(col_media - 1); putchar('.'); tab(columna - col_media - 1); putchar('*'); putchar('\n'); } }; }
Ejercicio ALG.11.04 en PASCAL (************************************************************) (* Alg_11_04 *) (* *) (* Algoritmo que evalua el valor de un polinomio de grado n *) (* en un punto dado. *) (************************************************************) PROGRAM Alg_11_04 (input,output); CONST n = 5; VAR c : ARRAY [0..n] OF REAL; i : INTEGER; x : REAL; valor : REAL; BEGIN WRITELN('Alg 11.04 : evaluaci贸n de funciones polin贸micas'); WRITELN('------------------------------------------------'); WRITELN; (* Pedimos los coeficientes del polinomio *) WRITELN('Por favor, introduzca los coeficientes del polinomio'); WRITELN('des del t茅rmino de grado ', n, ' hasta el de grado 0'); FOR i := n DOWNTO 0 DO READLN(c[i]); REPEAT (* Pedimos el punto a evaluar *) WRITE('驴 Sobre que valor quiere evaluar el polinomio (0 acabar) ? '); READLN(x); (* Evaluamos el polinomio *) valor := c[n]; FOR i := n-1 DOWNTO 0 DO valor := valor*x + c[i]; (* Escribimos el resultado *) WRITELN('El polinomio evaluado sobre el punto ', x:4:2, ' vale ', valor:4:2); UNTIL x = 0; END.
Ejercicio ALG.11.04 en C /************************************************************/ /* Alg_11_04 */ /* */ /* Algoritmo que evalua el valor de un polinomio de grado n */ /* en un punto dado. */ /************************************************************/
#include <stdio.h> #include <math.h>
#define n 5
/* Programa principal */ void main (void) { float c[n+1]; int i; float x; float valor; printf("Alg 11.04 : evaluaci贸n de funciones polin贸micas\n"); printf("-----------------------------------------------\n\n"); /* Pedimos los coeficientes del polinomio */ printf("Por favor, introduzca los coeficientes del polinomio\n"); printf("des del t茅rmino de grado %i hasta el de grado 0\n", n); for (i = n; i >= 0; i--) scanf("%f", &c[i]); do { /* Pedimos el punto a evaluar */ printf("驴 Sobre que valor quiere evaluar el polinomio (0 acabar) ? "); scanf("%f", &x); /* Evaluamos el polinomio */ valor = c[n]; for (i = n-1; i >= 0; i--) valor = valor*x + c[i]; /* Escribimos el resultado */ printf("El polinomio evaluado sobre el punto %4.2f vale %4.2f\n", x, valor); } while (x != 0); }
Ejercicio ALG.11.05 en PASCAL (**************************************************************) (* Alg_11_05 *) (* *) (* Algoritmo que halla el máximo común divisor de dos números *) (* según el algoritmo de Euclides. *) (**************************************************************) PROGRAM Alg_11_05 (input,output); VAR x, y, r : INTEGER; BEGIN WRITELN('Alg 11.05 : máximo común divisor'); WRITELN('--------------------------------'); WRITELN; (* Pedimos WRITE('Por READLN(x); WRITE('Por READLN(y); r := x MOD
los dos números *) favor, introduzca el primer número : '); favor, introduzca el segundo número : '); y;
(* Aplicamos el algoritmo de Euclides *) WHILE r <> 0 DO BEGIN x := y; y := r; r := x MOD y; END; WRITELN('El máximo común divisor es ', y); END.
Ejercicio ALG.11.05 en C /**************************************************************/ /* Alg_11_05 */ /* */ /* Algoritmo que halla el máximo común divisor de dos números */ /* según el algoritmo de Euclides. */ /**************************************************************/
#include <stdio.h>
/* Programa principal */ void main (void) { int x, y, r; printf("Alg 11.05 : máximo común divisor\n"); printf("--------------------------------\n\n"); /* Pedimos los dos números */ printf("Por favor, introduzca el primer número : "); scanf("%d", &x); printf("Por favor, introduzca el segundo número : "); scanf("%d", &y); r = x % y; /* Aplicamos el algoritmo de Euclides */ while (r != 0) { x = y; y = r; r = x % y; }; printf("El máximo común divisor es %i\n", y); }
Ejercicio ALG.11.06 v1 en PASCAL (***********************************************************) (* Alg_11_06_v1 *) (* *) (* Algoritmo que imprime los números de tres cifras que no *) (* sean primos y cuya suma de centenas y decenas sea igual *) (* a las unidades. *) (***********************************************************) PROGRAM Alg_11_06_v1 (input,output); VAR i : INTEGER;
(* Primo : *) (* Función que devuelve TRUE o FALSE según sea el entero 'n' primo o no. *) FUNCTION Primo(n : INTEGER):BOOLEAN; VAR i : INTEGER; BEGIN Primo := TRUE; FOR i := 2 TO TRUNC(SQRT(n)) DO IF (n MOD i) = 0 THEN Primo := FALSE; END;
BEGIN WRITELN('Alg 11.06 v1 : no primos tal que centenas + decenas = unidades'); WRITELN('--------------------------------------------------------------'); WRITELN; FOR i := 100 TO 999 DO IF NOT Primo(i) THEN IF (i DIV 100) + ((i MOD 100) DIV 10) = (i MOD 10) THEN WRITELN(i); END.
Ejercicio ALG.11.06 v1 en C /***********************************************************/ /* Alg_11_06_v1 */ /* */ /* Algoritmo que imprime los números de tres cifras que no */ /* sean primos y cuya suma de centenas y decenas sea igual */ /* a las unidades. */ /***********************************************************/
#include <stdio.h> #include <math.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* Primo : */ /* Función que devuelve TRUE o FALSE según sea el entero 'n' primo o no. */ boolean Primo(int n) { int i; boolean prim; prim = TRUE; for (i = 2; i <= (int)(sqrt(n)); i++) if ((n % i) == 0) prim = FALSE; return prim; }
/* Programa principal */ void main (void) { int i; printf("Alg 11.06 v1 : no primos tal que centenas + decenas = unidades\n"); printf("--------------------------------------------------------------\n\n"); for (i = 100; i <= 999; i++) if (!Primo(i)) if (((i / 100) + ((i % 100) / 10)) == (i % 10)) }
printf("%d\n",i);
Ejercicio ALG.11.06 v2 en PASCAL (***********************************************************) (* Alg_11_06_v2 *) (* *) (* Algoritmo que imprime los números de tres cifras que no *) (* sean primos y cuya suma de centenas y decenas sea igual *) (* a las unidades. *) (***********************************************************) PROGRAM Alg_11_06_v2 (input,output); VAR i : INTEGER;
(* Primo : *) (* Función que devuelve TRUE o FALSE según sea el entero 'n' primo o no. *) FUNCTION Primo(n : INTEGER):BOOLEAN; VAR i : INTEGER; BEGIN Primo := TRUE; FOR i := 2 TO TRUNC(SQRT(n)) DO IF (n MOD i) = 0 THEN Primo := FALSE; END;
BEGIN WRITELN('Alg 11.06 v2 : no primos tal que centenas + decenas = unidades'); WRITELN('--------------------------------------------------------------'); WRITELN; FOR i := 100 TO 999 DO IF (i DIV 100) + ((i MOD 100) DIV 10) = (i MOD 10) THEN IF NOT Primo(i) THEN WRITELN(i); END.
Ejercicio ALG.11.06 v2 en C /***********************************************************/ /* Alg_11_06_v2 */ /* */ /* Algoritmo que imprime los números de tres cifras que no */ /* sean primos y cuya suma de centenas y decenas sea igual */ /* a las unidades. */ /***********************************************************/
#include <stdio.h> #include <math.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* Primo : */ /* Función que devuelve TRUE o FALSE según sea el entero 'n' primo o no. */ boolean Primo(int n) { int i; boolean prim; prim = TRUE; for (i = 2; i <= (int)(sqrt(n)); i++) if ((n % i) == 0) prim = FALSE; return prim; }
/* Programa principal */ void main (void) { int i; printf("Alg 11.06 v2 : no primos tal que centenas + decenas = unidades\n"); printf("--------------------------------------------------------------\n\n"); for (i = 100; i <= 999; i++) if (((i / 100) + ((i % 100) / 10)) == (i % 10)) if (!Primo(i)) printf("%d\n",i); }
Ejercicio ALG.11.06 v3 en PASCAL (***********************************************************) (* Alg_11_06_v3 *) (* *) (* Algoritmo que imprime los números de tres cifras que no *) (* sean primos y cuya suma de centenas y decenas sea igual *) (* a las unidades. *) (***********************************************************) PROGRAM Alg_11_06_v3 (input,output); VAR c, d, u, i : INTEGER;
(* Primo : *) (* Función que devuelve TRUE o FALSE según sea el entero 'n' primo o no. *) FUNCTION Primo(n : INTEGER):BOOLEAN; VAR i : INTEGER; BEGIN Primo := TRUE; FOR i := 2 TO TRUNC(SQRT(n)) DO IF (n MOD i) = 0 THEN Primo := FALSE; END;
BEGIN WRITELN('Alg 11.06 v3 : no primos tal que centenas + decenas = unidades'); WRITELN('--------------------------------------------------------------'); WRITELN; FOR c := 1 TO 9 DO FOR d := 0 TO 9-c DO BEGIN u := c + d; i := c*100 + d*10 + u; IF NOT Primo(i) THEN WRITELN(i); END; END.
Ejercicio ALG.11.06 v3 en C /***********************************************************/ /* Alg_11_06_v3 */ /* */ /* Algoritmo que imprime los números de tres cifras que no */ /* sean primos y cuya suma de centenas y decenas sea igual */ /* a las unidades. */ /***********************************************************/
#include <stdio.h> #include <math.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* Primo : */ /* Función que devuelve TRUE o FALSE según sea el entero 'n' primo o no. */ boolean Primo(int n) { int i; boolean prim; prim = TRUE; for (i = 2; i <= (int)(sqrt(n)); i++) if ((n % i) == 0) prim = FALSE; return prim; }
/* Programa principal */ void main (void) { int c, d, u, i; printf("Alg 11.06 v3 : no primos tal que centenas + decenas = unidades\n"); printf("--------------------------------------------------------------\n\n"); for (c = 1; c <= 9; c++) for (d = 0; d <= 9-c; d++) { u = c + d; i = c*100 + d*10 + u; if (!Primo(i)) printf("%d\n",i); }; }
Ejercicio ALG.11.07 en PASCAL (***********************************************************) (* Alg_11_07 *) (* *) (* Algoritmo que imprime los números de tres cifras que no *) (* sean primos y sí sean capicua. *) (***********************************************************) PROGRAM Alg_11_07 (input,output); VAR i, j, n : INTEGER;
(* Primo : *) (* Función que devuelve TRUE o FALSE según sea el entero 'n' primo o no. *) FUNCTION Primo(n : INTEGER):BOOLEAN; VAR i : INTEGER; BEGIN Primo := TRUE; FOR i := 2 TO TRUNC(SQRT(n)) DO IF (n MOD i) = 0 THEN Primo := FALSE; END;
BEGIN WRITELN('Alg 11.07 : primos y capicuas de tres cifras'); WRITELN('--------------------------------------------'); WRITELN; FOR i := 1 TO 9 DO FOR j := 0 TO 9 DO BEGIN n := i*100 + j*10 + i; IF Primo(n) THEN WRITELN(n); END; END.
Ejercicio ALG.11.07 en C /***********************************************************/ /* Alg_11_07 */ /* */ /* Algoritmo que imprime los números de tres cifras que no */ /* sean primos y sí sean capicua. */ /***********************************************************/
#include <stdio.h> #include <math.h>
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* Primo : */ /* Función que devuelve TRUE o FALSE según sea el entero 'n' primo o no. */ boolean Primo(int n) { int i; boolean prim; prim = TRUE; for (i = 2; i <= (int)(sqrt(n)); i++) if ((n % i) == 0) prim = FALSE; return prim; }
/* Programa principal */ void main (void) { int i, j, n; printf("Alg 11.07 : primos y capicuas de tres cifras\n"); printf("--------------------------------------------\n\n"); for (i = 1; i <= 9; i++) for (j = 0; j <= 9; j++) { n = i*100 + j*10 + i; if (Primo(n)) printf("%i\n", n); }; }
Ejercicio ALG.11.08 en PASCAL (***********************************************************) (* Alg_11_08 *) (* *) (* Algoritmo que resuelve un sistema de n ecuaciones *) (* con n incógnitas mediante el método de Kramer. *) (***********************************************************) PROGRAM Alg_11_08 (input,output); CONST n = 3; TYPE t_matriu = ARRAY[1..n , 1..n] OF REAL; t_matriu_ext = ARRAY[1..n , 1..n+1] OF REAL; VAR R : ARRAY [1..n] OF REAL; A : t_matriu_ext; Ai : t_matriu; det_A : REAL; i , j , k : INTEGER;
(* Vector de soluciones *) (* Matriz extendida *) (* Matriz Kramer *)
(* det : (* función que devuelve el determinante de una matriz (* recibida como parámetro. "Implementada sólo para n FUNCTION det(VAR M : t_matriu):REAL; BEGIN det := m[1,1]*m[2,2]*m[3,3] + m[1,2]*m[2,3]*m[3,1] - m[1,1]*m[2,3]*m[3,2] - m[1,2]*m[2,1]*m[3,3] END;
*) nxn *) = 3" *)
+ m[1,3]*m[2,1]*m[3,2] - m[1,3]*m[2,2]*m[3,1];
BEGIN WRITELN('Alg 11.08 : Sistema de n ecuaciones por Kramer'); WRITELN('----------------------------------------------'); WRITELN; (* Leemos los coeficientes de la matriz *) FOR j := 1 TO n DO FOR k := 1 TO n+1 DO BEGIN WRITE('Introduzca el elemento [' , j, ',', k, '] de la matriz : '); READLN(A[j,k]); END; det_A := det(A); (* Calculamos el determinante de todas las matrices n*n resultantes de (* sustituir cada una de las columnas de la matriz extendida n*(n+1) (* por la columna solución. Con k señalamos la columna, y guardamos (* la solución en la posición k de vector_sol. FOR i := 1 TO n DO BEGIN (* Copio en Ai la matriu que queda después de sustituir la *) (* columna i de la matriz A. Después calculo su determinante. *) FOR j := 1 TO n DO FOR k := 1 TO n DO IF k <> i THEN Ai[j,k] := A[j,k] ELSE Ai[j,k] := A[j,n]; R[i] := det(Ai); END; (* Imprimimos el resultado *) WRITELN; IF det_A = 0 THEN BEGIN WRITELN('El determinante es cero.');
*) *) *) *)
WRITELN('Sistema incompatible o con infinitas soluciones.'); END ELSE BEGIN FOR i := 1 TO n DO WRITELN('x', i, ' = ', R[i]/det_A); END; END.
Ejercicio ALG.11.08 en C /***********************************************************/ /* Alg_11_08 */ /* */ /* Algoritmo que resuelve un sistema de n ecuaciones */ /* con n incógnitas mediante el método de Kramer. */ /***********************************************************/
#include <stdio.h>
#define n 3
typedef float t_matriu[n][n]; typedef float t_matriu_ext[n][n+1];
/* det : */ /* función que devuelve el determinante de una matriz nxn */ /* recibida como parámetro. "Implementada sólo para n = 3" */ float det(t_matriu m) { return m[0][0]*m[1][1]*m[2][2] + m[0][1]*m[1][2]*m[2][0] + m[0][2]*m[1][0]*m[2][1] - m[0][0]*m[1][2]*m[2][1] - m[0][1]*m[1][0]*m[2][2] - m[0][2]*m[1][1]*m[2][0]; }
/* Programa principal */ void main (void) { float R[n]; t_matriu_ext A; t_matriu Ai; float det_A; int i, j, k;
/* Vector de soluciones */ /* Matriz extendida */ /* Matriz Kramer */
printf("Alg 11.08 : Sistema de n ecuaciones por Kramer\n"); printf("----------------------------------------------\n\n"); /* Leemos los coeficientes de la matriz */ for (j = 0; j < n; j++) for (k = 0; k < n+1; k++) { printf("Introduzca el elemento [%d,%d] de la matriz : ", j+1, k+1); scanf("%f", &A[j][k]); }; det_A = det(A); /* Calculamos el determinante de todas las matrices n*n resultantes de /* sustituir cada una de las columnas de la matriz extendida n*(n+1) /* por la columna solución. Con k señalamos la columna, y guardamos /* la solución en la posición k de vector_sol. for (i = 0; i < n; i++) { /* Copio en Ai la matriu que queda después de sustituir la */ /* columna i de la matriz A. Después calculo su determinante. */ for (j = 0; j < n; j++) for (k = 0; k < n; k++) if (k != i) Ai[j][k] = A[j][k]; else Ai[j][k] = A[j][n]; R[i] = det(Ai); }; /* Imprimimos el resultado */ printf("\n"); if (det_A == 0) {
*/ */ */ */
printf("El determinante es cero.\n"); printf("Sistema incompatible o con infinitas soluciones.\n"); } else { for (i = 0; i < n; i++) printf("x%d = %f\n", i, R[i]/det_A); }; }
Ejercicio ALG.11.09 en PASCAL (*******************************************************************) (* Alg_11_09 *) (* *) (* Algoritmo que dado un pedido de barras de longitud x, decida *) (* el tamaño estándar que debe utilizarse en el corte, de modo que *) (* minimice la pérdida de material. *) (* Existen barras de n tamaños estándar, de longitudes L1, ..., Ln *) (*******************************************************************) PROGRAM Alg_11_09 (input,output); CONST n = 4; VAR longitud : ARRAY [1..n] OF REAL; (* Longitudes de las barras *) existencias : ARRAY [1..n] OF INTEGER; (* Existencias de barras *) x : REAL; (* Tamaño deseado *) cantidad_pedida : INTEGER; (* Cantidad deseada *) resto : INTEGER; (* Cantidad que falta por calcular*) long_optima : REAL; (* Longitud que minimiza pérdidas *) perdida_minima : REAL; (* Porcentage de pérdidas mínimas *) perdida : REAL; (* Porcentage de pérdidas *) numero : INTEGER; (* Número de barras necesarias *) consumo : REAL; (* Longitud del material consumido*) trozos : INTEGER; (* Trozos por barra *) i, j, k : INTEGER; finalizar : CHAR; BEGIN WRITELN('Alg 11.09 : Barras. Minimización de costes.'); WRITELN('-------------------------------------------'); WRITELN; longitud[1] longitud[2] longitud[3] longitud[4]
:= := := :=
25; 30; 52; 68;
existencias[1] existencias[2] existencias[3] existencias[4]
:= := := :=
20; 20; 20; 20;
REPEAT (* Imprimimos existencias *) FOR j := 1 TO n DO WRITELN('Longitud: ', longitud[j]:6:2, ' ', 'Existencias : ' , existencias[j]:4); WRITELN; (* Leemos el tamaño y la cantidad pedidos *) WRITE('Introduzca el tamaño deseado : '); READLN(x); WRITE('Introduzca la cantidad deseada : '); READLN(cantidad_pedida); WRITELN; resto := cantidad_pedida; (* Elección del óptimo para resto *) perdida_minima := 100; FOR j := 1 TO n DO (* Mirar sólo los elementos de suficiente *) (* longitud de los que hay existencias *) IF (longitud[j] >= x) AND (existencias[j] > 0) THEN BEGIN k := TRUNC(longitud[j] / x); (* Sólo considera las aprovechables *) IF k > resto THEN k := resto; perdida := (longitud[j] - k*x)/longitud[j]*100; (* Memorizar *) IF perdida < perdida_minima THEN BEGIN
perdida_minima := perdida; i := j; long_optima := longitud[j]; END; END; IF perdida_minima = 100 THEN WRITELN('No hay ningún tamaño') ELSE BEGIN consumo := 0; REPEAT trozos := TRUNC(long_optima/x); numero := resto DIV trozos; IF numero = 0 THEN (* última barra *) numero := 1; IF numero > existencias[i] THEN numero := existencias[i]; WRITELN(numero, ' barras de longitud ', longitud[i]:4:2); existencias[i] := existencias[i] - numero; consumo := consumo + numero*longitud[i]; resto := resto - numero*trozos; IF resto > 0 THEN BEGIN (* Elección del óptimo para resto *) perdida_minima := 100; FOR j := 1 TO n DO (* Mirar sólo los elementos de suficiente *) (* longitud de los que hay existencias *) IF (longitud[j] >= x) AND (existencias[j] > 0) THEN BEGIN k := TRUNC(longitud[j] / x); (* Sólo considera las aprovechables *) IF k > resto THEN k := resto; perdida := (longitud[j] - k*x)/longitud[j]*100; (* Memorizar *) IF perdida < perdida_minima THEN BEGIN perdida_minima := perdida; i := j; long_optima := longitud[j]; END; END; END; IF perdida_minima = 100 THEN WRITELN('No puede completarse'); UNTIL (resto <= 0) OR (perdida_minima = 100); END; WRITELN; WRITE('Pulse ''S'' para finalizar, otra tecla para más pedidos : '); READLN(finalizar); WRITELN; UNTIL (finalizar = 's') OR (finalizar = 'S'); END.
Ejercicio ALG.11.09 en C /*******************************************************************/ /* Alg_11_09 */ /* */ /* Algoritmo que dado un pedido de barras de longitud x, decida */ /* el tamaño estándar que debe utilizarse en el corte, de modo que */ /* minimice la pérdida de material. */ /* Existen barras de n tamaños estándar, de longitudes L1, ..., Ln */ /*******************************************************************/
#include <stdio.h>
#define n 4
/* Programa principal */ void main (void) { float int float int int float float float int float int int char
longitud[n]; existencias[n]; x; cantidad_pedida; resto; long_optima; perdida_minima; perdida; numero; consumo; trozos; i, j, k; finalizar;
/* /* /* /* /* /* /* /* /* /* /*
Longitudes de las barras Existencias de barras Tamaño deseado Cantidad deseada Cantidad que falta por calcular Longitud que minimiza pérdidas Porcentage de pérdidas mínimas Porcentage de pérdidas Número de barras necesarias Longitud del material consumido Trozos por barra
printf("Alg 11.09 : Barras. Minimización de costes\n"); printf("------------------------------------------\n\n"); longitud[0] longitud[1] longitud[2] longitud[3]
= = = =
25; 30; 52; 68;
existencias[0] existencias[1] existencias[2] existencias[3]
= = = =
20; 20; 20; 20;
do { /* Imprimimos existencias */ for (j = 0; j < n; j++) printf("Longitud: %6.2f Existencias : %4i\n", longitud[j], existencias[j]); printf("\n"); /* Leemos el tamaño y la cantidad pedidos */ printf("Introduzca el tamaño deseado : "); scanf("%f", &x); printf("Introduzca la cantidad deseada : "); scanf("%d", &cantidad_pedida); printf("\n"); resto = cantidad_pedida; /* Elección del óptimo para resto */ perdida_minima = 100; for (j = 0; j < n; j++) /* Mirar sólo los elementos de suficiente */ /* longitud de los que hay existencias */ if ((longitud[j] >= x) && (existencias[j] > 0)) { k = (int) (longitud[j] / x); /* Sólo considera las aprovechables */ if (k > resto) k = resto; perdida = (longitud[j] - k*x)/longitud[j]*100; /* Memorizar */
*/ */ */ */ */ */ */ */ */ */ */
if (perdida < perdida_minima) { perdida_minima = perdida; i = j; long_optima = longitud[j]; }; }; if (perdida_minima == 100) printf("No hay ningún tamaño\n"); else { consumo = 0; do { trozos = (int) (long_optima/x); numero = resto / trozos; if (numero == 0) /* última barra */ numero = 1; if (numero > existencias[i]) numero = existencias[i]; printf("%d barras de longitud %4.2f\n", numero, longitud[i]); existencias[i] -= numero; consumo += numero*longitud[i]; resto -= numero*trozos; if (resto > 0) { /* Elección del óptimo para resto */ perdida_minima = 100; for (j = 0; j < n; j++) /* Mirar sólo los elementos de suficiente */ /* longitud de los que hay existencias */ if ((longitud[j] >= x) && (existencias[j] > 0)) { k = (int) (longitud[j] / x); /* Sólo considera las aprovechables */ if (k > resto) k = resto; perdida = (longitud[j] - k*x)/longitud[j]*100; /* Memorizar */ if (perdida < perdida_minima) { perdida_minima = perdida; i = j; long_optima = longitud[j]; }; }; }; if (perdida_minima == 100) printf("No puede completarse\n"); } while ((resto > 0) && (perdida_minima != 100)); }; printf("\nPulse 'S' para finalizar, otra tecla para más pedidos : "); scanf("\n%c", &finalizar); printf("\n"); } while ((finalizar != 's') && (finalizar != 'S')); }
Ejercicio ALG.11.10 en PASCAL (*******************************************************************) (* Alg_11_10 *) (* *) (* Algoritmo que imprime las variaciones con repetición de n *) (* elementos tomados de k en k. *) (*******************************************************************) PROGRAM Alg_11_10 (input,output); CONST MAX = 10; VAR componente : ARRAY [1..max] OF CHAR; combinacion : ARRAY [1..max] OF CHAR; ultima : ARRAY [1..max] OF CHAR; i, k, n : INTEGER; aux, puntero : INTEGER; elemento : CHAR; repetido : BOOLEAN;
(* Conjunto de elementos *) (* Combinación de elementos *) (* éltima combinación *)
(* siguiente : *) (* Función que dado un elemento pasado como parámetro, retorna el siguiente *) FUNCTION siguiente(c:CHAR):CHAR; VAR i : INTEGER; BEGIN i := 1; WHILE (i <= n) AND (componente[i] <> c) DO i := i + 1; IF i < n THEN siguiente := componente[i+1] ELSE IF i = n THEN siguiente := componente[1] ELSE siguiente := CHR(0); END;
BEGIN WRITELN('Alg 11.10 : Variaciones con repetición.'); WRITELN('---------------------------------------'); WRITELN; (* Inicializamos los elementos *) n := 0; REPEAT WRITE('Introduzca un elemento (<@> para acabar) : '); READLN(elemento); IF elemento <> '@' THEN BEGIN (* Comprobamos que no exista y lo *) (* añadimos al conjunto de elementos *) repetido := FALSE; FOR i := 1 TO n DO IF elemento = componente[i] THEN repetido := TRUE; IF repetido THEN WRITELN('Este elemento ya existe') ELSE BEGIN n := n + 1; componente[n] := elemento; END END; UNTIL (elemento = '@') OR (n = MAX); (* Pedimos el número de elementos de las combinaciones *) REPEAT
WRITE('Introduzca el número de elementos de una combinación : '); READLN(k); UNTIL (k >= 1) AND (k <= n); (* Generamos la primera combinación y la última *) FOR i := 1 TO k DO BEGIN combinacion[i] := componente[1]; ultima[i] := componente[n]; END; (* Imprimimos la combinación *) WRITELN('Combinación : ', combinacion); WHILE combinacion <> ultima DO BEGIN IF combinacion[k] = componente[n] THEN BEGIN (* Tratamiento del último componente *) puntero := k - 1; WHILE combinacion[puntero] = componente[n] DO puntero := puntero - 1; combinacion[puntero] := siguiente(combinacion[puntero]); (* Elementos de su derecha igual a primer componente *) FOR aux := puntero + 1 TO k DO combinacion[aux] := componente[1]; END ELSE combinacion[k] := siguiente(combinacion[k]); WRITELN('Combinación : ', combinacion); END; END.
Ejercicio ALG.11.10 en C /*******************************************************************/ /* Alg_11_10 */ /* */ /* Algoritmo que imprime las variaciones con repetición de n */ /* elementos tomados de k en k. */ /*******************************************************************/
#include <stdio.h>
#define MAX 10
/* Creamos el nuevo tipo 'boolean'. En C no existe */ typedef enum {FALSE, TRUE} boolean;
/* siguiente : */ /* Función que dado un elemento pasado como parámetro, retorna el siguiente */ char siguiente(char c, int n, char *componente) { int i; for (i = 0; (i < n) && (componente[i] != c); i++); if (i < n) return componente[i+1]; else if (i == n) return componente[1]; else return '\0'; }
/* Programa principal */ void main (void) { char componente[MAX]; char combinacion[MAX+1]; char ultima[MAX+1]; int i, k, n; int aux, puntero; char elemento; boolean repetido;
/* Conjunto de elementos */ /* Combinación de elementos */ /* éltima combinación */
printf("Alg 11.10 : Variaciones con repetición\n"); printf("--------------------------------------\n\n"); /* Inicializamos los elementos */ n = 0; do { printf("Introduzca un elemento (<@> para acabar) : "); scanf("\n%c", &elemento); if (elemento != '@') { /* Comprobamos que no exista y lo */ /* añadimos al conjunto de elementos */ repetido = FALSE; for (i = 0; i < n; i++) if (elemento == componente[i]) repetido = TRUE; if (repetido) printf("Este elemento ya existe\n"); else componente[n++] = elemento; }; } while ((elemento != '@') && (n != MAX)); /* Pedimos el número de elementos de las combinaciones */
do { printf("Introduzca el número de elementos de una combinación : "); scanf("%d", &k); } while ((k < 1) || (k > n)); /* Generamos la primera combinación y la última */ for (i = 0; i < k; i++) { combinacion[i] = componente[0]; ultima[i] = componente[n-1]; }; combinacion[k] = '\0'; ultima[k] = '\0'; /* Imprimimos la combinación */ printf("Combinación : %s\n", combinacion); while (strcmp(combinacion,ultima) != 0) { if (combinacion[k-1] == componente[n-1]) { /* Tratamiento del último componente */ for (puntero = k-2; combinacion[puntero] == componente[n-1]; puntero--); combinacion[puntero] = siguiente(combinacion[puntero], n-1, componente); /* Elementos de su derecha igual a primer componente */ for (aux = puntero + 1; aux < k; aux++) combinacion[aux] = componente[0]; } else combinacion[k-1] = siguiente(combinacion[k-1], n-1, componente); printf("Combinación : %s\n", combinacion); }; }
Ejercicio ALG.11.11 en PASCAL (*******************************************************************) (* Alg_11_11 *) (* *) (* Algoritmo que actua como cajero que desglosa cambio. *) (*******************************************************************) PROGRAM Alg_11_11 (input,output); CONST n = 7; VAR monedas : ARRAY [1..n] OF caja : ARRAY [1..n] OF importe_factura : INTEGER; pago : ARRAY [1..n] OF importe_pago : INTEGER; cambio : ARRAY [1..n] OF importe_cambio : INTEGER; resto : INTEGER; cantidad : INTEGER; i : INTEGER; conforme : CHAR;
INTEGER; INTEGER;
(* (* (* (* (* (* (* (* (*
INTEGER; INTEGER;
Importe de las monedas Existencia de monedas Importe de la factura Importe pagado desglose Importe pagado total Importe a devolver desglose Importe a devolver total Importe a calcular/devolver Cantidad de monedas devolver
BEGIN WRITELN('Alg 11.11 : Cajero. Desglosar cambio.'); WRITELN('-------------------------------------'); WRITELN; monedas[1] monedas[2] monedas[3] monedas[4] monedas[5] monedas[6] monedas[7]
:= 5000; := 1000; := 500; := 100; := 25; := 5; := 1;
caja[1] caja[2] caja[3] caja[4] caja[5] caja[6] caja[7]
:= := := := := := :=
2; 5; 4; 5; 4; 5; 5;
cambio[1] cambio[2] cambio[3] cambio[4] cambio[5] cambio[6] cambio[7]
:= := := := := := :=
0; 0; 0; 0; 0; 0; 0;
(* Imprimimos caja *) FOR i := 1 TO n DO WRITELN('Disponemos de ', caja[i], ' monedas de ', monedas[i]); WRITELN; (* Leemos el importe de la factura y el desglose del pago *) WRITE('Introduzca el importe de la factura : '); READLN(importe_factura); WRITELN('Introduzca el importe de pago desglosado : '); importe_pago := 0; FOR i := 1 TO n DO BEGIN WRITE('¿ Cuántas monedas de ', monedas[i], ' ? '); READLN(pago[i]); importe_pago := importe_pago + pago[i]*monedas[i]; END; WRITELN; importe_cambio := importe_pago - importe_factura; WRITELN('Total a devolver : ', importe_cambio); IF importe_cambio = 0 THEN BEGIN WRITELN('Importe exacto'); (* Incorporamos el desglose del pago a la caja *) FOR i := 1 TO n DO caja[i] := caja[i] + pago[i]; END ELSE BEGIN resto := importe_cambio; i := 1; WHILE (resto <> 0) AND (i <= n) DO
*) *) *) *) *) *) *) *) *)
BEGIN IF (monedas[i] <= resto) AND (caja[i] <> 0) THEN BEGIN cantidad := resto DIV monedas[i]; IF cantidad > caja[i] THEN cantidad := caja[i]; resto := resto - cantidad*monedas[i]; (* Incorporamos la cantidad al desglose de cambio *) cambio[i] := cantidad; END; i := i + 1; END; IF resto = 0 THEN BEGIN (* Imprimimos cambio *) WRITELN('Cambio:'); FOR i := 1 TO n DO WRITELN(Cambio[i], ' monedas de ', monedas[i]); WRITELN; WRITE('Pulse ''S'' si est谩 conforme, otra tecla si no : '); READLN(conforme); WRITELN; IF (conforme = 's') OR (conforme = 'S') THEN (* Rebajamos el desglose del cambio de la caja, *) (* incorporamos el desglose del pago a la caja *) (* e imprimimos caja. *) FOR i := 1 TO n DO BEGIN caja[i] := caja[i] - cambio[i]; caja[i] := caja[i] + pago[i]; WRITELN('Disponemos de ', caja[i], ' monedas de ', monedas[i]); END ELSE WRITELN('Operaci贸n anulada'); END ELSE WRITELN('Cambio insuficiente'); END; END.
Ejercicio ALG.11.11 en C /*******************************************************************/ /* Alg_11_11 */ /* */ /* Algoritmo que actua como cajero que desglosa cambio. */ /*******************************************************************/
#include <stdio.h>
#define n 7
/* Programa principal */ void main (void) { int monedas[n]; int caja[n]; int importe_factura; int pago[n]; int importe_pago; int cambio[n]; int importe_cambio; int resto; int cantidad; int i; char conforme;
/* /* /* /* /* /* /* /* /*
Importe de las monedas Existencia de monedas Importe de la factura Importe pagado desglose Importe pagado total Importe a devolver desglose Importe a devolver total Importe a calcular/devolver Cantidad de monedas devolver
*/ */ */ */ */ */ */ */ */
printf("Alg 11.11 : Cajero. Desglosar cambio.\n"); printf("-------------------------------------\n\n"); monedas[0] monedas[1] monedas[2] monedas[3] monedas[4] monedas[5] monedas[6]
= 5000; = 1000; = 500; = 100; = 25; = 5; = 1;
caja[0] caja[1] caja[2] caja[3] caja[4] caja[5] caja[6]
= = = = = = =
2; 5; 4; 5; 4; 5; 5;
cambio[0] cambio[1] cambio[2] cambio[3] cambio[4] cambio[5] cambio[6]
= = = = = = =
0; 0; 0; 0; 0; 0; 0;
/* Imprimimos caja */ for (i = 0; i < n; i++) printf("Disponemos de %d monedas de %d\n", caja[i], monedas[i]); printf("\n"); /* Leemos el importe de la factura y el desglose del pago */ printf("Introduzca el importe de la factura : "); scanf("%d", &importe_factura); printf("Introduzca el importe de pago desglosado : \n"); importe_pago = 0; for (i = 0; i < n; i++) { printf("Âż CuĂĄntas monedas de %d ? ", monedas[i]); scanf("%d", &pago[i]); importe_pago += pago[i]*monedas[i]; }; printf("\n"); importe_cambio = importe_pago - importe_factura; printf("Total a devolver : %d\n", importe_cambio); if (importe_cambio == 0) { printf("Importe exacto\n"); /* Incorporamos el desglose del pago a la caja */ for (i = 0; i < n; i++) caja[i] += pago[i]; } else { resto = importe_cambio; for (i = 0; (i < n) && (resto != 0); i++) if ((monedas[i] <= resto) && (caja[i] != 0)) {
cantidad = resto / monedas[i]; if (cantidad > caja[i]) cantidad = caja[i]; resto -= cantidad*monedas[i]; /* Incorporamos la cantidad al desglose de cambio */ cambio[i] = cantidad; }; if (resto == 0) { /* Imprimimos cambio */ printf("Cambio:\n"); for (i = 0; i < n; i++) printf("%d monedas de %d\n", cambio[i], monedas[i]); printf("\nPulse 'S' si est谩 conforme, otra tecla si no : "); scanf("\n%c", &conforme); printf("\n"); if ((conforme == 's') || (conforme == 'S')) /* Rebajamos el desglose del cambio de la caja, */ /* incorporamos el desglose del pago a la caja */ /* e imprimimos caja. */ for (i = 0; i < n; i++) { caja[i] -= cambio[i]; caja[i] += pago[i]; printf("Disponemos de %d monedas de %d\n", caja[i], monedas[i]); } else printf("Operaci贸n anulada\n"); } else printf("Cambio insuficiente\n"); }; }
Ejercicio ALG.11.12 en PASCAL (*******************************************************************) (* Alg_11_12 *) (* *) (* Algoritmo que dadas las posiciones de dos damas y un peón en un *) (* tablero de ajedrez (conocidas por sus coordenadas a partir del *) (* ángulo inferior izquierdo del jugador), determina si las damas *) (* están en posición de matarse. *) (*******************************************************************) PROGRAM Alg_11_12 (input,output); VAR dbx, dby : INTEGER; dnx, dny : INTEGER; px, py : INTEGER; menor, mayor : INTEGER;
(* Coordenadas de la dama blanca *) (* Coordenadas de la dama negra *) (* Coordenadas del peón *)
(* misma_linea : *) (* Procedimiento que pasados como parámetros las coordenadas de dos *) (* damas y un peón escribe por pantalla si se matan o no. *) PROCEDURE misma_linea(coor_difb, coor_difn, coor_igual, peon_dif, peon_igual : INTEGER); VAR menor, mayor : INTEGER; BEGIN IF peon_igual <> coor_igual THEN WRITELN('Se matan') ELSE BEGIN IF coor_difb < coor_difn THEN BEGIN mayor := coor_difn; menor := coor_difb; END ELSE BEGIN mayor := coor_difb; menor := coor_difn; END; IF (menor < peon_dif) AND (peon_dif < mayor) THEN WRITELN('No se matan') ELSE WRITELN('Se matan'); END; END;
BEGIN WRITELN('Alg 11.12 : Dos damas y un peón'); WRITELN('-------------------------------'); WRITELN; (* Leemos las coordenadas de las damas y el peón *) REPEAT WRITE('Introduzca la coordenada X de la dama blanca : '); READLN(dbx); UNTIL (dbx >= 1) AND (dbx <= 8); REPEAT WRITE('Introduzca la coordenada Y de la dama blanca : '); READLN(dby); UNTIL (dby >= 1) AND (dby <= 8); REPEAT WRITE('Introduzca la coordenada X de la dama negra : '); READLN(dnx); UNTIL (dnx >= 1) AND (dnx <= 8); REPEAT WRITE('Introduzca la coordenada Y de la dama negra : ');
READLN(dny); UNTIL (dny >= 1) AND (dny <= 8); REPEAT WRITE('Introduzca la coordenada X del pe贸n : '); READLN(px); UNTIL (px >= 1) AND (px <= 8); REPEAT WRITE('Introduzca la coordenada Y del pe贸n : '); READLN(py); UNTIL (py >= 1) AND (py <= 8); IF dby = dny THEN misma_linea(dbx, dnx, dby, px, py) ELSE IF dbx = dnx THEN misma_linea(dby, dny, dbx, py, px) ELSE IF ABS(dbx-dnx) = ABS(dby-dny) THEN IF ((dby-dny)/(dbx-dnx)) = ((py-dny)/(px-dnx)) THEN BEGIN IF dbx < dnx THEN BEGIN mayor := dnx; menor := dbx; END ELSE BEGIN mayor := dbx; menor := dnx; END; IF (menor < px) AND (px < mayor) THEN WRITELN('No se matan') ELSE WRITELN('Se matan'); END ELSE WRITELN('Se matan') ELSE WRITELN('No se matan'); END.
Ejercicio ALG.11.12 en C /*******************************************************************/ /* Alg_11_12 */ /* */ /* Algoritmo que dadas las posiciones de dos damas y un peón en un */ /* tablero de ajedrez (conocidas por sus coordenadas a partir del */ /* ángulo inferior izquierdo del jugador), determina si las damas */ /* están en posición de matarse. */ /*******************************************************************/
#include <stdio.h> #include <math.h>
/* misma_linea : */ /* Procedimiento que pasados como parámetros las coordenadas de dos */ /* damas y un peón escribe por pantalla si se matan o no. */ void misma_linea(int coor_difb, int coor_difn, int coor_igual, int peon_dif, int peon_igual) { int menor, mayor; if (peon_igual != coor_igual) printf("Se matan\n"); else { if (coor_difb < coor_difn) { mayor = coor_difn; menor = coor_difb; } else { mayor = coor_difb; menor = coor_difn; }; if ((menor < peon_dif) && (peon_dif < mayor)) printf("No se matan\n"); else printf("Se matan\n"); }; }
/* Programa principal */ void main (void) { int int int int
dbx, dby; dnx, dny; px, py; menor, mayor;
/* Coordenadas de la dama blanca */ /* Coordenadas de la dama negra */ /* Coordenadas del peón */
printf("Alg 11.12 : Dos damas y un peón\n"); printf("-------------------------------\n\n"); /* Leemos las coordenadas de las damas y el peón */ do { printf("Introduzca la coordenada X de la dama blanca : "); scanf("%d", &dbx); } while ((dbx < 1) || (dbx > 8)); do { printf("Introduzca la coordenada Y de la dama blanca : "); scanf("%d", &dby); } while ((dby < 1) || (dby > 8)); do { printf("Introduzca la coordenada X de la dama negra : "); scanf("%d", &dnx); } while ((dnx < 1) || (dnx > 8)); do {
printf("Introduzca la coordenada Y de la dama negra : "); scanf("%d", &dny); } while ((dny < 1) || (dny > 8)); do { printf("Introduzca la coordenada X del pe贸n : "); scanf("%d", &px); } while ((px < 1) || (px > 8)); do { printf("Introduzca la coordenada Y del pe贸n : "); scanf("%d", &py); } while ((py < 1) || (py > 8)); if (dby == dny) misma_linea(dbx, dnx, dby, px, py); else if (dbx == dnx) misma_linea(dby, dny, dbx, py, px); else if (abs(dbx-dnx) == abs(dby-dny)) if (((dby-dny)/(dbx-dnx)) == ((py-dny)/(px-dnx))) { if (dbx < dnx) { mayor = dnx; menor = dbx; } else { mayor = dbx; menor = dnx; }; if ((menor < px) && (px < mayor)) printf("No se matan\n"); else printf("Se matan\n"); } else printf("Se matan\n"); else printf("No se matan\n"); }