Conocer los atajos de teclado de PSeInt te ahorra decenas de clics por sesión: ejecutar el programa, comentar líneas o duplicar código se hace en una fracción de segundo. Esta lista recoge los atajos más útiles y mejor documentados. Ten en cuenta que pueden variar según la versión de PSeInt que uses.

Tabla de atajos de teclado

Los 4 atajos que más usarás

F9 — Ejecutar

Es el atajo que más pulsarás: compila y ejecuta tu pseudocódigo de un toque. Acostúmbrate a probar tu programa con F9 cada pocos cambios en lugar de escribir mucho código sin probarlo.

Ctrl + D — Comentar

Convierte la línea actual (o el bloque seleccionado) en comentario. Ideal para desactivar temporalmente una parte del programa mientras depuras, sin borrarla.

Ctrl + L — Duplicar línea

Crea una copia de la línea actual justo debajo. Muy útil cuando necesitas una instrucción similar con pequeños cambios, como varias líneas de Escribir seguidas.

F3 — Buscar

Abre el diálogo de búsqueda para localizar texto dentro de tu código. Imprescindible en programas largos cuando necesitas encontrar dónde se usa una variable.

¿Por qué un atajo puede no funcionar en tu versión?

PSeInt ha evolucionado durante años y la asignación de teclas ha cambiado entre versiones. Si alguno de estos atajos no responde en tu instalación:

• Revisa el menú correspondiente: la mayoría de las opciones muestran su atajo a la derecha del nombre.
• Consulta la ayuda del programa (F1) o en el menú Ayuda, donde suele haber un listado actualizado.
• Comprueba que no haya otro programa capturando esa combinación de teclas.

Si estás empezando con el editor, también te conviene repasar la sintaxis básica de PSeInt y la guía de errores comunes para depurar más rápido.

Cómo sacarle provecho a cada atajo

Memorizar cuatro combinaciones es fácil; lo que marca la diferencia es usarlas en el momento justo:

• Depuración rápida con F9: escribe un bloque pequeño de código (tres o cuatro líneas), pulsa F9 y comprueba el resultado antes de seguir. Este ciclo corto de «escribir-probar» evita acumular errores que luego cuesta localizar.
• Comentar para probar hipótesis con Ctrl + D: si sospechas que una línea causa un fallo, coméntala con Ctrl + D y ejecuta de nuevo. Si el error desaparece, ya sabes dónde mirar. Vuelve a pulsar Ctrl + D para recuperar la línea.
• Duplicar estructuras con Ctrl + L: cuando escribas varias líneas parecidas —por ejemplo, una serie de Escribir para un menú—, duplica la primera con Ctrl + L y modifica solo lo necesario. Es más rápido y cometes menos errores de tecleo que escribiendo cada línea desde cero.
• Localizar variables con F3: en programas de más de cincuenta líneas, buscar a mano dónde se asigna una variable es lento y propenso a pasar por alto apariciones. F3 te lleva a cada coincidencia en segundos.

Dónde consultar el listado oficial de tu versión

Como los atajos pueden cambiar entre versiones, la fuente más fiable es tu propia instalación:

1. Los menús del programa: cada opción muestra a su derecha el atajo asignado en tu versión. Es la forma más rápida de descubrir atajos adicionales que aquí no listamos por variar entre versiones.
2. La ayuda integrada (F1): la documentación incluida en PSeInt describe el editor y sus funciones.
3. En el menú Ayuda: encontrarás el acceso a la documentación y, según la versión, información sobre la configuración del entorno.

Si un atajo de la tabla no responde, no asumas que está roto: verifica primero en el menú correspondiente qué combinación usa tu versión. Y si lo que te frena no es el editor sino la sintaxis, la guía de sintaxis básica te ayudará a seguir avanzando.

Preguntas frecuentes

Documentación oficial: pseint.sourceforge.io.

