Vous êtes sur la page 1sur 15

INTRODUCCIÓN A LA PROGRAMACIÓN 1

PRÁCTICA 2: ESTRUCTURAS DE CONTROL

E.2.1 Como se deduce del mensaje, se trata de comprobar que los dos números enteros leídos son iguales. Por tanto, el
símbolo = de asignación deberá ser cambiado por ==.

E.2.2 Este experimento se compila y ejecuta sin errores. Sin embargo, si leemos distintos pares de números podemos
comprobar que no funciona correctamente. Por ejemplo, si leemos 7 y 10 el programa responde que k, cuyo valor es 5, está
entre los números leídos. Esto, evidentemente, es falso. El problema está en que la construcción i<k<j no es una expresión
lógica correcta para expresar que un número k está entre otros dos (i y j). La respuesta correcta debe ser i<k && k<j.

E.2.3 Si se ejecuta este programa y, por ejemplo, se lee el valor 1 se puede comprobar cómo se ejecutan todas las
sentencias; si se lee -1 se ejecutan las sentencias desde el caso -1 en adelante, etc. La solución si no queremos que esto
suceda es poner una sentencia break al final de cada case.

E.2.4 Este programa no compila porque la sentencia switch sólo puede ser utilizada para chequear un conjunto de valores
constantes y fijados de antemano, no expresiones lógicas. Es imposible poner un case para todos los números positivos, por
tanto este programa no se puede resolver con un switch, sino que es obligatorio usar sentencias if-else enlazadas:

if (i>0)
printf ("i es positivo\n");
else if (i<0)
printf ("i es negativo\n");
else
printf ("i es cero\n");

E.2.5 Falta inicializar las variables i, suma, es decir, escribir:

int i=1, suma=0;

Además hay que poner obligatoriamente llaves para marcar el ámbito de la sentencia while:

while (i<10)
{
suma=suma+i;
i++;
}

E.2.6 Falta inicializar la variable suma (no es necesario hacerlo con la variable i porque ya se hace en el bucle for), es decir,
escribir:

int i, suma=0;

La condición de finalización debe ser i<=10, para que sume los 10 primeros números enteros:

for(i=0;i<=10;i++)
suma=suma+i;

E.2.7 En primer lugar, hay que encerrar entre llaves las instrucciones que deben estar en el ámbito del while. Es decir:

while (i!=10) while (i<10)


{ {
suma=suma+i; suma=suma+i;
i++; i++;
} }

En principio, los dos programas hacen lo mismo porque la condición de finalización es equivalente si i va sumando de uno
en uno. Sin embargo, al sustituir i++ por i=i+2, i toma los valores 1, 3, 5, 7, 9, 11, 13,... Esto significa que la condición
i<10 sigue siendo una condición válida, pero i!=10 ya no es una condición válida pues i no tomará nunca el valor 10 y, por
tanto, el experimento dará lugar a un programa que no acaba. La conclusión debe ser que antes de poner una condición en
un bucle debe tenerse en cuenta si ésta será falsa en algún momento
S.2.8
#include <stdio.h>
void main (void)
{
int i, m;

i = 1;
m = i*3;
while (m < 20)
{
printf ("%d ", m);
i++;
m = i*3;
}
}

S.2.9
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAXIMO 100
typedef enum {Falso, Cierto} Logico;
void main (void)
{
int n, numero, contador=0;
Logico acierto;
srand((unsigned)time( NULL ));

numero = rand();
while(numero<1 || numero>100)
numero = rand();
acierto = Falso;
while (!acierto)
{
printf ("\n Introduzca un número: ");
scanf ("%d", &n);
contador++;
if (n == numero)
{
printf ("\n Acierto en %d intentos", contador);
acierto = Cierto;
}
else if (n < numero)
printf ("\n El número es mayor");
else
printf ("\n El número es menor");
}
}

S.2.10
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAXIMO 100
#define MAXINTENTOS 10
typedef enum {Falso, Cierto} Logico;
void main (void)
{
int n, numero, contador=0;
Logico acierto;

srand((unsigned)time( NULL ));

numero = rand();
while(numero<1 || numero>100)
numero = rand();

acierto = Falso;
while (!acierto && contador<MAXINTENTOS)
{
printf ("\n Introduzca un número: ");
scanf ("%d", &n);
contador++;
if (n == numero)
{
printf ("\n Acierto en %d intentos", contador);
acierto = Cierto;
}
else if (n < numero)
printf ("\n El número es mayor");
else
printf ("\n El número es menor");
}
if (!acierto)
printf ("\nLo siento, ha perdido");
}

