EL ALGORITMO Y SUS EJEMPLOS

ALGORITMOS

DEFINICIÓN: Un Algoritmo, se puede definir como una secuencia de instrucciones que representan un modelo de solución para determinado tipo de problemas. O bien como un conjunto de instrucciones que realizadas en orden conducen a obtener la solución de un problema. Por lo tanto podemos decir que es un conjunto ordenado y finito de pasos que nos permite solucionar un problema.

Los algoritmos son independientes de los lenguajes de programación. En cada problema el algoritmo puede escribirse y luego ejecutarse en un lenguaje de diferente programación. El algoritmo es la infraestructura de cualquier solución, escrita luego en cualquier lenguaje de programación.

Programa: Un programa es una serie de instrucciones ordenadas, codificadas en lenguaje de programación que expresa un algoritmo y que puede ser ejecutado en un computador.

CLASIFICACIÓN DE ALGORITMOS: Los algoritmos se pueden clasificar en cuatro tipos:

• Algoritmo computacional: Es un algoritmo que puede ser ejecutado en una computadora. Ejemplo: Fórmula aplicada para un cálculo de la raíz cuadrada de un valor x.
• Algoritmo no computacional: Es un algoritmo que no requiere de una computadora para ser ejecutado. Ejemplo: Instalación de un equipo de sonido.
• Algoritmo cualitativo: Un algoritmo es cualitativo cuando en sus pasos o instrucciones no están involucrados cálculos numéricos. Ejemplos: Las instrucciones para desarrollar una actividad física, encontrar un tesoro.
• Algoritmo cuantitativo: Una algoritmo es cuantitativo cuando en sus pasos o instrucciones involucran cálculos numéricos. Ejemplo: Solución de una ecuación de segundo grado.

CARACTERÍSTICAS DE UN ALGORITMO: Todo algoritmo debe tener las siguientes características:

• 1. Debe ser Preciso, porque cada uno de sus pasos debe indicar de manera precisa e inequívoca que se debe hacer.
  2. Debe ser Finito, porque un algoritmo debe tener un número limitado de pasos.
  3. Debe ser Definido, porque debe producir los mismos resultados para las mismas condiciones de entrada.
  4. Puede tener cero o más elementos de entrada.
  5. Debe producir un resultado. Los datos de salida serán los resultados de efectuar las instrucciones.

PARTES DE UN ALGORITMO: Todo Algoritmo debe tener las siguientes partes:

· Entrada de datos, son los datos necesarios que el algoritmo necesita para ser ejecutado.
· Proceso, es la secuencia de pasos para ejecutar el algoritmo.
· Salida de resultados, son los datos obtenidos después de la ejecución del algoritmo.

TÉCNICAS DE REPRESENTACIÓN: Para la representación de un algoritmo, antes de ser convertido a lenguaje de programación, se utilizan algunos métodos de representación escrita, gráfica o matemática. Los métodos más conocidos son:

· Diagramación libre (Diagramas de flujo).
· Diagramas Nassi-Shneiderman.
· Pseudocódigo.
· Lenguaje natural (español, inglés, etc.).
· Fórmulas matemáticas.

EJEMPLOS DE ALGORITMOS

En esta sección puede observar ejemplos de pseudocódigos válidos en PSeInt, así como también sus correspondientes diagramas de flujo (en cualquiera de las tres formas soportadas). Recuerde que el lenguaje de PSeInt puede adaptarse a diferentes perfiles. A modo de ejemplo se incluyen los algoritmos para dos perfiles diferentes, uno con reglas flexibles, y otro con reglas estrictas.

Suma: Este es el ejemplo más simple. Muestra cómo cargar dos números de dos variables, calcular la suma de los mismos y mostrarla en pantalla

// este es el ejemplo más simple de esta ayuda, 
// toma dos numeros, los suma y muestra el resultado

Proceso Suma


    // para cargar un dato, se le muestra un mensaje al usuario
    // con la instrucción Escribir, y luego se lee el dato en 
    // una variable (A para el primero, B para el segundo) con 
    // la instrucción Leer

    Escribir "Ingrese el primer numero:"
    Leer A

    Escribir "Ingrese el segundo numero:"
    Leer B


    // ahora se calcula la suma y se guarda el resultado en la
    // variable C mediante la asignación (<-)
    
    C <- A+B


    // finalmente, se muestra el resultado, precedido de un 
    // mensaje para avisar al usuario, todo en una sola
    // instrucción Escribir
    
    Escribir "El resultado es: ",C

FinProceso

Mayores: Busca los dos mayores de una lista de N datos

// Busca los dos mayores de una lista de N datos