Hay tres instrucciones pequeñas que aparecen en casi todos los programas de PSeInt y que controlan lo que el usuario ve en pantalla: Borrar Pantalla limpia la consola, Esperar Tecla pausa hasta que se pulse una tecla y Esperar introduce una pausa temporizada. Dominarlas marca la diferencia entre un programa que muestra todo de golpe y uno que se presenta con orden.

Borrar Pantalla: limpiar la consola

La instrucción Borrar Pantalla; elimina todo el texto mostrado hasta el momento y deja la consola vacía. Es útil al inicio de un programa, entre secciones o antes de mostrar un resultado importante que no quieres que se pierda entre líneas anteriores.

Proceso MenuLimpio
    Borrar Pantalla;
    Escribir "=== MENÚ PRINCIPAL ===";
    Escribir "1. Sumar";
    Escribir "2. Restar";
    Escribir "3. Salir";
FinProceso

Sin el Borrar Pantalla; inicial, el menú aparecería debajo de cualquier texto previo y el usuario tendría que buscarlo entre el desorden.

Esperar Tecla: pausar hasta que el usuario pulse una tecla

Cuando un programa termina, la ventana de consola suele cerrarse (o el texto se desplaza) antes de que puedas leer el resultado. La solución clásica es Esperar Tecla;: el programa se detiene y continúa solo cuando el usuario pulsa cualquier tecla.

Proceso PausaAlFinal
    Definir nombre Como Caracter;
    Escribir "¿Cómo te llamas?";
    Leer nombre;
    Escribir "Hola, ", nombre, ". ¡Bienvenido!";
    Escribir "Pulsa cualquier tecla para salir...";
    Esperar Tecla;
FinProceso

Colócala siempre después del último Escribir y antes del FinProceso. Es una de las instrucciones más usadas en ejercicios de clase, junto con Leer.

Esperar: pausas temporizadas en segundos y milisegundos

La instrucción Esperar detiene el programa durante un tiempo determinado, sin necesidad de que el usuario haga nada. Admite dos formas:

• Segundos: Esperar 3 Segundos; pausa el programa durante 3 segundos.
• Milisegundos: Esperar 250 Milisegundos; pausa durante un cuarto de segundo.

Proceso CuentaAtras
    Escribir "El programa comenzará en...";
    Esperar 1 Segundos;
    Escribir "3...";
    Esperar 1 Segundos;
    Escribir "2...";
    Esperar 1 Segundos;
    Escribir "1... ¡ya!";
FinProceso

Usa segundos para pausas que el usuario debe percibir (mensajes, cuenta atrás) y milisegundos para pequeños retardos, por ejemplo al animar texto o separar iteraciones de un bucle.

Ejemplo combinado: presentación con ritmo

Proceso Presentacion
    Borrar Pantalla;
    Escribir "Cargando datos...";
    Esperar 2 Segundos;
    Borrar Pantalla;
    Escribir "¡Datos cargados correctamente!";
    Esperar Tecla;
FinProceso

Este patrón —limpiar, mostrar, pausar, limpiar— es la base de menús y presentaciones sencillas. Si quieres controlar si el texto salta de línea o no al mostrarlo, revisa cómo escribir sin saltar de línea.

Errores frecuentes

• Olvidar Esperar Tecla al final: el programa «no muestra nada» porque la consola se cierra antes de que leas el resultado. Casi siempre la causa es esta.
• Confundir segundos y milisegundos: Esperar 500 Segundos; son más de 8 minutos de espera. Revisa siempre la unidad.
• Borrar Pantalla en medio de un bucle sin pausa: el texto parpadea y no se puede leer; añade un Esperar breve entre iteraciones.

Buenas prácticas al presentar información

Estas tres instrucciones rinden más cuando se usan con criterio. Algunas pautas que siguen los docentes:

• No abuses de Borrar Pantalla: si lo usas después de cada mensaje, el usuario no tendrá tiempo de leer nada. Resérvalo para cambios de sección claros: inicio del programa, cambio de menú o antes del resultado final.
• Combina Esperar Tecla con mensajes guía: un Esperar Tecla; sin un Escribir previo que lo anuncie deja al usuario sin saber qué hacer. Avisa siempre («Pulsa una tecla para continuar…»).
• Elige la unidad de tiempo adecuada: para animaciones sencillas (por ejemplo, mostrar puntos suspensivos uno a uno) los milisegundos dan un ritmo natural; para que el usuario lea un mensaje, usa segundos completos.

