Pascal/Turbo Pascal - Desarrolle un algoritmo que permita leer un valor entero positivo N y determinar si es primo o no

Val: 12

Desarrolle un algoritmo que permita leer un valor entero positivo N y determinar si es primo o no

Publicado por Henry (1 intervención) el 03/10/2020 01:00:13

Buenas tardes, soy nuevo en Pascal y me encuentro haciendo un ejercicio de pascal que corresponde a lo siguiente:

Ejercicio No: 9
Desarrolle un algoritmo que permita leer un valor entero positivo N y determinar si es primo o no.

El pseucodigo estaria de la siguiente forma:

1. Inicio

2. Declaración de variables:

J = 2, S =0

3. Leer N

4. Mientras J<= N / 2 hacer

5. Si N / J =0

6. S=S+1

7. J=J+1

8. Fin_Si

9. Fin del ciclo mientras

10. Si S = 0 Entonces

11. Escribir N “es primo”

12. Sino (De lo contrario)

13. Escribir N “no es primo”

14. Fin_Si

15. Fin

Y en su momento lo codifique a Pascal quedando de la siguiente manera:

rogram numeropositivoprimo;

uses crt;

var j, s, n: integer;

BEGIN

	j:=2;

	s:=0;

        n:=0;

	writeln('Escribe un numero');

	read(n);

	while j<=n/2 do

	begin

                if n/j=0 then

                begin

		        s:=s+1;

		        j:=j+1;

end

	end;

	if s=0 then

	begin

		writeln(n, ' es primo');

end

	else

	begin

		writeln(n, ' no es primo');

	end;

readkey;

END.

El ejercicio menciona lo siguiente ¿Qué falta en este algoritmo? ¿ Qué errores presenta?
Segun yo, este no es el modo y mi duda es la siguiente: ¿Que tendría que modificar en mi código para que realmente cumpla con lo que marca el ejercicio?

Valora esta pregunta

Me gusta: Está pregunta es útil y esta clara

No me gusta: Está pregunta no esta clara o no es útil

Responder

Pos: 2

Val: 112

Desarrolle un algoritmo que permita leer un valor entero positivo N y determinar si es primo o no

Publicado por juanba (40 intervenciones) el 08/10/2020 09:36:40

Buenos días. Aquí van mis comentarios acerca del programa de numeros primos.
Primero, el pseudocódigo:
- Entiendo que la variable J es el presunto divisor de N y la variable S un flag que indica que se han encontrado S divisores de N.
- Para determinar si un numero es NO es primo, no hace falta calcular TODOS sus divisores, basta con obtener UNO. Por lo tanto, el bucle "while" puede terminar en el momento en que se encuentre un J que divide a N y ponga el valor 1 en S.
- El algoritmo intenta ciclar J para todos los numeros desde 2 hasta N / 2. En realidad habría que hacerlo ciclar desde 2 hasta la raiz cuadrada de N redondeando la raiz hacia arriba. La razón es que si no hemos encontrado un divisor J menor que sqrt(N) y existiera uno en valores mayores que sqrt(N), al calcular X = N div J nos daría un valor X que por una parte también es divisor de N (porque N div X = J) y por otra parte, al ser J > sqrt(N), X tendría que ser necesariamente menor que sqrt(N) y por lo tanto habría aparecido al buscar los divisores menores que la raiz de N.
- Este rollo que acabo de largar puede parecer que no tiene importancia con valores pequeños de N. Por ejemplo, si N = 20, ciclar hasta N/2 nos daría 10 pasadas mientras que ciclar hasta sqrt(N) serían 5 pasadas. A la velocidad que van los ordenadores no hay prácticamente diferencia. Pero si N = 100 millones, N/2 son 50 millones y sqrt(N) son 10000. Ya se ve que no es lo mismo.
- En el punto 5 del pseudocodigo se comprueba que N / J = 0. Tanto si empleas la division entera como real, el resultado no sera nunca cero porque J es como maximo N / 2, por lo tanto N > J y N / J es mayor que 1. Lo que tienes que emplear es una comprobación de resto cero, o sea (N mod J) = 0.
- Hay que comprobar que N es positivo, pero eso es trivial
- Y por último, te comento que en el código pascal tienes que hacer las divisiones entre enteros por medio de "div". La división con "/" trata los operandos como numeros reales y el resultado tambien. Compruebalo con este programa:

program TestDiv;

var j, n: integer;

BEGIN

  j := 4;

  n := 5;

  writeln(n div j);

  writeln(n / j);

  readln;

END.

Con todo esto, aqui tienes un ejemplo de como podria ir el programa. Vale para N > 2. Empleo un procedimiento auxiliar para calcular la raiz de N, o sea el numero maximo de iteraciones. No es complicado.

program TestDiv;

uses crt;

var j, n, s, limite: integer;

function CalcLimite(Numero: integer): integer;

var i: integer;

begin

  i := 2;

  while i * i < Numero do

    i := i + 1;

  CalcLimite := i;

end;

BEGIN

  clrscr;

  write('Numero a comprobar primalidad: ');

  readln(n);

  if n <= 2 then             // Ignorar negativos, 0, 1 y el 2 que es primo

    writeln('Este numero no me gusta.')

  else begin

    Limite := CalcLimite(n);        (* O tambien  Limite := Round(sqrt(Numero) + 0.5) ;  y nos ahorramos CalcLimite*)

    j := 2;

    s := 0;

    while (j <= Limite) and (s = 0) do        // Bucle de comprobación

    begin

      if (n mod j) = 0 then            // Bingo!

        s := s + 1

      else

        j := j + 1;              // No es divisor; a por el siguiente

    end;

    if s = 0 then             // Hemos llegado al limite sin encontrar divisores

      writeln('El numero ', n, ' es primo.')

    else

      writeln('El numero ', n, ' tiene divisores. Por ejemplo ', j, ' x ', n div j, '.');

  end;

  readln;

END.

Enjoy yourself..

Valora esta respuesta

Me gusta: Está respuesta es útil y esta clara

No me gusta: Está respuesta no esta clara o no es útil

Comentar