Proceso Mayores

    // primero se declara un arreglo de 200 elementos
    Dimension datos[200]
    
    // luego se pide al usuario ingresar la cantidad de datos, 
    // que no debera ser mayor a 200
    Escribir "Ingrese la cantidad de datos (de 2 a 200):"
    Leer n
    
    // se leen uno por uno los 200 datos y se los guarda en el arreglo
    Para i<-1 Hasta n Hacer
        Escribir "Ingrese el dato ",i,":"
        Leer datos[i]
    FinPara

    // se comparan los dos primeros y se toman como may1 (el mayor de los
    // dos) y may2 (el segundo mayor).
    Si datos[1]>datos[2] Entonces
        may1<-datos[1]
        may2<-datos[2]
    Sino
        may1<-datos[2]
        may2<-datos[1]
    FinSi
    // se recorren los demas elementos buscan si hay alguno mayor que may1 o may2
    Para i<-3 Hasta n Hacer
        Si datos[i]>may1 Entonces // si hay un valor mayor que may1
            may2<-may1 // como may1 era el más grande, pasa a estar en segundo lugar
            may1<-datos[i] // y el nuevo dato toma el primer puesto (mayor de todos)
        Sino // si no era mas grande que may1, todavia puede ser mas grande que may2
            Si datos[i]>may2 Entonces // si supera al segundo mayor que teniamos
                may2<-datos[i] // se lo guarda como segundo mayor
            FinSi
        FinSi
    FinPara
    
    // se muestran los resultados
    Escribir "El mayor es: ",may1
    Escribir "El segundo mayor es: ",may2
    
FinProceso

Coloquial: En este ejemplo se muestran algunas de las variantes que se pueden utilizar con el perfil de lenguaje Flexible para que el pseudocódigo se asemeje más al lenguaje coloquial

// Este ejemplo muestra algunas de las variaciones posibles cuando se utiliza
// syntaxis flexible, instrucciones adicionales, y expresiones en lenguaje
// coloquial para las condiciones.

Proceso sin_titulo
    
    Definir a, b Como Entero
    
    Imprimir "Ingrese 3 numeros (los dos primeros deben ser enteros):"
    Leer a b c
    
    Si a Es Mayor Que b Y a Es Mayor Que c Entonces
        Escribir a " es el mayor"
    sino 
        Si b Es Mayor Que c Entonces
            Escribir b " es el mayor"
        Sino
            Escribir c " es el mayor"
        FinSi
    FinSi

    
    Mostrar "Pulse una tecla para continuar"
    Esperar Tecla
    Limpiar Pantalla
    
    Si a Es Par
        Escribir a " es par"
    Sino
        Escribir a " es impar"
    FinSi
    
    Escribir Sin Bajar "Los divisores de " b " son: "
    Para i Desde 1 Hasta b-1
        Si b Es Multiplo De i
            Escribir sin bajar i " "
        Fin Si
    Fin Para
    Escribir b
    
    Si c Es Entero 
        Mostrar C " es entero"
    Sino
        Mostrar C " es real"
    FinSi
    
FinProceso





Subprocesos: Ejemplo básico que ilustra la sintaxis para declarar e invocar nuevas funciones en pseudocódigo



// funcion que no recibe ni devuelve nada
SubProceso Saludar
    Escribir "Hola mundo!"
FinSubProceso

// funcion que recibe un argumento por valor, y devuelve su doble
SubProceso res <- CalcularDoble(num) 
    res <- num*2 // retorna el doble
FinSubProceso

// funcion que recibe un argumento por referencia, y lo modifica
SubProceso Triplicar(num por referencia) 
    num <- num*3 // modifica la variable duplicando su valor
FinSubProceso

// proceso principal, que invoca a las funciones antes declaradas
Proceso PruebaFunciones
    
    
    Escribir "Llamada a la funcion Saludar:"
    Saludar // como no recibe argumentos pueden omitirse los paréntesis vacios
    
    Escribir "Ingrese un valor numérico para x:"
    Leer x
    
    Escribir "Llamada a la función CalcularDoble (pasaje por valor)"
    Escribir "El doble de ",x," es ", CalcularDoble(x)
    Escribir "El valor original de x es ",x
    
    Escribir "Llamada a la función Triplicar (pasaje por referencia)"
    Triplicar(x)
    Escribir "El nuevo valor de x es ", x
    
FinProceso


AdivinaNumero: Sencillo juego en el que el usuario debe adivinar un número aleatorio

// Juego simple que pide al usuario que adivine un numero en 10 intentos

