[ Foro de Pascal ]

ayuda

Cordial saludo Profesor Nacho Cabanes y Antonio.
Agradecerles de antemano su tiempo y la ayuda que nos brindais y que nos ayuda tanto a descubrir nuevas cosas en la programacion.

tengo dudas de como resolver el siguiente ejercicio:

Un arreglo de números se llama partidario si todo número que está en una casilla par (2,4,…) es mayor que cualquiera de los números que están en las casillas impares (1,3,5,…). Escriba un programa que ( SEA  EFICIENTE EN SU RESPUESTA, es decir, en el momento que encuentre que alguno de los elementos no cumple la condicion del enunciado no siga recorriendo el resto del array ) lea un arreglo de números enteros y luego, diga si es partidario o no.

Por ejemplo, si el arreglo es el siguiente:

 1    2    3    4    5   6   7   8   9   10   //indices del arreglo    
100 5 200 1 1000 0 600 50 300 4    //valores del arreglo

El programa debe escribir: es partidario.

yo he intentado hacer algo como esto:

... declaracion de variables y del arreglo

for i:=1 to 10 do
if ( (i mod 2 = 0) and (arreglo[i]>arreglo[i+1]) ) then
   write('es partidario')
 else
   write('no es partidario')

pero claro en este caso de me estaria imprimiendo cada vez que cumpla la condicion del if el mensaje "es partidario", ademas creo que no estaria siendo eficiente por que con el for estaria recorriendo todo el vector y se supone que en el momento de encontrar un elemento que no cumpla se debe parar y enviar el mensaje " no es partidario.
pero no encuentro como hacerlo y por eso acudo a vuestra ayuda para que me orienten en como podria hacerlo y ademas como seria utilizando un while que creo seria la forma eficiente por que con este bucle controlaria la parada en caso de que un elementop no cumpliese con la condicion, pero no me surge como , con vuestra ayuda se que podre acalrar muchas dudas que tengo mil gracias como siempre por su valioso tiempo y la ayuda generosa que nos brindais.
 

Si cualquier número de posición par tiene que ser mayor que TODOS los de posiciones impares, yo daría una primera pasada para descubrir el mayor de los valores de posiciones impares.

Después, en una segunda pasada, vas comparando ese valor memorizado con el valor de cada posición par. En cuanto encuentres un valor que no cumpla, interrumpes el proceso (puedes usar un "repeat..until" para eso). Si llegas al final sin encontrar valores incorrectos, es que sí era partidario.

Hola Óscar.

Efectivamente, yo te habría dicho lo mismo que el Profesor.

A lo mejor esto te ayuda en los siguientes programas:

RECORRIDO ---------------------------------- BUCLE

Completo ----------------------------------- For
Al menos un paso --------------------------- Repeat
Quizá no se entrará en el bucle ------------ While


¡Hasta luego!

Permiteme decirte profesor por que para mi lo eres, entre otras cosas por que tienes un don para ayudar y eso es de profesores,mil gracias siempre por tu ayuda.
Antonio, queria pedirte el favor si me puedes esquematizar en seudocodigo usando el repeat until, es que no entiendo bien como lo de la primera pasada y despues lo de la segunda pasada y como voy comparando ese valor ( el mayor de los valores de posiciones impares ) memorizado con el valor de cada posición par?? te agradezco muchisimo que me ayudes pues esta parte en la programacion me ha costado, es decir como se utiliza un ciclo cuando no hay que recorer todo el array, ayudame por favor pues gracias a sus explicaciones puedo ir superandome poco apoco pues desafortunadamente no cuento con los medios para poder ingresar en una academia y menos en una universidad pero quiero aprender a programar y se que con sus ayudas y explicaciones poco a poco estoy mejorando, mil gracias.

OK, pues vamos a ver:

Paso 1: Encontrar el máximo de las casillas impares.
Paso 2: Comparar el anterior valor con los de las casillas pares.

Nomenclatura que utilizaré:

- "vector": será el vector [1..N] celdas de valores integer.
- "max": será el valor máximo.
- "cont": será el contador para los bucles.

Vemos el paso nº1:

- Tener en cuenta que:
---> Solamente se examinan las celdas impares.
---> Si el valor que encontramos es mayor que max, max pasa a tener ese valor.

- Desarrollo:
max:= vector[1]; { Necesita un valor válido. }
desde cont=3 hasta N hacer
 si cont es impar then
   si max es menor que vector[cont] then
     max:= vector[cont];

- Tras este bucle, cont = N.(Es importante para el paso nº2, ya que aprovecho esa misma variable).


Vemos el paso nº2:

- Tener en cuenta que se examinan las celdas impares.
- Usamos repeat...until porque al menos habrá que examinar una vez (suponiendo, claro, que N es mayor o igual que 2, es decir, que al menos hay 2 celdas en el array).
- Hay que plantear bien la condición o condiciones de parada. El bucle parará cuando se produzca uno de estos hechos:
---> Nos pasemos de N con cont.
---> Encontremos un valor de las celdas pares mayor que max.