Proceso AnimacionPuntos
    Definir i Como Entero;
    Escribir "Procesando" Sin Saltar;
    Para i <- 1 Hasta 5 Con Paso 1 Hacer
        Esperar 300 Milisegundos;
        Escribir "." Sin Saltar;
    FinPara
    Escribir "";
    Escribir "¡Listo!";
    Esperar Tecla;
FinProceso

Observa cómo los 300 milisegundos crean una animación de puntos legible sin hacer esperar demasiado. Si quieres dominar la salida de texto, la guía de Escribir sin saltar de línea es el siguiente paso natural.

Preguntas frecuentes

Documentación oficial: pseint.sourceforge.io.

Cuando un programa usa el mismo valor en varias partes —el IVA, el valor de PI, un tope máximo— escribir ese número a mano una y otra vez es una invitación al error: basta cambiarlo en un solo lugar y olvidarlo en otro para que los resultados dejen de cuadrar. Para eso existen las constantes en PSeInt: nombres que representan un valor fijo que no cambia durante la ejecución del programa.

¿Qué es una constante en PSeInt?

Una constante es un identificador asociado a un valor que queda fijado en el momento de la declaración y no puede modificarse después. Si intentas asignarle otro valor más adelante, PSeInt te mostrará un error. Esa es precisamente su utilidad: el compilador te protege de cambiar por accidente un valor que debería permanecer estable.

La diferencia con una variable declarada con Definir es conceptual: la variable está pensada para cambiar (un contador, un acumulador, una lectura del usuario); la constante representa algo que, por definición del problema, es invariable, como un porcentaje de impuesto o una constante matemática.

Cómo declarar una constante: la sintaxis Const

La forma de declarar una constante en PSeInt es la siguiente:

Const IVA <- 0.21;

Observa los elementos:

• Const: la palabra clave que indica que se trata de una constante.
• IVA: el nombre que le das a la constante (por convención, en mayúsculas).
• <-: el operador de asignación, el mismo que se usa con variables.
• 0.21: el valor fijo.
• ;: el punto y coma de fin de instrucción (obligatorio según tu perfil de lenguaje).

Constantes vs variables: diferencias clave

Ejemplos prácticos

Ejemplo 1: la constante PI

Proceso AreaCirculo
    Const PI <- 3.1416;
    Definir radio, area Como Real;
    Escribir "Ingrese el radio del círculo:";
    Leer radio;
    area <- PI * radio * radio;
    Escribir "El área es: ", area;
FinProceso

Si mañana quisieras más precisión, cambiarías el valor en un solo lugar y todo el programa usaría el nuevo valor.

Ejemplo 2: el IVA en una factura

Proceso FacturaConIVA
    Const IVA <- 0.21;
    Definir precio, total Como Real;
    Escribir "Ingrese el precio sin IVA:";
    Leer precio;
    total <- precio * (1 + IVA);
    Escribir "Total con IVA: ", total;
FinProceso

El 0.21 aparece una sola vez, con un nombre que explica qué significa. Quien lea el código entiende inmediatamente la fórmula.

¿Cuándo conviene usar constantes?

• Valores que se repiten en varias partes del programa (tasas, porcentajes, topes).
• Constantes matemáticas o físicas (PI, velocidad de la luz en un ejercicio, etc.).
• Textos fijos que se muestran varias veces, como el nombre del programa.
• Cualquier número «mágico»: si un valor aparece suelto en el código sin explicación, casi siempre merece ser una constante con nombre.

En cambio, no uses constantes para valores que el usuario ingresa, para contadores o para resultados intermedios: esos son variables por naturaleza. Si aún no dominas la declaración de variables, repasa cómo usar Definir y los tipos de datos de PSeInt.

Errores frecuentes con Const

