Tipos numéricos

En programación, los tipos numéricos son fundamentales para representar valores cuantitativos en los algoritmos. En PseInt, se manejan principalmente dos tipos numéricos: enteros y reales.

Los enteros (tipo entero) son números sin parte decimal, utilizados para contar o enumerar elementos. Por ejemplo, el número de estudiantes en una clase o la puntuación en un juego.

Algoritmo EjemploEntero
    Definir edad Como Entero  // Declaración de una variable entera
    edad <- 25                // Asignación de un valor entero
    Escribir "La edad es: ", edad
FinAlgoritmo

En Python, el tipo entero se utiliza de manera similar:

# Declaración y asignación de una variable entera
edad = 25

Los reales (tipo real) representan números con parte decimal, adecuados para cálculos que requieren mayor precisión, como medidas o cálculos científicos.

Algoritmo EjemploReal
    Definir temperatura Como Real    // Declaración de una variable real
    temperatura <- 36.6              // Asignación de un valor real
    Escribir "La temperatura es: ", temperatura
FinAlgoritmo

En Python, los números con decimales se denominan float:

# Declaración y asignación de una variable real (float)
temperatura = 36.6

Es importante tener en cuenta la distinción entre estos tipos numéricos, ya que las operaciones y el consumo de recursos pueden variar. Por ejemplo, al realizar una división entre dos enteros, el resultado en PseInt será un real si hay decimales:

Algoritmo DivisionPSeInt
    Definir resultado Como Real
    resultado <- 5 / 2  // resultado será 2.5
    Escribir "El resultado de 5/2 es: ", resultado
FinAlgoritmo

En Python, dependiendo de la división, el resultado también puede ser un float:

# División de enteros con resultado float
resultado = 5 / 2  # resultado es 2.5

Si se desea una división entera sin decimales, se puede utilizar la división entera en Python:

# División entera sin decimales
resultado = 5 // 2  # resultado es 2

En PseInt, para obtener una división entera, se puede convertir el resultado a entero o utilizar funciones específicas.

El uso correcto de los tipos numéricos garantiza la precisión y eficiencia en los algoritmos. Además, al declarar variables numéricas en PseInt, es recomendable ser explícito con el tipo para evitar errores:

Algoritmo TiposNumericosEjemplo
    Definir contador Como Entero
    Definir promedio Como Real

    contador <- 10
    promedio <- 4.5

    Escribir "Contador: ", contador
    Escribir "Promedio: ", promedio
FinAlgoritmo

Las operaciones aritméticas básicas (suma, resta, multiplicación y división) se aplican a los tipos numéricos. Por ejemplo:

Algoritmo SumaEnteros
    Definir a, b, suma Como Entero
    a <- 10
    b <- 20
    suma <- a + b  // suma es 30
    Escribir "La suma es: ", suma
FinAlgoritmo

En Python:

a = 10
b = 20
suma = a + b  # suma es 30

Es esencial comprender los límites de los tipos numéricos. En PseInt, al ser una herramienta educativa, estos límites no suelen ser un problema, pero en lenguajes como Python, los enteros pueden ser de tamaño arbitrario, mientras que los reales (float) tienen precisión limitada.

Tipos booleanos

En programación, los tipos booleanos son esenciales para manejar condiciones y expresiones lógicas que determinan el flujo de un algoritmo. En PseInt, el tipo lógico representa valores de verdad: Verdadero o Falso.

Para declarar una variable booleana en PseInt, se utiliza el tipo lógico:

Algoritmo EjemploBooleano
    Definir esMayorDeEdad Como Logico   // Declaración de una variable booleana
    esMayorDeEdad <- Verdadero         // Asignación de un valor booleano
FinAlgoritmo

En Python, el tipo booleano es bool, y utiliza los valores True y False:

# Declaración y asignación de una variable booleana
es_mayor_de_edad = True

Las variables booleanas son fundamentales en las estructuras de control como condicionales y bucles, permitiendo que el programa tome decisiones basadas en condiciones. Por ejemplo:

    Si esMayorDeEdad Entonces
        Escribir "Acceso permitido"
    Sino
        Escribir "Acceso denegado"
    FinSi

En Python, el equivalente es:

if es_mayor_de_edad:
    print("Acceso permitido")
else:
    print("Acceso denegado")

Los operadores lógicos son herramientas para combinar expresiones booleanas y generar nuevas condiciones. 

• y (AND): Devuelve Verdadero solo si ambas condiciones son Verdadero.
• o (OR): Devuelve Verdadero si al menos una condición es Verdadero.
• no (NOT): Invierte el valor lógico de la condición (convierte Verdadero en Falso y viceversa).

