Ciclos y Bucles – PSeInt.org https://pseint.org Descarga, Tutoriales y Ejercicios de Pseudocódigo Wed, 14 Oct 2026 16:24:41 +0000 es hourly 1 https://wordpress.org/?v=7.1.3 https://pseint.org/wp-content/uploads/2026/01/favicon-150x150.png Ciclos y Bucles – PSeInt.org https://pseint.org 32 32 Algoritmo para el juego de dados: adivina la suma en PSeInt (Guía 2026) https://pseint.org/juego-dados-suma-7-pseint/ Wed, 14 Oct 2026 16:24:41 +0000 https://pseint.org/juego-dados-suma-7-pseint/ Este mini juego lanza dos dados virtuales con la función azar() y reta al usuario a adivinar la suma antes de ver el resultado. Es una forma divertida de practicar números aleatorios, lectura de datos y condicionales en un solo programa.

Código completo

Algoritmo JuegoDadosSuma7
    Definir dado1, dado2, suma, apuesta Como Entero
    dado1 <- azar(6) + 1
    dado2 <- azar(6) + 1
    suma <- dado1 + dado2
    Escribir "Adivina la suma de dos dados (2-12):"
    Leer apuesta
    Escribir "Dado 1: ", dado1, "  Dado 2: ", dado2
    Si apuesta = suma Entonces
        Escribir "¡Ganaste! La suma es ", suma, "."
    SiNo
        Escribir "Perdiste. La suma era ", suma, "."
    FinSi
FinAlgoritmo

Explicación paso a paso

  1. Se lanzan los dos dados: azar(6) genera 0 a 5, por eso se suma 1 para obtener 1 a 6.
  2. Se calcula la suma de ambos dados.
  3. Se pide al usuario que apueste por un valor entre 2 y 12.
  4. Se muestran los dados que salieron.
  5. Con un Si se compara la apuesta con la suma real y se anuncia si ganó o perdió.

Errores comunes

  • Usar azar(6) sin sumar 1: daría valores de 0 a 5 y un dado nunca muestra 0.
  • Lanzar los dados después de la apuesta: el orden no cambia el resultado, pero es más limpio lanzar primero.
  • Rango de apuesta 1-12: con dos dados la suma mínima es 2; el mensaje debe decir 2-12.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]> Algoritmo para imprimir los impares del 1 al 100 en PSeInt (Guía 2026) https://pseint.org/numeros-impares-1-100-pseint/ Wed, 14 Oct 2026 16:23:46 +0000 https://pseint.org/numeros-impares-1-100-pseint/ Imprimir solo los impares del 1 al 100 se resuelve de forma elegante con un ciclo Para que avanza de dos en dos empezando en 1. Sin condiciones ni filtros: el propio incremento garantiza que solo salgan impares.

Código completo

Algoritmo NumerosImpares1a100
    Definir i Como Entero
    Para i <- 1 Hasta 100 Con Paso 2 Hacer
        Escribir i
    FinPara
FinAlgoritmo

Explicación paso a paso

  1. Se define el contador i.
  2. El ciclo Para empieza en 1, el primer impar.
  3. Con Paso 2 el contador salta de impar en impar: 1, 3, 5…
  4. En cada vuelta se muestra el valor actual de i.
  5. El ciclo termina al superar 100, mostrando el 99 como último impar.

Errores comunes

  • Empezar en 0 o 2 con Paso 2: eso generaría pares, no impares; el inicio correcto es 1.
  • Usar Paso 1 con un Si: funciona pero es innecesariamente complicado; Paso 2 lo resuelve directo.
  • Límite 99 en vez de 100: con Hasta 100 el ciclo se detiene solo en el 99; no hace falta ajustar el límite.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]> Algoritmo para las tablas de multiplicar del 1 al 10 en PSeInt (Guía 2026) https://pseint.org/tablas-multiplicar-1-10-pseint/ Wed, 14 Oct 2026 16:22:51 +0000 https://pseint.org/tablas-multiplicar-1-10-pseint/ Imprimir las diez tablas de multiplicar completas es el ejemplo más claro de ciclos anidados: el ciclo externo elige de qué número es la tabla y el ciclo interno recorre los multiplicadores del 1 al 10. A diferencia de la tabla de un solo número, aquí se generan las 10 tablas de una vez.

Código completo