• Intentar reasignar la constante: IVA <- 0.10; después de declararla produce un error. Si el valor puede cambiar, usa una variable.
• Usarla antes de declararla: declara tus constantes al inicio del proceso, antes de cualquier instrucción que las utilice.
• Confundir el perfil de lenguaje: si el punto y coma te da problemas, revisa si estás en perfil flexible o estricto; tienes más detalles en la guía de errores comunes.

Preguntas frecuentes

Documentación oficial del lenguaje: pseint.sourceforge.io.

Actualizado: Octubre 2026

Para-Hasta en PSeInt: Sintaxis con Paso (2026)

Para…Hasta es el bucle con contador de PSeInt: repite un bloque un número conocido de veces, con una variable que avanza automáticamente desde un valor inicial hasta un límite. Es la estructura más clara cuando sabes de antemano cuántas repeticiones necesitas.

Sintaxis

Para variable <- inicial Hasta limite Con Paso paso Hacer
    // instrucciones que se repiten
FinPara

• variable: el contador (típicamente i); debe estar definido como Entero.
• inicial: valor con el que empieza el contador.
• limite: valor hasta el que llega (inclusive).
• Con Paso: cuánto avanza el contador en cada vuelta. Si lo omites, el paso es 1 (confírmalo en la ayuda integrada de tu perfil).

Para contar hacia atrás usa un paso negativo:

Para i <- 10 Hasta 1 Con Paso -1 Hacer
    Escribir i
FinPara

Ejemplo completo

Tabla de multiplicar del número que pida el usuario:

Algoritmo TablaDeMultiplicar
    Definir i, n Como Entero
    Escribir Sin Saltar '¿Qué tabla quieres ver? '
    Leer n
    Para i <- 1 Hasta 10 Con Paso 1 Hacer
        Escribir n, ' x ', i, ' = ', n * i
    FinPara
FinAlgoritmo

Con n = 3, la salida muestra 3 x 1 = 3 hasta 3 x 10 = 30. El contador i avanza solo: no necesitas incrementarlo dentro del cuerpo.

Errores comunes

• Paso igual a cero: el contador no avanza y el bucle no termina. El paso debe ser distinto de cero.
• Límites invertidos sin paso negativo: Para i <- 10 Hasta 1 con paso positivo no ejecuta ninguna vuelta; para descender usa Con Paso -1.
• Modificar el contador dentro del cuerpo: es una mala práctica que produce resultados impredecibles; deja que el Para gestione el contador.

Preguntas frecuentes

Actualizado: Octubre 2026

Repetir Hasta Que en PSeInt: Sintaxis (2026)

Repetir…Hasta Que es el bucle con condición final de PSeInt: ejecuta el bloque de instrucciones y después comprueba la condición. Por eso el cuerpo se ejecuta al menos una vez, aunque la condición ya se cumpla desde el principio.

Sintaxis

Repetir
    // instrucciones que se repiten
Hasta Que condicion

La lógica es la inversa de Mientras: el bucle se repite mientras la condición sea falsa y sale cuando la condición se vuelve verdadera.

Es la estructura ideal para «pedir un dato hasta que sea válido»: muestras el mensaje, lees el dato y repites hasta que cumpla la condición.

Ejemplo completo

Pide un número hasta que el usuario escriba uno positivo:

Algoritmo PedirPositivo
    Definir n Como Entero
    Repetir
        Escribir Sin Saltar 'Escribe un número positivo: '
        Leer n
    Hasta Que n > 0
    Escribir 'Gracias. Escribiste: ', n
FinAlgoritmo

Si el usuario escribe -3, la condición n > 0 es falsa y el bucle repite; cuando escribe 7, la condición es verdadera y el programa sale mostrando Gracias. Escribiste: 7. El mensaje se mostró al menos una vez en todos los casos.

Errores comunes