Proceso Adivina_Numero

    intentos<-10
    num_secreto <- azar(100)+1
    
    Escribir "Adivine el numero (de 1 a 100):"
    Leer num_ingresado
    Mientras num_secreto<>num_ingresado Y intentos>1 Hacer
        Si num_secreto>num_ingresado Entonces
            Escribir "Muy bajo"
        Sino 
            Escribir "Muy alto"
        FinSi
        intentos <- intentos-1
        Escribir "Le quedan ",intentos," intentos:"
        Leer num_ingresado
    FinMientras
    
    Si num_secreto=num_ingresado Entonces
        Escribir "Exacto! Usted adivino en ",11-intentos," intentos."
    Sino
        Escribir "El numero era: ",num_secreto
    FinSi
    
FinProceso





Promedio: Ejemplo básico de uso de un acumulador y la estructura de control PARA para calcular el promedio de un conjunto de valores



// Calcula el promedio de una lista de N datos

Proceso Promedio

    Escribir "Ingrese la cantidad de datos:"
    Leer n
    
    acum<-0
    
    Para i<-1 Hasta n Hacer
        Escribir "Ingrese el dato ",i,":"
        Leer dato
        acum<-acum+dato
    FinPara
    
    prom<-acum/n
    
    Escribir "El promedio es: ",prom
    
FinProceso



Triangulo: Este algoritmo determina a partir de las longitudes de tres lados de un triángulo si corresponden a un triángulo rectángulo (para utiliza la relación de Pitágoras, tomando los dos lados de menor longitud como catetos), y en caso afirmativo informa el área del mismo                                                                                                                                                                                                                                                                                                   // Lee los tres lados de un triangulo rectangulo, determina 
// si corresponden (por Pitargoras) y en caso afirmativo 
// calcula el area

Proceso TrianguloRectangulo
    

    // cargar datos
    Escribir "Ingrese el lado 1:"
    Leer l1
    Escribir "Ingrese el lado 2:"
    Leer l2
    Escribir "Ingrese el lado 3:"
    Leer l3
    
    // encontrar la hipotenusa (mayor lado)
    Si l1>l2 Entonces
        cat1<-l2
        Si l1>l3 Entonces
            hip<-l1
            cat2<-l3
        Sino
            hip<-l3
            cat2<-l1
        FinSi
    Sino
        cat1<-l1
        Si l2>l3 Entonces
            hip<-l2
            cat2<-l3
        Sino
            hip<-l3
            cat2<-l2
        FinSi
    FinSi
    
    // ver si cumple con Pitagoras
    Si hip^2 = cat1^2 + cat2^2 Entonces
        // calcualar area
        area<-(cat1*cat2)/2
        Escribir "El area es: ",area
    Sino
        Escribir "No es un triangulo rectangulo."
    FinSi
    
FinProceso                                                                                                                  OrdenaLista: Este ejemplo almacena una lista de nombres en un arreglo y luego los ordena alfabéticamente. El método de ordenamiento es relativamente simple. Para la entrada de datos se utiliza una estructura MIENTRAS, sin saber a priori la cantidad de datos que se ingresarán                                                                                                                                                                                                                                                                         // Se ingresa una lista de nombres (la lista termina
// cuando se ingresa un nombre en blanco) no permitiendo
// ingresar repetidos y luego se ordena y muestra

Proceso OrdenaLista
    
    Dimension lista[200]
    
    Escribir "Ingrese los nombres (enter en blanco para terminar):"
    
    // leer la lista
    cant<-0
    Leer nombre
    Mientras nombre<>"" Hacer
        cant<-cant+1
        lista[cant]<-nombre
        Repetir // leer un nombre y ver que no este ya en la lista
            Leer nombre
            se_repite<-Falso
            Para i<-1 Hasta cant Hacer
                Si nombre=lista[i] Entonces
                    se_repite<-Verdadero
                FinSi
            FinPara
        Hasta Que NO se_repite
    FinMientras
    
    // ordenar
    Para i<-1 Hasta cant-1 Hacer
        // busca el menor entre i y cant
        pos_menor<-i
        Para j<-i+1 Hasta cant Hacer
            Si lista[j]<lista[pos_menor] Entonces
                pos_menor<-j
            FinSi
        FinPara
        // intercambia el que estaba en i con el menor que encontro
        aux<-lista[i]
        lista[i]<-lista[pos_menor]
        lista[pos_menor]<-aux
    FinPara    
    
    // mostrar como queda la lista
    Escribir "La lista ordenada es:"
    Para i<-1 Hasta cant Hacer
        Escribir "   ",lista[i]
    FinPara
    
FinProceso



Modulo: Ejemplo trivial del uso del operador de módulo (MOD o %)