Algoritmo TablasMultiplicar1a10
    Definir i, j Como Entero
    Para i <- 1 Hasta 10 Con Paso 1 Hacer
        Escribir "Tabla del ", i, ":"
        Para j <- 1 Hasta 10 Con Paso 1 Hacer
            Escribir i, " x ", j, " = ", i * j
        FinPara
        Escribir ""
    FinPara
FinAlgoritmo

Explicación paso a paso

  1. El ciclo externo recorre i desde 1 hasta 10: cada valor es una tabla.
  2. Se muestra el encabezado ‘Tabla del i’.
  3. El ciclo interno recorre j desde 1 hasta 10 para cada tabla.
  4. En cada vuelta interna se muestra la multiplicación i x j = resultado.
  5. Al terminar una tabla se imprime una línea en blanco como separador.

Errores comunes

  • Reutilizar la misma variable: el ciclo externo y el interno necesitan variables distintas (i y j).
  • Olvidar el FinPara interno: cada Para necesita su propio FinPara; revisa que estén bien anidados.
  • Mostrar i * j fuera del ciclo interno: el producto solo tiene sentido dentro del ciclo que recorre j.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]> Algoritmo para promediar números hasta un centinela en PSeInt (Guía 2026) https://pseint.org/promedio-hasta-centinela-pseint/ Wed, 14 Oct 2026 16:21:56 +0000 https://pseint.org/promedio-hasta-centinela-pseint/ Cuando no se sabe cuántos datos va a ingresar el usuario, se usa un valor centinela para terminar la lectura. Aquí el centinela es cualquier número negativo: al detectarlo se detiene la lectura y se calcula el promedio de todo lo ingresado.

Código completo

Algoritmo PromedioHastaCentinela
    Definir num Como Real
    Definir suma Como Real
    Definir cantidad Como Entero
    suma <- 0
    cantidad <- 0
    Escribir "Ingresa números (negativo para terminar):"
    Leer num
    Mientras num >= 0 Hacer
        suma <- suma + num
        cantidad <- cantidad + 1
        Leer num
    FinMientras
    Si cantidad > 0 Entonces
        Escribir "El promedio es: ", suma / cantidad
    SiNo
        Escribir "No se ingresaron números."
    FinSi
FinAlgoritmo

Explicación paso a paso

  1. Se definen suma y cantidad inicializadas en 0, y se lee el primer número.
  2. El ciclo Mientras continúa mientras el número no sea negativo.
  3. Dentro del ciclo se acumula el número y se cuenta cuántos van.
  4. Al final de cada vuelta se lee el siguiente número.
  5. Al salir del ciclo se verifica que se haya ingresado al menos un número.
  6. Si hay datos se muestra suma / cantidad; si no, un mensaje de aviso.

Errores comunes

  • Leer solo dentro del ciclo: se necesita una primera lectura antes del Mientras para que la condición tenga sentido.
  • Dividir sin verificar cantidad: si el primer valor ya es negativo, cantidad vale 0 y habría división entre cero.
  • Sumar el centinela: la lectura del siguiente número va al final del ciclo para que el negativo no se acumule.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]> Algoritmo para listar números primos hasta N en PSeInt (Guía 2026) https://pseint.org/primos-hasta-n-pseint/ Wed, 14 Oct 2026 16:21:01 +0000 https://pseint.org/primos-hasta-n-pseint/ A diferencia de verificar un solo número, aquí listamos todos los primos entre 2 y N. Se usan dos ciclos anidados: el externo recorre cada candidato y el interno cuenta sus divisores. Si un número tiene exactamente 2 divisores, es primo.

Código completo

Algoritmo PrimosHastaN
    Definir N, i, j, divisores Como Entero
    Escribir "Ingresa N:"
    Leer N
    Para i <- 2 Hasta N Con Paso 1 Hacer
        divisores <- 0
        Para j <- 1 Hasta i Con Paso 1 Hacer
            Si i MOD j = 0 Entonces
                divisores <- divisores + 1
            FinSi
        FinPara
        Si divisores = 2 Entonces
            Escribir i
        FinSi
    FinPara
FinAlgoritmo

Explicación paso a paso

  1. Se lee N y el ciclo externo recorre cada candidato i desde 2 hasta N.
  2. Para cada i se reinicia el contador de divisores en 0.
  3. El ciclo interno prueba todos los j desde 1 hasta i.
  4. Si i MOD j = 0, j es divisor y se incrementa el contador.
  5. Al terminar el ciclo interno, si divisores = 2, el número es primo y se muestra.