S.2.11
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAXIMO 100
#define MAXINTENTOS 10
typedef enum {Falso, Cierto} Logico;
void main (void)
{
int n, numero, contador, respuesta;
LOGICO acierto, repetir=Cierto;

while (repetir)
{
contador = 0;
srand((unsigned)time( NULL ));

numero = rand();
while(numero<1 || numero>100)
numero = rand();

acierto = Falso;
while (!acierto && contador<MAXINTENTOS)
{
printf ("\n Introduzca un número: ");
scanf ("%d", &n);
contador++;
if (n == numero)
{
printf ("\n Acierto en %d intentos", contador);
acierto = Cierto;
}
else if (n < numero)
printf ("\n El número es mayor");
else
printf ("\n El número es menor");
}
if (!acierto)
printf ("\nLo siento, ha perdido");
printf ("\nPara terminar teclee 0, otro número para volver a jugar: ");
scanf ("%d", &respuesta);
if (respuesta != 0)
repetir = Falso;
}
}

A.2.1
#include <stdio.h>
void main (void)
{
float dato, inverso;

printf ("Escriba un valor numérico: ");


scanf ("%f", &dato);
if (dato != 0)
{
inverso = 1/dato;
printf ("El inverso de %f es %f\n", dato, inverso);
}
else
printf ("ERROR - división por cero\n");
}

A.2.3
#include <stdio.h>
typedef enum {Falso, Cierto} Logico;
void main (void)
{
int anyo;
Logico bisiesto;

printf ("\nIntroduzca el año: ");


scanf ("%d", &anyo);

bisiesto = anyo%4==0 && anyo%100!=0 || anyo%400==0;


if (bisiesto)
printf ("\nEl año es bisiesto");
else
printf ("\nEl año no es bisiesto");
}

A.2.7
/* solución a) */
#include <stdio.h>
void main (void)
{
double x, y;
int cuadrante;

printf ("\nIntroduzca las coordenadas del punto.\nCoordenada x? ");


scanf ("%lf", &x);
printf ("Coordenada y? ");
scanf ("%lf", &y);
if (x>0 && y>0)
cuadrante = 1;
if (x>0 && y<0)
cuadrante = 4;
if (x<0 && y>0)
cuadrante = 2;
if (x<0 && y<0)
cuadrante = 3;

printf ("\nEl cuadrante del punto (%lf, %lf) es el %d", x, y, cuadrante);


}

/* solución b) */
#include <stdio.h>
void main (void)
{
double x, y;
int cuadrante;

printf ("\nIntroduzca las coordenadas del punto.\nCoordenada x? ");


scanf ("%lf", &x);
printf ("Coordenada y? ");
scanf ("%lf", &y);

if (x>0)
if (y>0)
cuadrante = 1;
else
cuadrante = 4;
else
if (y>0)
cuadrante = 2;
else
cuadrante = 3;

printf ("\nEl cuadrante del punto (%lf, %lf) es el %d", x, y, cuadrante);


}

A.2.11
#include <stdio.h>
#define PI 3.14159
void main (void)
{
int opcion;
double lado, radio, base, altura, base1, base2, area;

printf ("\n==========================================");
printf ("\nCÁLCULO DE SUPERFICIES (versión 1.0)");
printf ("\n==========================================");
printf ("\n1. Cuadrado lado*lado");
printf ("\n2. Círculo pi*radio*radio");
printf ("\n3. Rectángulo base*altura");
printf ("\n4. Trapecio (base1+base2)*altura/2");
printf ("\n5. Triángulo (base*altura)/2");
printf ("\n==========================================");

printf ("\n\nSeleccione opción: ");


scanf ("%d", &opcion);

switch (opcion)
{
case 1:
printf ("\nSuperficie seleccionada: CUADRADO");
printf ("\nIntroduzca el valor del lado: ");
scanf ("%lf", &lado);
area = lado*lado;
printf ("El área es %.2lf\n", area);
break;
case 2:
printf ("\nSuperficie seleccionada: CÍRCULO");
printf ("\nIntroduzca el valor del radio: ");
scanf ("%lf", &radio);
area = PI*radio*radio;
printf ("El área es %.2lf\n", area);
break;
case 3:
printf ("\nSuperficie seleccionada: RECTÁNGULO");
printf ("\nIntroduzca los valores de la base y la altura: ");
scanf ("%lf%lf", &base, &altura);
area = base*altura;
printf ("El área es %.2lf\n", area);
break;
case 4:
printf ("\nSuperficie seleccionada: TRAPECIO");
printf ("\nIntroduzca el valor de la altura y las dos bases: ");
scanf ("%lf%lf%lf", &altura, &base1, &base2);
area = (base1+base2)*altura/2;
printf ("El área es %.2lf\n", area);
break;
case 5:
printf ("\nSuperficie seleccionada: TRIÁNGULO");
printf ("\nIntroduzca el valor de la base y la altura: ");
scanf ("%lf%lf", &base, &altura);
area = (base*altura)/2;
printf ("El área es %.2lf\n", area);
}
}