Proceso Modulo
    Escribir "Ingrese el numero: "
    Leer N
    Escribir "Ingrese el divisor: "
    Leer M
    Si N MOD M = 0 Entonces
        Escribir M," es divisor exacto de ",N,"."
    Sino
        Escribir "El resto de dividir ",N," por ",M," es: ",N MOD M
    FinSi
FinProceso


Menu: Ejemplo simple de menú de opciones, con las estructuras Repetir-Hasta Que y Segun

// Muestra como hacer un menú simple con las estructuras Repetir-Hasta Que y Según

Proceso sin_titulo
    Repetir
        // mostrar menu
        Limpiar Pantalla
        Escribir "Menú de recomendaciones"
        Escribir "   1. Literatura"
        Escribir "   2. Cine"
        Escribir "   3. Música"
        Escribir "   4. Videojuegos"
        Escribir "   5. Salir"
        // ingresar una opcion
        Escribir "Elija una opción (1-5): "
        Leer OP
        // procesar esa opción
        Segun OP Hacer
            1:
                Escribir "Lecturas recomendables:"
                Escribir " + Esperándolo a Tito y otros cuentos de fúbol (Eduardo Sacheri)"
                Escribir " + El juego de Ender (Orson Scott Card)"
                Escribir " + El sueño de los héroes (Adolfo Bioy Casares)"
            2:
                Escribir "Películas recomendables:"
                Escribir " + Matrix (1999)"
                Escribir " + El último samuray (2003)"
                Escribir " + Cars (2006)"
            3:
                Escribir "Discos recomendables:"
                Escribir " + Despedazado por mil partes (La Renga, 1996)"
                Escribir " + Búfalo (La Mississippi, 2008)"
                Escribir " + Gaia (Mägo de Oz, 2003)"
            4:
                Escribir "Videojuegos clásicos recomendables"
                Escribir " + Día del tentáculo (LucasArts, 1993)"
                Escribir " + Terminal Velocity (Terminal Reality/3D Realms, 1995)"
                Escribir " + Death Rally (Remedy/Apogee, 1996)"
            5:
                Escribir "Gracias, vuelva prontos"
            De otro modo:
                Escribir "Opción no válida"
        FinSegun
        Escribir "Presione enter para continuar"
        Esperar Tecla
    Hasta Que OP=5
FinProceso





Digitos: Separa los dígitos de un número entero utilizando el operador módulo



// Separa un numero entero en sus digitos

Proceso Digitos
    
    Escribir "Ingrese un numero entero postivo:"
    Leer n
    
    // primero, contar cuantos digitos
    cont <- 0 
    aux <- n
    Mientras aux>0 hacer // mientras no sea cero
        cont <- cont + 1 // contar cuantos digitos
        aux <- trunc(aux/10) // dividir por 10 y despreciar los de
    FinMientras
    Escribir "El numero tiene ",cont," digitos"
    
    // luego, mostrarlos uno por uno 
    aux<-n
    Para i<-1 hasta cont Hacer
        pot <- 10^(cont-i) // por cuanto hay que dividir para obtener el primer digito
        digito <- trunc (aux / pot) // obtener el digito
        aux <- aux - digito*pot // quitar ese digito al numero
        Escribir "El digito ",i," es ",digito
    FinPara
    
FinProceso

Resolvente: Utiliza la fórmula resolvente para determinar las raíces de una ecuación de segundo grado a partir de sus tres coeficientes, y las informa adecuadamente según su tipo (reales iguales, reales distintas, imaginarias)

// calcula las raices de una ecuacion de segundo grado

Proceso Resolvente
    
    // cargar datos
    Escribir "Ingrese el coeficiente A:"
    Leer a
    Escribir "Ingrese el coeficiente B:"
    Leer b
    Escribir "Ingrese el coeficiente C:"
    Leer c
    
    // determinar si son reales o imaginarias
    disc <- b^2-4*a*c
    Si disc<0 Entonces
        // si son imaginarias
        preal<- (-b)/(2*a)
        pimag<- rc(-disc)/(2*a)
        Escribir "Raiz 1: ",preal,"+",pimag,"i"
        Escribir "Raiz 2: ",preal,"-",pimag,"i"
    Sino
        Si disc=0 Entonces // ver si son iguales o distintas
            r <- (-b)/(2*a)
            Escribir "Raiz 1 = Raiz 2: ",r
        Sino
            r1 <- ((-b)+rc(disc))/(2*a)
            r2 <- ((-b)-rc(disc))/(2*a)
            Escribir "Raiz 1: ",r1
            Escribir "Raiz 2: ",r2
        FinSi
    FinSi
    
FinProceso





Primos: Calcula iterativamente los N primeros números primos



// Encuentra los primeros N numeros primos