• Confundir la lógica de salida: en Repetir se sale cuando la condición es Verdadera (al revés que en Mientras). Hasta Que n > 0 significa «repite hasta conseguir un positivo».
• Olvidar que el cuerpo corre mínimo una vez: si necesitas cero ejecuciones posibles, usa Mientras.
• No actualizar la variable de la condición dentro del cuerpo: sin un Leer o una asignación que la cambie, el bucle no termina.

Preguntas frecuentes

Actualizado: Octubre 2026

Mientras en PSeInt: Sintaxis (2026)

Mientras es el bucle con condición inicial de PSeInt: repite un bloque de instrucciones mientras una condición sea Verdadera. La condición se evalúa antes de cada repetición, por lo que si es falsa desde el principio, el cuerpo no se ejecuta ni una sola vez.

Sintaxis

Mientras condicion Hacer
    // instrucciones que se repiten
FinMientras

En cada vuelta, PSeInt evalúa la condición: si es Verdadera, ejecuta el cuerpo y vuelve a comprobar; si es Falsa, sale del bucle y continúa después del FinMientras.

La condición suele comparar una variable que el propio cuerpo modifica (un contador, un acumulador). Si nada cambia la condición dentro del cuerpo, el bucle no terminará nunca: es el temido bucle infinito.

Ejemplo completo

Contador del 1 al 5. Sigue mentalmente el valor de i en cada vuelta:

Algoritmo ContarHastaCinco
    Definir i Como Entero
    i <- 1
    Mientras i <= 5 Hacer
        Escribir 'i vale: ', i
        i <- i + 1
    FinMientras
    Escribir 'Fin del bucle.'
FinAlgoritmo

La salida muestra i vale: 1 hasta i vale: 5 y luego Fin del bucle.. En la sexta comprobación, i vale 6, la condición i <= 5 es falsa y el bucle termina. Sin la línea i <- i + 1, el programa no saldría nunca del bucle.

Errores comunes

• Bucle infinito: olvidar modificar la variable de la condición dentro del cuerpo (por ejemplo, no incrementar el contador).
• Condición falsa desde el inicio: si inicializas mal la variable, el cuerpo no se ejecuta ninguna vez y parece que el programa «no hace nada».
• Olvidar el FinMientras que cierra el bucle.

Preguntas frecuentes

Actualizado: Octubre 2026

Según en PSeInt: Sintaxis y Ejemplos (2026)

Según es la instrucción de selección múltiple de PSeInt: evalúa una expresión una sola vez y la compara con una lista de casos, ejecutando el bloque del caso que coincida. Es la alternativa limpia a encadenar muchos Si cuando comparas una misma variable con varios valores fijos.

Sintaxis

Segun expresion Hacer
    valor1:
        // instrucciones si coincide con valor1
    valor2:
        // instrucciones si coincide con valor2
    De Otro Modo:
        // instrucciones si ningún caso coincide
FinSegun

Cada caso se escribe con su valor seguido de dos puntos. El bloque De Otro Modo es opcional: se ejecuta cuando ningún caso coincide con la expresión.

Ejemplo completo

Programa que muestra el día de la semana según un número del 1 al 7:

Algoritmo DiaSemana
    Definir dia Como Entero
    Escribir Sin Saltar 'Escribe un número del 1 al 7: '
    Leer dia
    Segun dia Hacer
        1:
            Escribir 'Lunes'
        2:
            Escribir 'Martes'
        3:
            Escribir 'Miércoles'
        De Otro Modo:
            Escribir 'Número fuera de rango'
    FinSegun
FinAlgoritmo

Con 2 muestra Martes; con 9 ningún caso coincide y se ejecuta el bloque De Otro Modo: Número fuera de rango.

Errores comunes

• Expresión de tipo no permitido (error 205): la expresión debe ser numérica o de tipo caracter; revisa el tipo de la variable.
• Olvidar los dos puntos después de cada valor de caso: sin ellos hay error de sintaxis.
• Olvidar el FinSegun que cierra la estructura.

Preguntas frecuentes

Actualizado: Octubre 2026

Si-Entonces en PSeInt: Sintaxis (2026)