A.2.14
#include <stdio.h>
void main (void)
{
int a, b, c;

printf ("Escriba tres números enteros separados por blancos o retorno: ");
scanf ("%d%d%d", &a, &b, &c);
if (a > b)
if (a > c)
if (b > c)
printf ("%d %d %d\n", a, b, c);
else
printf ("%d %d %d\n", a, c, b);
else
printf ("%d %d %d\n", c, a, b);
else
if (a > c)
printf ("%d %d %d\n", b, a, c);
else
if (b > c)
printf ("%d %d %d\n", b, c, a);
else
printf ("%d %d %d\n", c, b, a);
}

A.2.22
#include <stdio.h>
#define OPMIN 1
#define OPMAX 5
void main (void)
{
int n, contador;
contador = 1;
printf ("\nIntroduzca un valor: ");
scanf ("%d", &n);
while (n<OPMIN || n>OPMAX)
{
contador++;
printf ("El valor es incorrecto. Introduzca de nuevo: ");
scanf ("%d", &n);
}
printf ("El valor %d ha sido leido en el intento no. %d", n, contador);
}
INTRODUCCIÓN A LA PROGRAMACIÓN 1
PRÁCTICA 3: FUNCIONES Y PROCEDIMIENTOS

E.3.1 Falta la instrucción de retorno en la función max_doble, sin la cual ésta no devuelve ningún valor. La función
completa queda de la siguiente manera:

float max_doble(float a, float b)


{
float max;

if (a>b)
max=a;
else
max=b;
max=max*2;
return (max);
}

E.3.2 El aviso se debe a la ausencia del prototipo de la función cuadrado. La explicación es la siguiente: cuando el
compilador analiza el código fuente de un programa lo hace secuencialmente, comenzando por el principio del fichero y
avanzando hacia adelante. Cuando encuentra una llamada a una función de la cual no tiene información previa (por no
disponer de prototipo), el compilador siempre asume por defecto que la función es de tipo int. Cuando más tarde se
encuentra con la definición de la función, si ésta no es de tipo int surge un conflicto con el tipo asumido anteriormente. El
compilador avisa del conflicto de 'redeclaración' de la función, que a sus efectos ha sido declarada de dos formas distintas.

En el experimento el compilador asume que la función cuadrado es de tipo int y más tarde se encuentra que está definida
como tipo float, por lo cual surge el conflicto.

La solución consiste en colocar el prototipo de la función al comienzo del código. De esta forma, el compilador ya dispone
desde un principio de toda la información que necesita para comprobar la corrección de las llamadas a la función. El
programa queda pues de la siguiente manera:

#include <stdio.h>
float cuadrado (float);
void main(void)
{
float x;

printf("\nDeme un número: ");


scanf("%f",&x);
printf("El cuadrado de %f es %f\n",x,cuadrado(x));
}
float cuadrado(float y)
{
return(y*y);
}

E.3.3 La función no realiza su cometido porque los parámetros que recibe son de entrada y no de entrada/salida. Por esta
razón, las modificaciones que se hacen sobre ellos no afectan a los parámetros formales de la llamada. La forma correcta de
escribir la función es la siguiente:

void intercambia (Pint x, Pint y)


{
int temp;

temp = *x;
*x = *y;
*y = temp;
}

E.3.4 El programa completo es el siguiente:

#include <stdio.h>
typedef int * Pint;
typedef char * Pchar;
void inicializa (Pint, Pchar);
void main (void)
{
int codigo;
char tipo;

inicializa (&codigo, &tipo);


printf ("\nEl código es %d y el tipo es %c", codigo, tipo);
}
void inicializa (Pint c, Pchar t)
{
*c = 12;
*t = 'B';
}