Algoritmo EjemploLogico
    Definir esMayorDeEdad, tienePermiso Como Logico
    esMayorDeEdad <- Verdadero
    tienePermiso  <- Verdadero

    Si esMayorDeEdad y tienePermiso Entonces
        Escribir "Puede conducir"
    Sino
        Escribir "No puede conducir"
    FinSi
FinAlgoritmo

En Python:

tiene_permiso = True

if es_mayor_de_edad and tiene_permiso:
    print("Puede conducir")
else:
    print("No puede conducir")

Las expresiones comparativas generan resultados booleanos al comparar valores numéricos o de texto. Por ejemplo:

Algoritmo ComparacionEdad
    Definir edad Como Entero
    Definir esMayorDeEdad Como Logico

    edad <- 20
    esMayorDeEdad <- (edad >= 18)

    Si esMayorDeEdad Entonces
        Escribir "Mayor de edad"
    Sino
        Escribir "Menor de edad"
    FinSi
FinAlgoritmo

En Python, la asignación es similar:

edad = 20
es_mayor_de_edad = edad >= 18

Es importante recordar que en PseInt, las constantes booleanas Verdadero y Falso deben escribirse con la primera letra en mayúscula. Esto asegura que el intérprete reconozca correctamente los valores lógicos.

Los operadores lógicos permiten crear condiciones complejas:

• Y (and): La expresión es Verdadero solo si ambas condiciones son Verdadero.
• O (or): La expresión es Verdadero si al menos una condición es Verdadero.
• No (not): Invierte el valor lógico de la condición.

Por ejemplo, para verificar si un número está dentro de un rango:

Algoritmo VerificarRango
    Definir numero Como Entero

    numero <- 15

    Si numero >= 10 y numero <= 20 Entonces
        Escribir "El número está entre 10 y 20"
    Sino
        Escribir "El número está fuera del rango"
    FinSi
FinAlgoritmo

En Python:

numero = 15

if numero >= 10 and numero <= 20:
    print("El número está entre 10 y 20")
else:
    print("El número está fuera del rango")

Las variables booleanas también son útiles para controlar la ejecución de bucles, permitiendo detener la iteración bajo ciertas condiciones:

Algoritmo EjemploBucleBooleano
    Definir continuar Como Logico
    continuar <- Verdadero

    Mientras continuar Hacer
        Escribir "Ejecutando el bucle..."
        continuar <- Falso   // Actualizar la condición para salir del bucle
    FinMientras
FinAlgoritmo

En Python:

continuar = True

while continuar:
    print("Ejecutando el bucle...")
    # Actualizar la condición para salir del bucle
    continuar = False

El uso adecuado de los tipos booleanos es crucial para implementar lógica condicional y control de flujo en los programas. Comprender cómo funcionan las variables lógicas y los operadores asociados permite desarrollar algoritmos más eficientes y robustos.

Tipos texto

En programación, los tipos texto son fundamentales para manipular y almacenar cadenas de caracteres, como palabras, frases o cualquier conjunto de símbolos alfanuméricos. En PseInt, se utiliza el tipo carácter para manejar datos de texto.

Para declarar una variable de tipo texto en PseInt, se emplea el tipo caracter:

Algoritmo EjemploTexto
    Definir nombre Como Caracter   // Declaración de una variable de texto
    nombre <- "Juan Pérez"         // Asignación de un valor textual
    Escribir "El nombre es: ", nombre
FinAlgoritmo

En Python, las cadenas de texto se manejan utilizando el tipo str:

# Declaración y asignación de una cadena de texto
nombre = "Juan Pérez"

Las variables de tipo texto permiten almacenar información textual y realizar operaciones como concatenación, extracción de subcadenas y transformación de caracteres. Por ejemplo, para concatenar cadenas en PseInt, se utiliza el operador + o se pueden simplemente unir:

Algoritmo ConcatenarTexto
    Definir saludo, nombre, nombreCompleto Como Caracter
    saludo <- "Hola"
    nombre <- "Juan Pérez"
    
    // Concatenación usando +
    nombreCompleto <- saludo + " " + nombre
    Escribir "El saludo completo es: ", nombreCompleto
FinAlgoritmo

En Python, la concatenación de cadenas también se realiza con el operador +:

saludo = "Hola"
nombre_completo = saludo + " " + nombre  # Resultado: "Hola Juan Pérez"

Es importante manejar correctamente las comillas al asignar valores textuales. En PseInt, las cadenas se encierran entre comillas dobles " ", al igual que en Python.

Para ingresar datos de texto proporcionados por el usuario en PseInt, se utiliza la instrucción Leer:

Algoritmo EntradaTexto
    Definir ciudad Como Caracter
    Escribir "Introduce tu ciudad:"
    Leer ciudad
    Escribir "La ciudad ingresada es: ", ciudad
FinAlgoritmo

En Python, se utiliza la función input() para obtener datos del usuario:

# Entrada de datos de texto
ciudad = input("Introduce tu ciudad: ")
print("La ciudad ingresada es: " + ciudad)

Las cadenas de texto pueden manipularse mediante diversas funciones y operaciones. Por ejemplo, para obtener la longitud de una cadena en PseInt, se utiliza la función Longitud():

Algoritmo LongitudCadena
    Definir nombre Como Caracter
    Definir longitudNombre Como Entero

    nombre <- "Juan Pérez"
    longitudNombre <- Longitud(nombre)  // Devuelve la cantidad de caracteres

    Escribir "El nombre tiene ", ConvertirATexto(longitudNombre), " caracteres."
FinAlgoritmo

En Python, se utiliza la función len() para obtener la longitud de una cadena:

longitud_nombre = len(nombre)  # Obtiene la cantidad de caracteres en 'nombre'
print("El nombre tiene " + str(longitud_nombre) + " caracteres.")

Para extraer una subcadena, PseInt ofrece la función SubCadena(), que permite obtener una parte específica de la cadena:

Algoritmo SubcadenaTexto
    Definir nombre, iniciales Como Caracter
    nombre <- "Juan Pérez"
    // Extrae desde la posición 1 hasta la 4
    iniciales <- SubCadena(nombre, 1, 4)  
    Escribir "Las primeras letras son: ", iniciales
FinAlgoritmo

En Python, se utilizan los operadores de slicing para extraer subcadenas:

iniciales = nombre[0:4]  # Extrae desde el índice 0 hasta el 3
print("Las primeras letras son: " + iniciales)

Es relevante destacar que en Python, los índices comienzan en 0, mientras que en PseInt, el conteo de posiciones inicia en 1. Esta diferencia es clave al manipular cadenas de texto entre ambos lenguajes.

Las operaciones de comparación entre cadenas permiten evaluar si dos textos son iguales o determinar su orden alfabético:

Algoritmo CompararCadenas
    Definir nombre Como Caracter
    nombre <- "Juan Pérez"

    Si nombre = "Juan Pérez" Entonces
        Escribir "El nombre coincide."
    Sino
        Escribir "Nombre diferente."
    FinSi
FinAlgoritmo

En Python:

if nombre == "Juan Pérez":
    print("El nombre coincide.")
else:
    print("Nombre diferente.")

En PSeInt, se emplean las funciones ConvertirATexto() y ConvertirANumero() para transformar números a texto y texto a números, respectivamente.

Algoritmo ConversionTextoNumero
    Definir edad Como Entero
    Definir edadTexto Como Caracter

    edad <- 30
    edadTexto <- ConvertirATexto(edad)
    Escribir "Tienes ", edadTexto, " años."

    Definir numeroTexto Como Caracter
    Definir numeroReal Como Real

    numeroTexto <- "45.67"
    numeroReal <- ConvertirANumero(numeroTexto)
    Escribir "El número es: ", numeroReal
FinAlgoritmo

En Python, se emplea la función str() para convertir números a cadenas:

edad = 30
edad_texto = str(edad)
print("Tienes " + edad_texto + " años.")

En Python, se puede utilizar int() o float() dependiendo del tipo numérico:

numero_texto = "45.67"
numero = float(numero_texto)
print("El número es:", numero)

Los caracteres especiales y el manejo de mayúsculas y minúsculas son aspectos importantes. En PseInt, se pueden utilizar funciones como Mayusculas() y Minusculas() para transformar el texto:

Algoritmo TransformarMayusculas
    Definir nombre, nombreMayus Como Caracter
    nombre <- "Juan Pérez"
    nombreMayus <- Mayusculas(nombre)
    Escribir "Nombre en mayúsculas: ", nombreMayus
FinAlgoritmo

En Python, los métodos upper() y lower() realizan estas transformaciones:

nombre_mayus = nombre.upper()
print("Nombre en mayúsculas: " + nombre_mayus)

Entender las similitudes y diferencias entre PseInt y Python en el manejo de textos permite al programador trasladar sus conocimientos de pseudocódigo a lenguajes de programación reales con mayor facilidad.

Los tipos texto son esenciales para la manipulación de cadenas y requieren un buen dominio de las funciones y operaciones disponibles en el lenguaje utilizado. Practicar con ejemplos concretos fortalece la comprensión y habilidad para desarrollar algoritmos que involucren procesamiento textual.