Proceso Primos
    
    Escribir "Ingrese la cantidad de numeros primos a mostrar:"
    Leer cant_a_mostrar
    
    Escribir "1: 2" // el primer primo es 2, los otros son todos impares...
    cant_mostrados <- 1
    n<-3            // ...a partir de 3
    
    Mientras cant_mostrados<cant_a_mostrar Hacer
        
        es_primo <- Verdadero // pienso que es primo hasta que encuentre con que dividirlo
        
        Para i<-3 hasta rc(n) con paso 2 Hacer // ya sabemos que es impar
            Si n MOD i = 0 entonces // si la division da exacta...
                es_primo <- Falso  // ...ya no es primo
            FinSi
        FinPara
        
        Si es_primo Entonces
            cant_mostrados <- cant_mostrados + 1
            Escribir cant_mostrados, ": ",n
        FinSi
        
        n <- n + 2 
        
    FinMientras
    
FinProceso


Factorizacion: Ejemplo de algoritmo para descomponer un número en sus factores primos

Proceso Factorizacion
    
    Escribir "Ingrese el numero: "
    Leer num
    
    Escribir "Factorizacion: "
    
    factorizar<-verdadero
    
    Mientras factorizar Y num>1 hacer
        div<-0
        Si num/2 = trunc(num/2) Entonces
            Escribir 2
            num<-num/2
        Sino
            div<-1; factor_primo<-Verdadero
            Mientras div<=rc(num) Y factor_primo Hacer
                div <- div+2
                Si num/div = trunc(num/div) Entonces
                    factor_primo <- Falso
                FinSi
            FinMientras
            Si factor_primo Entonces
                escribir num
                factorizar<-falso
            sino
                escribir div
                num<-num/div
                factor_primo<-verdadero
            FinSi
        FinSi
    FinMientras
    
FinProceso





Cadenas: Muestra la utilización de las funciones de cadenas para contar las vocales de una frase



// Este ejemplo muestra como utilizar las funciones para manejo 
// de cadenas de caracteres. Requiere que el perfil de lenguaje
// habilite estas funciones. Si al intentar ejecutar obtiene
// errores en las funciones, revise su configuración en el
// item "Opciones del lenguaje" del menú "Configurar".
Proceso sin_titulo
    
    
    // el usuario ingresa una frase, vamos a contar cuantas vocales tiene
    Escribir "Ingrese una frase"
    Leer frase
    // pasamos toda la frase a minusculas para no tener que preguntar 2 veces por cada vocal
    frase<-Minusculas(frase)
    
    // lista de letras que vamos a buscar
    Vocales<-"aeiouáéíóúü"
    cantvocales<-0
    
    // comparar todas las letras de frase con las de vocales y contar coincidencias
    Para i<-1 hasta Longitud(frase) Hacer
        Para j<-1 hasta Longitud(vocales) Hacer
            Si Subcadena(frase,i,i)=Subcadena(vocales,j,j) Entonces
                cantVocales<-cantVocales+1
            FinSi
        FinPara
    FinPara
    
    Escribir "La frase contiene ",cantVocales," vocales."
    
    
FinProceso


Para: En este ejemplo se recorre un arreglo utilizando las tres variantes de la estructura Para

// Para poder ejecutar correctamente este ejemplo debe tener
// habilitada la sintaxis flexible en su perfil de lenguaje

Proceso sin_titulo    


    // declara un arreglo de 10 elementos
    Dimension A[10]
    
    // recorre los 10 elementos y va asignandoles enteros aleatorios
    para cada elemento de A Hacer
        // elemento toma el contenido de cada posicion del arreglo
        // y si se modifica elemento se modifica el arreglo
        elemento <- azar(100)
    FinPara
    
    Escribir "Los elementos del arreglo son:"
    // recorre los 10 elementos utilizando subindices y los muestra en pantalla
    para i desde 1 hasta 10 Hacer
        escribir "Posición " i ": " A[i]
    FinPara
    
    Escribir "" // deja una linea en blanco
    
    Escribir "En orden inverso:"
    // recorre los 10 elementos en orden inverso y los muestra en una misma linea
    para i desde 10 hasta 1 Hacer
        escribir sin bajar A[i] " "
    FinPara
    
FinProceso





Potencia: Ejemplo de una función recursiva para calcular una potencia



// Implementación del cálculo de una potencia mediante una función recursiva
// El paso recursivo se basa en que A^B = B*(A^(B-1))
// El paso base se base en que A^0 = 1

SubProceso  resultado <- Potencia (base, exponente)
    Si exponente=0 Entonces
        resultado <- 1;
    sino 
        resultado <- base*Potencia(base,exponente-1); 
    FinSi
FinSubProceso