E.3.5 Los errores se deben a que se han omitido los '*' delante de los parámetros de salida del procedimiento areaLong
(area y longi). Por ello en lugar de acceder al contenido de las variables estamos manipulando directamente los
punteros, de ahí los errores del compilador. La forma correcta de la función es la siguiente:

#include <stdio.h>
#define PI 3.1416
typedef double * Pdouble;
void areaLong(double, Pdouble, Pdouble);
void main(void)
{
double r,a,l;
printf("\nIntroduzca el rádio de la circunferencia: ");
scanf("%lf",&r);
areaLong(r,&a,&l);
printf("El área es %lf, y la longitud es %lf.\n",a,l);
}
void areaLong(double radio, Pdouble area, Pdouble longi)
{
*area = PI*radio*radio;
*longi = 2*PI*radio;
}

S.3.3
#include <stdio.h>
long factorial (int);
void main (void)
{
int n;
long f;

printf ("\nIntroduzca un número entero positivo: ");


scanf ("%d", &n);
f = factorial (n);
printf ("\nEl factorial de %d es: %ld", n, f);
}
long factorial (int numero)
{
int i;
long fac=1;

for (i=1; i<=numero; i++)


fac = fac * i;
return fac;
}

S.3.4
#include <stdio.h>
int numero_combinatorio (int, int);
long factorial (int);
void main (void)
{
int m, n;

printf ("\nIntroduzca dos números enteros positivos n y m: ");


scanf ("%d%d", &n, &m);
printf ("El número combinatorio es: %d", numero_combinatorio (n, m));
}
int numero_combinatorio (int n, int m)
{
int num;

num = factorial(n) / (factorial(m)*factorial(n-m));


return num;
}
long factorial (int numero)
{
int i;
long fac=1;

for (i=1; i<=numero; i++)


fac = fac * i;
return fac;
}

A.3.2
#include <stdio.h>
int suma_intervalo (int, int);
void main (void)
{
int x1, x2, suma;

printf ("\nIntroduce dos valores: ");


scanf ("%d%d", &x1, &x2);
suma = suma_intervalo (x1, x2);
printf ("\nLa suma de los valores del intervalo es: %d", suma);
}
int suma_intervalo (int n1, int n2)
{
int i, suma=0;
for (i=n1; i<=n2; i++)
suma = suma + i;
return suma;
}

A.3.3
#include <stdio.h>
typedef enum {Falso, Cierto} Logico;
Logico esBisiesto (int);
void main (void)
{
int a;

printf ("\nIntroduzca el año: ");


scanf ("%d", &a);

if (esBisiesto(a))
printf ("\nEl año es bisiesto");
else
printf ("\nEl año no es bisiesto");
}
Logico esBisiesto (int anyo)
{
Logico bisiesto;

bisiesto = anyo%4==0 && anyo%100!=0 || anyo%400==0;


return bisiesto;
}

A.3.13
#include <stdio.h>
#include <math.h>
#define PI 3.14159

double lee_datos (void);


double calcula_seno (double);
void presenta_seno (double, double);
double potencia (double, int);
void main (void)
{
double angulo, seno;

angulo = lee_datos ();


seno = calcula_seno (angulo);
presenta_seno (angulo, seno);
}

double lee_datos (void)


{
double angulo;

printf ("\nIntroduzca un ángulo entre -PI/2 y PI/2: ");


scanf ("%lf", &angulo);
while ((angulo < -PI/2) || (angulo > PI/2))
{
printf ("\nÁngulo incorrecto; introduzca de nuevo: ");
scanf ("%lf", &angulo);
}
return angulo;
}

double calcula_seno (double angulo)


{
double seno;

seno = angulo - potencia(angulo,3)/6 + potencia(angulo,5)/120;


return seno;
}

void presenta_seno (double angulo, double seno)


{
printf ("\nEl seno aproximado del ángulo %lf es %lf", angulo, seno);
}

double potencia (double base, int exponente)


{
int i;
double pot=1;

for (i=1; i<=exponente; i++)


pot = pot*base;
return pot;
}

S.3.8
void maxmin (int x1, int x2, Pint max, Pint min)
{
if (x1 < x2)
{
*max = x2;
*min = x1;
}
else
{
*max = x1;
*min = x2;
}
}

S.3.11
void valida_dato (Pint dato, int min, int max, int defecto)
{
if (*dato < min || *dato > max)
*dato = defecto;
}