Si-Entonces es la instrucción condicional de PSeInt: permite que el programa tome decisiones. Evalúa una condición lógica y ejecuta un bloque de instrucciones u otro según el resultado sea Verdadero o Falso.

Sintaxis

Si condicion Entonces
    // instrucciones si la condición es Verdadera
SiNo
    // instrucciones si la condición es Falsa
FinSi

La condición es una expresión lógica: una comparación (edad >= 18), una variable lógica o varias condiciones combinadas con Y, O y NO.

El bloque SiNo es opcional: si lo omites y la condición es falsa, el programa simplemente continúa después del FinSi.

Los bloques Si pueden anidarse: dentro de un Si puede haber otro Si completo, cada uno con su propio FinSi.

Ejemplo completo

Programa que decide si una persona es mayor de edad:

Algoritmo MayorDeEdad
    Definir edad Como Entero
    Escribir Sin Saltar 'Escribe tu edad: '
    Leer edad
    Si edad >= 18 Entonces
        Escribir 'Eres mayor de edad.'
    SiNo
        Escribir 'Eres menor de edad.'
    FinSi
FinAlgoritmo

Con edad 20 muestra Eres mayor de edad.; con 15 muestra Eres menor de edad.. La condición edad >= 18 devuelve Verdadero o Falso y el programa elige el bloque correspondiente.

Errores comunes

• Olvidar el FinSi: cada Si necesita su cierre; sin él, PSeInt marca error de sintaxis.
• Usar <- en lugar de = en la condición: Si x <- 5 Entonces es incorrecto; para comparar se usa Si x = 5 Entonces.
• Condiciones que no devuelven un valor lógico: la condición debe evaluarse a Verdadero o Falso (una comparación o una variable lógica).

Preguntas frecuentes

Comentarios en PSeInt: Sintaxis // (2026)

