Ejercicios resueltos de algoritmia pseudocódigo dada lista números comprobar si

[jrgelloco@gmail.com]

Hola necesito ayuda concretamente con este ejercicio...

Escribir un algoritmo que, dada una lista de números ordenados un número N, te devuelva VERDADERO si alguna combinación de dos números cualesquiera suman N, y devuelva FALSO si ninguna combinación de dos números sumados da como resultado el número N.
 

Por Ejemplo:

En este caso, la lista es [1,2,3,4] y el segundo número (N) es 10:
[1 ,2, 3, 4] y 10. Quieres saber si alguna combinación de esos cuatro números de la lista suman 10. en Este caso es FALSO, porque ninguna combinación de dos números suma diez.
[1, 2, 3, 4] y 5 . Es VERDADERO, porque 2 + 3 es igual a cinco.
[1, 2, 3, 4] y 8 . Es FALSO.

[2,5,7,10,11,15,20] y 13 // verdadero 2+11 suman 13
[2,5,7,10,11,15,20] y 14 // falso


Y aquí es hasta donde he podido llegar..

Código: [Seleccionar]

Proceso sumanN
Definir datos, i,n,a,b,numN Como Entero;
dimension datos[20];
escribir "ingresar la cantidad de numeros que dispone la lista(de 2 a 20)";
leer n;
para i<- 0 hasta n-1 Hacer
escribir " ingrese el dato ", i+1,":";
leer datos[i];

FinPara
Escribir " ingrese el numero (N) para comparar los numeros de la lista ";
leer numN;

a<-0;
b<-1;

Mientras datos[a] <> datos[n-2] Hacer
Repetir
si datos[a] + datos[b] = numN Entonces
Escribir "Verdadero"," Puesto que ",datos[a]," + ", datos[b], " = ", numN;
b<-b+1;

finsi


Hasta Que datos[b] == datos[n-1]


Repetir
a<-a+1;
si datos[b]<>datos[n-1] Entonces
Escribir "Verdadero"," Puesto que ",datos[a]," + ", datos[b], " = ", numN;
b<-b+1;
FinSi
Hasta Que datos[a] == datos[n-2]



FinMientras



FinProceso

Si alguien me puede ayudar o guiarme se lo agradezco de antemano..!!

[Kabuto]

Yo lo haría así

Código: [Seleccionar]

para a < - 0 hasta n-2 hacer
    para b <- a+1 hasta n-1 hacer
        si datos[a] + datos[b] = numN entonces
            Escribir "Verdadero"," Puesto que ",datos[a]," + ", datos[b], " = ", numN;
        finsi
    finpara
finpara
El primer bucle recorre desde el primer valor, hasta el penúltimo.
El segundo bucle, comienza por el siguiente valor al que está apuntando actualmente el primer bucle, hasta el final.
Así se evitan comprobaciones redundantes

Es decir, la primera ejecución se cogería el valor en la posición [ 0 ], el segundo bucle comenzaría por el [1] hasta el final.
Luego el primer bucle coge el [1], y el segundo bucle el [2], y de nuevo hasta el final.
El segundo bucle no pasará por el valor[ 0 ], porque ya se han probado sus posibles combinaciones en la primera ejecución.

En la tercera ejecución, primer bucle se posiciona en [2] y el segundo bucle en [3], y a probar combinaciones hasta el final...

Y así hasta comprobar todas las combinaciones.

Lo he probado transcribiendolo a Java y parece que funciona bien.


Tan solo hay dos detalles que no se han tenido en cuenta.
- Solo hay mensaje para cuando es VERDADERO, no estamos controlando que pasa cuando es FALSO.
- Tal cuál está escrito, se mostrarían en pantalla todas las posibles combinaciones que sumen numN. Es decir, podría mostrarse varias veces el mensaje de VERDADERO.
Esto no es malo per se, pero posiblemente queramos que solo se muestre una vez, o sea, cuando encuentre una combinación válida, que indique VERDADERO y deje de seguir probando otras combinaciones.

Ambos detalles, podrían controlarse usando un boolean que adopte valor TRUE cuando se encuentre una combinación.
De ese modo, sabríamos cuando poner fin a los bucles y además luego al final de todo sabríamos si hay que mostrar el mensaje de FALSO o no.

En cualquier caso, en un ejercicio de pseudocódigo no se si es exigible controlar estos detalles.

Inténtalo si quieres y si tienes dudas pregunta por aquí.

[jrgelloco@gmail.com]

Hola, me sirvió mucho. No lo había pensado con dos ciclos for..!!
Te agradezco, un saludos y gracias desde la distancia..!!