A.3.18
#include <stdio.h>
void tabla_multiplicar (int);

void main (void)


{
int i;

for (i=1; i<=10; i++)


{
printf ("\nTabla de multiplicar del %d:", i);
tabla_multiplicar (i);
}
}

void tabla_multiplicar (int n)


{
int i;

for (i=1; i<=10; i++)


printf ("\n%2d x %2d = %3d", n, i, n*i);
}

A.3.19
void incrementa (Modo m, int cantidad, Pint numero)
{
if (m == sumar)
*numero = *numero + cantidad;
else
*numero = *numero - cantidad;
}

A.3.22
void siguiente_fecha (Pint dia, Pint mes, Pint anyo)
{
if (fecha_valida (*dia, *mes, *anyo))
{
if (*dia == duracion (*mes, *anyo))
{
*dia = 1;
if (*mes == 12)
{
*mes = 1;
*anyo = *anyo +1;
}
else
*mes = *mes +1;
}
else
*dia = *dia +1;
}
else
printf ("\nLa fecha %d-%d-%d no es válida\n", *dia, *mes, *anyo);
}

Logico fecha_valida (int dia, int mes, int anyo)


{
Logico valida;

valida = (1<=dia) && (dia<=duracion (mes, anyo)) &&


(1<=mes) && (mes<=12) && (0<=anyo);
return valida;
}

int duracion (int mes, int anyo)


{
int d;

if (mes==2 && bisiesto (anyo))


d = 29;
else if (mes==2 && !bisiesto (anyo))
d = 28;
else if (mes==4 || mes==6 || mes==9 || mes==11)
d = 30;
else
d = 31;

return d;
}

Logico bisiesto (int anyo)


{
Logico bis;

bis = anyo%4==0 && anyo%100!=0 || anyo%400==0;


return bis;
}
INTRODUCCIÓN A LA PROGRAMACIÓN 1
PRÁCTICA 4: TABLAS

E.4.1 Las tablas t1 y t2 deben almacenar unos valores durante la ejecución del bucle for. El índice i de recorrido de las
tablas toma valores desde 0 hasta TAM ambos incluidos. Teniendo en cuenta que el índice de la tabla debe de estar entre 0
y TAM-1, resulta que el valor de t2[TAM] (que no tienen memoria reservada) se almacena en t1[0] (podría haberlo hecho
en cualquier otra variable), lo que evidentemente puede causar un error difícil de descubrir durante la ejecución del
programa. La solución es poner los dos bucles for con el formato:
for (i=0;i<TAM;i++)

E.4.2 Las tablas se definen con un tamaño máximo, en este caso TAM=10, pero eso no quiere decir que el programa
"necesite" toda la memoria reservada. En este caso sólo se van a utilizar las 7 primeras posiciones de la tabla tab. Sin
embargo, en el procedimiento muestraTabla el bucle for se ejecuta mientras i sea menor que TAM. Las soluciones
"especiales" del tipo poner n=10 ó sustituir TAM por 7 no son soluciones válidas, pues no arreglan el problema sino que lo
"parchean" para un caso particular. La solución correcta es que n se pase como parámetro al procedimiento muestraTabla
para que sepa hasta dónde debe imprimir. Esto ocurrirá a menudo en el tratamiento de las tablas, por ejemplo en las
operaciones de ordenación y búsqueda, donde la función además de recibir como parámetro la tabla tiene que recibir
también el tamaño efectivo de ésta.

Así la llamada a muestraTabla debe quedar


muestraTabla(tab,n)

y el procedimiento

void muestraTabla (const Tabla t, int m)


{
int i;
for (i=0;i<m;i++)
printf("\n Elemento %d: %d",i,t[i]);
}

S.4.3 #include <stdio.h>


#define TAM 50
typedef enum {Falso, Cierto} Logico;
typedef int Vector50[TAM];
void ordenacion_intercambio_int (Vector50, int );
void main(void)
{
int i, contador=0, num;
Vector50 tabla;

printf ("\nIntroduzca un número positivo: ");


scanf ("%d", &num);
while (num>0 && contador<TAM) /* la lectura finaliza al leer un -1 */
{
tabla[contador]=num;
contador++;
printf ("Introduzca un número positivo: ");
scanf ("%d", &num);
}
ordenacion_intercambio_int (tabla, contador);
for (i=0; i<contador; i++)
printf ("%d ",tabla[i]);
}