Un buen programa no solo funciona: también se entiende. Los comentarios son notas que escribes dentro del código para explicar qué hace cada parte, y que PSeInt ignora al ejecutar el programa. En PSeInt los comentarios se escriben con doble barra (//): todo lo que sigue a // en una línea es un comentario. En esta guía verás la sintaxis exacta y cómo usarlos para documentar tus algoritmos.

Sintaxis

// Esto es un comentario de línea completa
x <- 5  // Esto es un comentario al final de una instrucción

// Para comentar varias líneas,
// se repite // al inicio de cada una

La doble barra puede ir al inicio de una línea (toda la línea es comentario) o después de una instrucción (solo el final de la línea es comentario). PSeInt no ejecuta nada de lo que esté comentado.

Explicación

• // comenta hasta el fin de la línea. Todo lo que escribas después de la doble barra en esa línea es ignorado por PSeInt. Es la única sintaxis de comentario: siempre es por línea.
• Dos posiciones habituales. Puedes usar una línea completa para explicar un bloque (// Calcula el promedio de las notas) o un comentario corto al final de una instrucción (suma <- 0 // inicializa el acumulador).
• Para varias líneas, repite //. No existe un comentario de bloque que abarque varios párrafos: cada línea que quieras comentar debe empezar con su propia doble barra.
• No afectan la ejecución. Puedes agregar, quitar o modificar comentarios sin que el programa cambie su comportamiento. Son solo para las personas que leen el código: tú en el futuro, tu profesor o tus compañeros.
• Úsalos para explicar el «por qué». Un buen comentario no repite lo obvio (// suma a y b junto a suma <- a + b aporta poco); explica la intención (// acumula para calcular el promedio al final).
• También sirven para desactivar código. Si quieres probar el programa sin una línea, la comentas con // en lugar de borrarla; así la recuperas fácilmente cuando la necesites.

Ejemplo completo

Este programa calcula el promedio de 3 notas usando comentarios explicativos en los puntos clave:

Algoritmo Promedio_Con_Comentarios
    // Declaración de variables: 3 notas y el promedio
    Definir n1, n2, n3, promedio Como Real

    // Entrada de datos: se piden las 3 notas al usuario
    Escribir "Ingresa la primera nota:"
    Leer n1
    Escribir "Ingresa la segunda nota:"
    Leer n2
    Escribir "Ingresa la tercera nota:"
    Leer n3

    // Proceso: se calcula el promedio de las 3 notas
    promedio <- (n1 + n2 + n3) / 3

    // Salida: se muestra el resultado
    Escribir "El promedio es: ", promedio
FinAlgoritmo

Observa cómo los comentarios dividen el programa en sus tres etapas clásicas —entrada, proceso y salida— y cada etapa queda claramente identificada. Si dentro de seis meses vuelves a este código, entenderás su estructura de un vistazo.

Errores comunes

• Usar otra sintaxis de comentario. Ni #, ni /* */, ni <!-- --> son comentarios en PSeInt. Solo la doble barra // funciona.
• Comentar código y olvidar que sigue comentado. Si desactivaste una línea con // para una prueba, recuerda quitar las barras cuando quieras que vuelva a ejecutarse.
• Comentar en exceso lo obvio. Llenar cada línea de comentarios que repiten el código (// lee n junto a Leer n) dificulta la lectura en lugar de ayudar. Comenta los bloques y las decisiones importantes.

Ver también

• Sintaxis de PSeInt: guía completa
• ¿Qué es PSeInt?
• Ejercicios resueltos de PSeInt
• SubProceso en PSeInt: sintaxis y Por Referencia
• Dimension en PSeInt: arreglos sintaxis
• Punto y coma en PSeInt: ¿obligatorio u opcional?

Preguntas frecuentes

Actualizado: Octubre 2026

Operadores en PSeInt: Aritméticos, Relacionales y Lógicos (2026)

Los operadores son los símbolos con los que PSeInt calcula, compara y combina valores. Se agrupan en cuatro familias: aritméticos (cálculos), relacionales (comparaciones), lógicos (combinar condiciones) y el operador de asignación.

Operadores aritméticos

Dos detalles importantes:

• La división / siempre devuelve decimales: 7 / 2 = 3.5.
• MOD calcula el resto: 7 MOD 2 = 1. Sirve, por ejemplo, para saber si un número es par (n MOD 2 = 0).
• ^ es la potencia: 2 ^ 3 = 8.

Operadores relacionales y lógicos

Las comparaciones devuelven Verdadero o Falso. Ojo: en PSeInt la igualdad se escribe con un solo =.

Ejemplo: (edad >= 18) Y (tieneEntrada = Verdadero) solo es Verdadero si se cumplen las dos condiciones.

Asignación: <-

El operador <- guarda un valor en una variable. Se lee de derecha a izquierda: primero se evalúa la expresión de la derecha y el resultado se almacena en la variable de la izquierda.

edad <- 20
promedio <- (nota1 + nota2) / 2

Ejemplo completo

Programa que ejercita las cuatro familias de operadores:

Algoritmo OperadoresDemo
    Definir a, b Como Entero
    Definir resultado Como Real
    Definir esPar, aprobado Como Logico
    a <- 7
    b <- 2
    resultado <- a / b
    Escribir '7 / 2 = ', resultado
    Escribir '7 MOD 2 = ', a MOD b
    esPar <- (a MOD 2 = 0)
    Escribir '¿7 es par? ', esPar
    aprobado <- (a >= 6) Y (b > 0)
    Escribir '¿Aprobado? ', aprobado
FinAlgoritmo

La salida será: 7 / 2 = 3.5, 7 MOD 2 = 1, ¿7 es par? Falso (porque 7 MOD 2 = 1, y 1 = 0 es falso) y ¿Aprobado? Verdadero (7 ≥ 6 y 2 > 0 se cumplen).

Errores comunes

• Usar = para asignar: la asignación es <-; el = solo sirve para comparar. x = 5 pregunta si x vale 5, no le asigna nada.
• Escribir == (como en otros lenguajes): en PSeInt no existe; la igualdad es un solo =.
• Olvidar paréntesis en condiciones compuestas: NO a = b Y c > 0 puede no evaluarse como esperas; escríbelo con paréntesis.

Preguntas frecuentes