Proceso DosALaDiezRecursivo
    Escribir "Ingrese Base"
    Leer base
    Escribir "Ingrese Exponente"
    Leer exponente
    Escribir "El resultado es ",Potencia(base,exponente)
FinProceso





Promedio2: Ejemplo de cómo crear subprocesos que reciban arreglos como argumento



// Calcula el promedio de una lista de N datos utilizando un SubProceso

SubProceso prom <- Promedio ( arreglo, cantidad )
    suma <- 0
    Para i<-1 Hasta cantidad Hacer
        suma <- suma + arreglo[i]
    FinPara
    prom <- suma/cantidad
FinSubProceso

Proceso Principal

    Dimension datos[100]
    Escribir "Ingrese la cantidad de datos:"
    Leer n
    
    Para i<-1 Hasta n Hacer
        Escribir "Ingrese el dato ",i,":"
        Leer datos[i]
    FinPara
    
    Escribir "El promedio es: ",Promedio(datos,n)
    
FinProceso





Misil: Ejemplo de animación con códigos ASCII y la instrucción Esperar



Proceso Misil

    Escribir "Presione una tecla para iniciar el lanzamiento!"
    Esperar Tecla
    
    
    // el arreglo cohete tiene el dibujo del cohete como lineas de texto
    dimension cohete[9]
    cohete[1]<-"   /|\   "
    cohete[2]<-"   |B|   "
    cohete[3]<-"   |O|   "
    cohete[4]<-"   |M|   "
    cohete[5]<-"   |B|   "
    cohete[6]<-"  //|\\  "
    cohete[7]<-" ******* "
    cohete[8]<-"* * * * *"
    cohete[9]<-" * * * * "
    
    // primero se muestra la primer parte del dibujo y la cuenta regresiva
    Para i<-1 hasta 11 Hacer
        Borrar Pantalla
        Para j<-1 hasta 15 Hacer
            Escribir ""
        FinPara
        Para j<-1 hasta 6 Hacer
            Escribir cohete[j]
        FinPara
        Escribir ""
        Escribir "Lanzamiento en ",11-i
        Esperar 1 Segundo
    FinPara
    
    // despues se muestra el dibujo completo y cada vez mas arriba
    Para i<-1 hasta 15 Hacer
        Borrar Pantalla
        Para j<-i hasta 15 Hacer
            Escribir ""
        FinPara
        Para j<-1 hasta 8 Hacer
            Escribir cohete[j]
        FinPara
        si i>1 Entonces
            Escribir " * * * * "
        finsi
        Esperar 1/i Segundo
    FinPara
    
    // finalmente se va modificando el dibujo para hacer la explosion
    // estado tiene un entero que dice en que parte de la explosion va cada linea del dibujo
    Dimension estado[6]
    estado[1]<-3; estado[2]<-2; estado[3]<-1
    estado[4]<-2; estado[5]<-3; estado[6]<-4
    Para i<-1 hasta 10 Hacer
        Borrar Pantalla
        Para j<-1 hasta 6 Hacer
            Estado[j]<-Estado[j]-1
            segun Estado[j] Hacer
                0:  cohete[j]<-"    +    "
                -1,-5: cohete[j]<-"   +X+   "
                -2,-4: cohete[j]<-"  +XXX+  "
                -3: cohete[j]<-" +XXXXX+ "
                -6: cohete[j]<-"         "
            FinSegun
            Escribir cohete[j]
        FinPara
        
        Esperar .2 Segundos
    FinPara
    
FinProceso


Romanos: Muestra como convertir números enteros a notación romana utilizando arreglos


Proceso Romanos
    
    // leer el número
    Escribir "Ingrese un número entre 1 y 1000"
    Leer Numero
    
    // controlar que sea válido para convertir
    SePuedeConvertir<-Verdadero
    Si Numero=0 Entonces
        Escribir "No existe ningún símbolo para representar el 0"
        SePuedeConvertir<-Falso
    FinSi
    Si Numero<>trunc(numero) Entonces
        Escribir "El número debe ser entero"
        SePuedeConvertir<-Falso
    FinSi
    Si Numero>1000 Entonces
        Escribir "Muy alto"
        SePuedeConvertir<-Falso
    FinSi
    Si Numero<0 Entonces
        Escribir "Debe ser positivo"
        SePuedeConvertir<-Falso
    FinSi
    
    // realizar la conversión
    Si SePuedeConvertir Entonces        
        Si Numero=1000 Entonces
            Escribir "M"
        Sino
            Dimension nu[10], nd[10], nc[10] // notación para unidades, decenas y centenas
            nu[1]<-''; nu[2]<-'I'; nu[3]<-'II'; nu[4]<-'III'; nu[5]<-'IV'; nu[6]<-'V'; nu[7]<-'VI'; nu[8]<-'VII'; nu[9]<-'VIII'; nu[10]<-'IX'
            nd[1]<-''; nd[2]<-'X'; nd[3]<-'XX'; nd[4]<-'XXX'; nd[5]<-'XL'; nd[6]<-'L'; nd[7]<-'LX'; nd[8]<-'LXX'; nd[9]<-'LXXX'; nd[10]<-'XC'
            nc[1]<-''; nc[2]<-'C'; nc[3]<-'CC'; nc[4]<-'CCC'; nc[5]<-'CD'; nc[6]<-'D'; nc[7]<-'DC'; nc[8]<-'DCC'; nc[9]<-'DCCC'; nc[10]<-'CM'
            centenas<-trunc(Numero/100) MOD 10
            decenas<-trunc(Numero/10) MOD 10
            unidades<-Numero MOD 10
            Escribir nc[centenas+1],nd[decenas+1],nu[unidades+1]
        FinSi
    FinSi
    