Errores comunes

  • No reiniciar divisores: el contador debe volver a 0 para cada candidato i, dentro del ciclo externo.
  • Empezar en 1: el 1 no es primo; el recorrido debe empezar en 2.
  • Confundir los contadores: i es el candidato, j prueba divisores; no se deben mezclar.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]> Algoritmo para generar potencias de 2 hasta N en PSeInt (Guía 2026) https://pseint.org/potencias-de-2-hasta-n-pseint/ Wed, 14 Oct 2026 16:20:06 +0000 https://pseint.org/potencias-de-2-hasta-n-pseint/ Las potencias de 2 (1, 2, 4, 8, 16…) aparecen en informática por todas partes. Este algoritmo las genera multiplicando por 2 en cada vuelta del ciclo, deteniéndose cuando el valor supera el límite N.

Código completo

Algoritmo PotenciasDe2HastaN
    Definir N, potencia Como Entero
    potencia <- 1
    Escribir "Ingresa N:"
    Leer N
    Mientras potencia <= N Hacer
        Escribir potencia
        potencia <- potencia * 2
    FinMientras
FinAlgoritmo

Explicación paso a paso

  1. Se define potencia inicializada en 1 (que es 2^0) y se lee N.
  2. El ciclo Mientras se repite mientras potencia no supere N.
  3. En cada vuelta se muestra la potencia actual.
  4. Luego se multiplica potencia por 2 para obtener la siguiente.
  5. Cuando potencia supera N, el ciclo termina.

Errores comunes

  • Empezar potencia en 0: 0 multiplicado por 2 siempre da 0 y el ciclo sería infinito; debe empezar en 1.
  • Condición potencia < N: con < se perdería el caso en que N es exactamente una potencia de 2; usa <=.
  • Mostrar después de multiplicar: se debe mostrar antes de multiplicar para no saltarse el 1.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]> Algoritmo para calcular el MCM de dos números en PSeInt (Guía 2026) https://pseint.org/mcm-dos-numeros-pseint/ Wed, 14 Oct 2026 16:19:11 +0000 https://pseint.org/mcm-dos-numeros-pseint/ El mínimo común múltiplo (MCM) se obtiene fácilmente si ya conoces el MCD: MCM(a,b) = (a × b) / MCD(a,b). Este algoritmo primero calcula el MCD con el algoritmo de Euclides y luego aplica la fórmula.

Código completo

Algoritmo MCMDosNumeros
    Definir a, b, x, y, temp, mcd, mcm Como Entero
    Escribir "Ingresa el primer número:"
    Leer a
    Escribir "Ingresa el segundo número:"
    Leer b
    x <- a
    y <- b
    Mientras y <> 0 Hacer
        temp <- y
        y <- x MOD y
        x <- temp
    FinMientras
    mcd <- x
    mcm <- trunc((a * b) / mcd)
    Escribir "El MCM es: ", mcm
FinAlgoritmo

Explicación paso a paso

  1. Se leen a y b, y se copian en x e y para no perder los valores originales.
  2. Con el algoritmo de Euclides se calcula el MCD, que queda en x.
  3. Se guarda el MCD en la variable mcd.
  4. Se aplica la fórmula mcm = (a * b) / mcd usando trunc para obtener un entero.
  5. Se muestra el resultado.

Errores comunes

  • Usar a y b directamente en Euclides: se destruirían los valores originales que necesita la fórmula; por eso se usan las copias x e y.
  • Olvidar el trunc: la división puede dar decimal en PSeInt; trunc asegura un entero.
  • Dividir antes de multiplicar: (a / mcd) * b puede perder precisión; mejor multiplicar primero.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]> Algoritmo para calcular el MCD de dos números en PSeInt (Guía 2026) https://pseint.org/mcd-dos-numeros-pseint/ Wed, 14 Oct 2026 16:18:15 +0000 https://pseint.org/mcd-dos-numeros-pseint/ El máximo común divisor (MCD) se calcula de forma elegante con el algoritmo de Euclides: se repiten divisiones con resto hasta que el resto sea cero, y el último divisor no nulo es el MCD. Un método de hace más de 2000 años que funciona perfecto en PSeInt.

Código completo