void ordenacion_intercambio_int (Vector50 v, int n)


{
int i,aux;
Logico ordenado=Falso;
while (!ordenado)
{
ordenado = Cierto;
for (i=0; i<n-1; i++)
if (v[i] > v[i+1])
{
aux = v[i];
v[i] = v[i+1];
v[i+1] = aux;
ordenado = Falso;
}
}
}

S.4.7 #include <stdio.h>


#include "v_doble.h"

int lee_vector_double (Vector v)


{
int i, n;

printf ("\nIntroduzca el tamaño de la lista de números: ");


scanf ("%d", &n);

for (i=0; i<n; i++)


{
printf ("\nIntroduzca el número %d: ", i+1);
scanf ("%lf", &v[i]);
}
return (n);
}

void escribe_vector_double (const Vector v, int n)


{
int i;

printf ("\nContenido de la tabla: ");


for (i=0; i<n; i++)
printf ("%f ", v[i]);
}

int busqueda_secuencial_double (const Vector v, int n, double x)


{
int pos = -1;
Logico encontrado = Falso;
int i = 0;

while (i<n && !encontrado)


{
if (v[i] == x)
{
pos = i;
encontrado = Cierto;
}
i++;
}
return (pos);
}

int busqueda_binaria_double (const Vector v, int n, double x)


{
int pos = -1;
Logico encontrado = Falso;
int bajo = 0, alto = n-1, central;

while (bajo<=alto && !encontrado)


{
central = (bajo + alto)/2;
if (v[central] == x)
{
pos = central;
encontrado = Cierto;
}
else if (v[central] < x)
bajo = central+1;
else
alto = central-1;
}
return (pos);
}

void ordenacion_intercambio_double (Vector v, int n)


{
int i;
double aux;
Logico ordenado = Falso;

while (!ordenado)
{
ordenado = Cierto;
for (i=0; i<n-1; i++)
if (v[i] > v[i+1])
{
aux = v[i];
v[i] = v[i+1];
v[i+1] = aux;
ordenado = Falso;
}
}

A.4.1 #include <stdio.h>


#define TAM 10
typedef int Vector10[TAM];

void main (void)


{
int i;
Vector10 tabla;

for (i=0; i<TAM; i++)


tabla[i]=(i+1)*(i+1);
for (i=0; i<TAM; i++)
printf("%d ", tabla[i]);
}

A.4.5 #include <stdio.h>


#define TAM 100
typedef float Vector100[TAM];

void main (void)


{
Vector100 numeros;
float suma, maximo, minimo, medio;
int i, n;

printf ("\nIntroduzca el tamaño de la lista de números: ");


scanf ("%d", &n);

for (i=0; i<n; i++)


{
printf ("\nIntroduzca el número %d: ", i+1);
scanf ("%f", &numeros[i]);
}

suma = numeros[0];
minimo = numeros[0];
maximo = numeros[0];
for (i=1; i<n; i++)
{
suma = suma + numeros[i];
if (numeros[i] < minimo)
minimo = numeros[i];
else if (numeros[i] > maximo)
maximo = numeros[i];
}
medio = suma/n;

printf ("\nLa suma es: %f", suma);


printf ("\nEl valor medio es: %f", medio);
printf ("\nEl valor mínimo es: %f", minimo);
printf ("\nEl valor máximo es: %f", maximo);
}

A.4.8 #include <stdio.h>


#define TAM 50
typedef enum {Falso, Cierto} Logico;
typedef int Vector50[TAM];

int busqueda_secuencial_int (const Vector50, int, int);

void main (void)


{
int pos, x, i=0, n, num;
Vector50 numeros;

printf("\nIntroduzca un número positivo: ");


scanf ("%d", &num);
while (num>0 && i<TAM)
{
numeros[i++]=num;
printf("Introduzca un número positivo: ");
scanf ("%d", &num);
}
n=i;

printf ("\nIntroduzca el valor a buscar: ");


scanf ("%d", &x);
pos = busqueda_secuencial_int (numeros, n, x);
if (pos == -1)
printf ("Elemento no encontrado\n");
else
printf ("La posición es %d", pos);
}

int busqueda_secuencial_int (const Vector50 v, int n, int x)


{
int pos=-1;
Logico encontrado=Falso;
int i=0;

while (i<n && !encontrado)


{
if (v[i] == x)
{
pos = i;
encontrado = Cierto;
}
i++;
}
return pos;
}

Vous aimerez peut-être aussi