FinProceso





Hanoi: Implementa el conocido juego de las torres de Hanoi en pseudocódigo



//    El objetivo del juego es mover los discos de la torre 1 a la 3 en la
// menor cantidad de movimientos posible. No se puede colocar un disco de 
// un tamanio sobre otro mas chico

//     Hay una matriz que representa las torres, cada columna contiene
//  nros que representan los tamanios de los discos en esas torres (solo
//  interesan los valores hasta la cantidad de discos de esa torre).
//  Cuantos discos tiene cada torre lo dice el vector cant_discos. 

Proceso Hanoi
    
    Dimension torres[3,10], cant_discos[3]
    
    // pedir y validar cuantos discos colocar en la primer torre
    Escribir "Ingrese el nro de discos (1-8):"
    leer discos
    mientras discos<1 O discos>8 Hacer
        Escribir "El numero de discos debe ser mayor a 0 y menor a 5:"
        leer discos
    finmientras

    // inicializar los datos
    cant_discos[1]<-discos
    cant_discos[2]<-0
    cant_discos[3]<-0
    Para i<-1 Hasta discos hacer
        torres[1,i]<-discos-i+1
    FinPara
    
    
    // jugar!
    cant_movs<-0
    Mientras cant_discos[3]<>discos Hacer // mientras no esten todos los discos en la tercer torre, el juego sigue
        
        Limpiar Pantalla
        
        Para i<-1 Hasta 3 Hacer // dibujar las tres torres
            escribir "Torre ",i
            si cant_discos[i]=0 Entonces
                Escribir ""
            sino
                para j<-cant_discos[i] hasta 1 con paso -1 Hacer // recorrer los discos de la torre, de arriba hacia abajo
                    segun torres[i,j] Hacer // dibujar cada disco
                        1: Escribir "                   XX"
                        2: Escribir "                 XXXXXX"
                        3: Escribir "               XXXXXXXXXX"
                        4: Escribir "             XXXXXXXXXXXXXX"
                        5: Escribir "           XXXXXXXXXXXXXXXXXX"
                        6: Escribir "         XXXXXXXXXXXXXXXXXXXXXX"
                        7: Escribir "       XXXXXXXXXXXXXXXXXXXXXXXXXX"
                        8: Escribir "     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                    finsegun
                FinPara
            finsi
            Escribir "   ----------------------------------"
            Escribir ""
        FinPara
        
        // solicitar movimiento
        Escribir "Mover desde la torre: "
        leer t1
        Escribir "hacia la torre: "
        leer t2
        
        si t1<1 O t1>3 O t2<1 O t2>3 Entonces // controlar que el nro de torre sea valido
            Escribir "Movimiento invalido"
            Esperar Tecla
        sino
            Si cant_discos[t1]=0 Entonces // controlar que la torre 1 tengo al menos un disco
                Escribir "Movimiento invalido"
                Esperar Tecla
            Sino
                disco_a_mover <- torres[t1,cant_discos[t1]] // obtener tamanio del disco que se quiere mover
                puede_mover<-verdadero
                Si cant_discos[t2]<>0 entonces // controlar que la torre dos no tenga discos o tenga solo discos mas grandes
                    Si torres[t2,cant_discos[t2]]<disco_a_mover Entonces
                        puede_mover<-Falso
                    FinSi
                FinSi
                Si puede_mover Entonces // si paso todos los controles, mover
                    cant_movs <- cant_movs+1
                    cant_discos[t2]<-cant_discos[t2]+1
                    torres[t2,cant_discos[t2]] <- disco_a_mover
                    cant_discos[t1]<-cant_discos[t1]-1
                Sino
                    Escribir "Movimiento invalido"
                    Esperar Tecla
                FinSi
            FinSi
        FinSi
    
    FinMientras
    
    // mostrar resultado
    Limpiar Pantalla
    Escribir "Juego finalizado en ",cant_movs," movimientos!"
    