- Desarrollo:
cont:= 2; {Por eso decía que era importante lo del paso nº1}
repeat
 si vector[cont] es menor que max entonces
   cont:= cont + 2; {De celda par a celda par. }
until (vector[cont] es mayor que máx) o (cont es mayor que N);
si cont > N entonces {significa que no hemos encontrado ninguno mayor que max.}
 write ('Yuju!')
else
 write ('Hay un valor mayor que ',max,' en la casilla ',cont);


Y creo que así funcionría. Revísalo y luego trata de implementarlo y probarlo con diferentes ejemplares de funcionamiento.

¡Ciao!

Mil gracias Antonio me lo has explicado perfecto y he aprendido algo nuevo gracias a ti y a Nacho, mil gracias y que toda esta ayuda desinteresada colme a Uds y los suyos de bendiciones, mile gracias de verdad
ciao

Buenas noches profesor Antonio.
Mira implemente la idea que me diste en el algoritmo de este ejercicio pero al ejecutarlo para cualquier vector me sale que "es partidario" y no me entra en el caso de que deba mostrar el mensaje "el vector no es partidario", quisiera pòr favor me ayudaras a indicarme donde puede estar mi error, o si estoy haciendo algo mal y por eso no me funciona como deberia.El codigo completo compilado ok es:


program partidario;
uses crt;
type vector1=array[1..20] of integer;
var vect:vector1;
var  max,orden,cont:integer;

procedure leervector(var vec:vector1;var orden:integer);
begin
clrscr;
writeln;
writeln;
writeln;
writeln;
write('ingrese el tama¤o del vector :');
readln(orden);
for cont:=1 to orden do
begin
 write('escriba el elemento[',cont,']:');
 readln(vec[cont]);
 end;
end;

 procedure muestravector(var vec:vector1;var orden:integer);
 begin
  for cont:=1 to orden do
   write(vec[cont]:4);
   writeln;
 end;

 begin
 leervector(vect,orden);
 muestravector(vect,orden);
  max:=vect[1];
  for cont:=3 to orden do
    begin
      if(cont mod 2 <>0) then
         if(max<vect[cont]) then
            max:=vect[cont];
     end;

   cont:=2;
   repeat
     if(vect[cont]<max) then
       cont:=cont+2;
    until((vect[cont]>max) or (cont>orden));

     if(cont>orden) then
       write('el vector es partidario')
      else
        write('el vector no es partidario');
   readkey;
 end.

Tu ayuda al igual que la del profesor Nacho son tan importantes para nosotros que cada vez es un mil gracias sincero y ojala podamos alcanzar algun dia su nivel.

ayudame porfa a ver que esta mal para que me funcione ok, como ves le estoy dedicando tiempo a aprender y tu ayuda me sirve muchisimo.

Las condiciones que tienes al final están mal: los pares deben ser mayores que los impares de modo que debes avanzar si es mayor, no si es menor:

if(vect[cont] > max) then
       cont:=cont+2;

y claro, la condición del "until" debe ser la contraria, porque repetirás hasta que encuentres un número que sea menor que el máximo de los impares:

until((vect[cont] < max) or (cont>orden));


Con las correcciones y con comentarios podría quedar así:

-----

program partidario;

uses crt;

type
 vector1=array[1..20] of integer;

var
 vect:vector1;
 max,orden,cont:integer;

procedure leervector(var vec:vector1;var orden:integer);
begin
clrscr;
writeln;
writeln;
writeln;
writeln;
write('ingrese el tama¤o del vector :');
readln(orden);
for cont:=1 to orden do
begin
 write('escriba el elemento[',cont,']:');
 readln(vec[cont]);
 end;
end;

procedure muestravector(var vec:vector1;var orden:integer);
begin
 for cont:=1 to orden do
   write(vec[cont]:4);
 writeln;
end;


(* Cuerpo del programa *)
begin
 leervector(vect,orden);
 muestravector(vect,orden);

 (* Busco el maximo de los impares *)
 max:=vect[1];
 for cont:=3 to orden do
   begin
     if(cont mod 2 <>0) then
         if(max < vect[cont]) then
           max := vect[cont];
    end;
 writeln('Maximo encontrado: ', max);


 (* Comparo todos los pares con el maximo *)
 cont:=2;
 repeat
   writeln('Comparando: ', vect[cont]);
   if(vect[cont] > max) then
     cont:=cont+2;
 until((vect[cont] < max) or (cont>orden));

 (* Si he llegado al final, era partidario *)
 if(cont > orden) then
   writeln('El vector es partidario')
 else
   write('El vector no es partidario');

 readkey;
end.