Algoritmo MCDDosNumeros
    Definir a, b, temp Como Entero
    Escribir "Ingresa el primer número:"
    Leer a
    Escribir "Ingresa el segundo número:"
    Leer b
    Mientras b <> 0 Hacer
        temp <- b
        b <- a MOD b
        a <- temp
    FinMientras
    Escribir "El MCD es: ", a
FinAlgoritmo

Explicación paso a paso

  1. Se leen los dos números en las variables a y b.
  2. El ciclo Mientras se repite mientras b sea distinto de cero.
  3. Se guarda b en temp para no perder su valor.
  4. b toma el valor del resto de a MOD b.
  5. a toma el valor anterior de b (guardado en temp).
  6. Cuando b llega a 0, el valor de a es el MCD.

Errores comunes

  • Perder el valor de b: sin la variable temp, al hacer b <- a MOD b se pierde el b original que necesita a.
  • Condición b = 0: el ciclo debe continuar mientras b sea distinto de cero (<> 0).
  • Mostrar b al final: al terminar b vale 0; el MCD queda en a.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]> Algoritmo para verificar un número capicúa en PSeInt (Guía 2026) https://pseint.org/numero-capicua-pseint/ Wed, 14 Oct 2026 16:17:02 +0000 https://pseint.org/numero-capicua-pseint/ Un número capicúa se lee igual al derecho y al revés, como 1221 o 787. Para detectarlo se invierte el número dígito por dígito y se compara con el original guardado. Si coinciden, es capicúa.

Código completo

Algoritmo NumeroCapicua
    Definir num, original, invertido, digito Como Entero
    invertido <- 0
    Escribir "Ingresa un número:"
    Leer num
    original <- num
    Mientras num > 0 Hacer
        digito <- num MOD 10
        invertido <- invertido * 10 + digito
        num <- trunc(num / 10)
    FinMientras
    Si invertido = original Entonces
        Escribir original, " es capicúa."
    SiNo
        Escribir original, " no es capicúa."
    FinSi
FinAlgoritmo

Explicación paso a paso

  1. Se lee el número y se guarda una copia en la variable original.
  2. Con un ciclo Mientras se invierte el número dígito por dígito (MOD 10 y trunc).
  3. Al terminar, invertido contiene el número al revés.
  4. Se compara invertido con original usando un Si.
  5. Si son iguales se informa que es capicúa; si no, que no lo es.

Errores comunes

  • No guardar el original: el ciclo destruye num, por eso se necesita la copia en original antes de invertir.
  • Comparar num con invertido: al salir del ciclo num vale 0; la comparación correcta es con original.
  • Olvidar el trunc: sin trunc(num / 10) el número nunca se reduce y el ciclo no termina.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]> Algoritmo para invertir un número en PSeInt (Guía 2026) https://pseint.org/invertir-numero-pseint/ Wed, 14 Oct 2026 16:16:07 +0000 https://pseint.org/invertir-numero-pseint/ Invertir un número (convertir 123 en 321) es un ejercicio clásico de lógica con ciclos. Se extrae el último dígito con MOD 10, se agrega al número invertido y se elimina ese dígito del original. Aquí está el código explicado paso a paso.

Código completo

Algoritmo InvertirNumero
    Definir num, invertido, digito Como Entero
    invertido <- 0
    Escribir "Ingresa un número:"
    Leer num
    Mientras num > 0 Hacer
        digito <- num MOD 10
        invertido <- invertido * 10 + digito
        num <- trunc(num / 10)
    FinMientras
    Escribir "Número invertido: ", invertido
FinAlgoritmo

Explicación paso a paso

  1. Se define invertido inicializado en 0 y se lee el número.
  2. El ciclo Mientras se repite mientras num sea mayor que 0.
  3. Con num MOD 10 se extrae el último dígito.
  4. Se multiplica invertido por 10 y se le suma el dígito extraído.
  5. Con trunc(num / 10) se elimina el último dígito del número original.
  6. Al terminar el ciclo, invertido contiene el número al revés.

Errores comunes

  • Usar num / 10 sin trunc: la división deja decimales; trunc elimina la parte decimal correctamente.
  • No inicializar invertido: debe partir de 0 para ir armando el número dígito a dígito.
  • Condición num >= 0: con 0 el ciclo nunca terminaría; debe ser num > 0.

🚀 ¿Ya dominas la lógica? Da el salto a Python

Ver curso de Python en español →

]]>