FinProceso





TaTeTi: Algoritmo para el juego del TaTeTi



Proceso TaTeTi
    
    // incializa dos matrices de 3x3, una para guardar la ficha que se ve, 
    // y otra para un valor asociado a la ficha, para un jugador sera 1, para
    // el otro 2, entoces para ver quien gano se multiplica por fila, por 
    // columna y por diagonal, si el resultado es 1 gano el primer jugador,
    // si es 8 gano el segundo, si es 0 es porque faltaba completar, si
    // es otra cosa, estan las tres fichas, pero no son del mismo jugador
    Dimension Tab1[3,3]
    Dimension Tab2[3,3]
    Para i<-1 Hasta 3 Hacer
        Para j<-1 Hasta 3 Hacer
            Tab1[i,j]<-0
            Tab2[i,j]<-" "
        FinPara
    FinPara
    TurnoJugador1<-Verdadero
    Terminado<-Falso
    Ganador<-Falso
    CantTurnos<-0
    
    Mientras ~ Terminado hacer
        
        // dibuja el tablero
        Borrar Pantalla
        Escribir " "
        Escribir "      ||     ||     "
        Escribir "   ",Tab2[1,1],"  ||  ",Tab2[1,2],"  ||  ",Tab2[1,3]
        Escribir "     1||    2||    3"
        Escribir " =====++=====++======"
        Escribir "      ||     ||     "
        Escribir "   ",Tab2[2,1],"  ||  ",Tab2[2,2],"  ||  ",Tab2[2,3]
        Escribir "     4||    5||    6"
        Escribir " =====++=====++======"
        Escribir "      ||     ||     "
        Escribir "   ",Tab2[3,1],"  ||  ",Tab2[3,2],"  ||  ",Tab2[3,3]
        Escribir "     7||    8||    9"
        Escribir " "
        
        Si ~ Ganador y CantTurnos<9 Entonces
            
            // carga auxiliares segun a qué jugador le toca
            Si TurnoJugador1 Entonces
                Ficha<-'O'; Valor<- 1; Objetivo<-1
                Escribir "Turno del jugador 1 (X)"
            Sino
                Ficha<-'X'; Valor<- 2; Objetivo<-8
                Escribir "Turno del jugador 2 (O)"
            FinSi
            
            // pide la posición para colocar la ficha y la valida
            Escribir "Ingrese la Posición (1-9):"
            
            Repetir
                Leer Pos
                Si Pos<1 o Pos>9 Entonces
                    Escribir "Posición incorrecta, ingrese nuevamente: "
                    Pos<-99;
                Sino
                    i<-trunc((Pos-1)/3)+1
                    j<-((Pos-1) MOD 3)+1
                    Si Tab1[i,j]<>0 Entonces
                        pos<-99
                        Escribir "Posición incorrecta, ingrese nuevamente: "
                    FinSi
                FinSi
            Hasta Que Pos<>99
            // guarda la ficha en la matriz tab2 y el valor en tab1
            CantTurnos<-CantTurnos+1
            Tab1[i,j]<-Valor
            Tab2[i,j]<-Ficha
            
            // verifica si ganó, buscando que el producto de las fichas en el tablero de Objetivo
            aux_d1<-1; aux_d2<-1
            Para i<-1 hasta 3 hacer
                aux_i<-1; aux_j<-1
                aux_d1<-aux_d1*Tab1[i,i]
                aux_d2<-aux_d2*Tab1[i,4-i]
                Para j<-1 hasta 3 hacer
                    aux_i<-aux_i*Tab1[i,j]
                    aux_j<-aux_j*Tab1[j,i]
                FinPara
                Si aux_i=Objetivo o aux_j=Objetivo Entonces
                    Ganador<-Verdadero
                FinSi
            FinPara
            Si aux_d1=Objetivo o aux_d2=Objetivo Entonces
                Ganador<-Verdadero
            Sino
                TurnoJugador1 <- ~ TurnoJugador1
            FinSi
            
        Sino
            
            Si Ganador Entonces
                Escribir "Ganador: "
                Si TurnoJugador1 Entonces
                    Escribir "Jugador 1!"
                Sino
                    Escribir "Jugador 2!"
                FinSi
            Sino
                Escribir "Empate!"
            FinSi
            Terminado<-Verdadero
            
        FinSi
        
    FinMientras
    
FinProceso