INDICE

Contenido
INTRODUCCION .............................................................................................................................. 3
ALGORITMO ..................................................................................................................................... 4
TIPOS DE DATOS ........................................................................................................................... 6
Tipos de datos para variables .................................................................................................... 6
Tipo de datos número: int........................................................................................................ 6
Tipos de datos número real: double o float .......................................................................... 6
Tipos de datos cadena: char o string .................................................................................... 7
Tipo de datos booleano: boolean ........................................................................................... 7
Tipos de datos abstractos ........................................................................................................... 7
PSEUDOCODIGO ............................................................................................................................ 8
Principales características del pseudocódigo ............................................................................ 8
Ventajas y desventajas del pseudocódigo ................................................................................. 8
Componentes y sintaxis del pseudocódigo ................................................................................ 9
Opciones del lenguaje (perfiles) .................................................................................................. 9
Estructura de un algoritmo en pseudocódigo ........................................................................... 10
VARIABLES..................................................................................................................................... 10
Concepto de variable ................................................................................................................. 11
Como se declara una variable en programación ................................................................... 11
Ejemplos de variables en programación ................................................................................. 12
Variable auxiliar ...................................................................................................................... 12
Variable acumuladora ............................................................................................................ 12
Variable de estado ................................................................................................................. 12
DIAGRAMA DE FLUJO ................................................................................................................. 13
¿QUÉ ES PROGRAMACIÓN?..................................................................................................... 13
PSEINT ............................................................................................................................................ 15
ESTRUCTURAS CONDICIONALES ........................................................................................... 16
ESTRUCTUA SWITHC WHILE, FOR DXO WHILE .................................................................. 17
CONTROLES BASICOS ............................................................................................................... 19
CONCLUSIONES ........................................................................................................................... 24
BIBLIOGRAFIA ............................................................................................................................... 25
 INTRODUCCION

A continuación, se le presentan conceptos relacionados

al área de programación, herramientas que sin duda alguna
vendrían a mejorar nuestros conocimientos sobre el área y que
nos facilitaran la práctica de la misma.
 ALGORITMO

Algoritmo. En Matemática, ciencias de la Computación y disciplinas relacionadas,

un algoritmo (del latín, dixit algorithmus y éste a su vez del matemático persa Al
Juarismi) es un conjunto reescrito de instrucciones o reglas bien definidas,
ordenadas y finitas que permite realizar una actividad mediante pasos sucesivos
que no generen dudas a quien lo ejecute. Dados un estado inicial y una entrada,
siguiendo los pasos sucesivos se llega a un estado final y se obtiene una solución.
Los algoritmos son objeto de estudio de la algoritmia.

La palabra algoritmo proviene del nombre de un matemático árabe del siglo

IX (Alheresni Khowarismi), originario de la antigua ciudad de Khowarism, hoy Kiva,
situada en la antigua URSS. Formuló las reglas de las cuatro operaciones
aritméticas con varios dígitos. Posteriormente este concepto comenzó a utilizarse
en general para designar las secuencias de operaciones que conducen a la
solución de cualquier tarea matemática.

Con el decursar del tiempo el proceso de búsqueda y formalización de algoritmos

dejó de ser tarea sólo de matemáticos y se obtuvieron diferentes tipos de
algoritmos. Así surgieron algoritmos para juegos como damas y ajedrez, donde los
objetos son figuras y posiciones en los que se requiere seleccionar el próximo
paso. En otros casos son acciones de una corriente eléctrica o de una
determinada máquina o por ejemplo el algoritmo de búsqueda de una palabra en
un diccionario donde se utilizan textos. Pero en todos los casos debe considerarse
que los algoritmos no trabajan con objetos del mundo real, sino con
representaciones, abstracciones de éstos. Por ello para designarlos se
utilizan variables, símbolos, codificaciones.

Características principales y definición formal

En la vida cotidiana se emplean algoritmos en multitud de ocasiones para resolver
problemas. Algunos ejemplos son los manuales de usuario, que muestran
algoritmos para usar un aparato, o las instrucciones que recibe un trabajador por
parte de su patrón. Algunos ejemplos en matemáticas son el algoritmo de la
división para calcular el cociente de dos números, el Algoritmo de Euclides para
obtener el máximo común divisor de dos enteros positivos, o el método
de Gauss para resolver un sistema lineal de ecuaciones.

En general, no existe ningún consenso definitivo en cuanto a la definición formal

de algoritmo. Muchos autores los señalan como listas de instrucciones para
resolver un problema abstracto, es decir, que un número finito de pasos convierten
los datos de un problema (entrada) en una solución (salida). Sin embargo cabe
notar que algunos algoritmos no necesariamente tienen que terminar o resolver un
problema en particular. Por ejemplo, una versión modificada de la criba
de Eratóstenes que nunca termine de calcular números primos no deja de ser un
algoritmo. A lo largo de la historia varios autores han tratado de definir
formalmente a los algoritmos utilizando modelos matemáticos como Máquinas de
Turing entre otros.

Sin embargo estos modelos están sujetos a un tipo particular de datos como son
números, símbolos o gráficas mientras que, en general, los algoritmos funcionan
sobre una basta cantidad de estructuras de datos.datos.En general, la parte
común en todas las definiciones se puede resumir en las siguientes tres
propiedades siempre y cuando no consideremos algoritmos paralelos:

 Tiempo secuencial. Un algoritmo funciona en tiempo discretizado –paso a

paso–, definiendo así una secuencia de estados "computacionales" por cada
entrada válida (la entrada son los datos que se le suministran al algoritmo
antes de comenzar).
 Estado abstracto. Cada estado computacional puede ser descrito formalmente
utilizando una estructura de primer orden y cada algoritmo es independiente de
su implementación (los algoritmos son objetos abstractos) de manera que en
un algoritmo las estructuras de primer orden son invariantes bajo isomorfismo.
 Exploración acotada. La transición de un estado al siguiente queda
completamente determinada por una descripción fija y finita; es decir, entre
cada estado y el siguiente solamente se puede tomar en cuenta una cantidad
fija y limitada de términos del estado actual.

En resumen, un algoritmo es cualquier cosa que funcione paso a paso, donde

cada paso se pueda describir sin ambigüedad y sin hacer referencia a una
computadora en particular, y además tiene un límite fijo en cuanto a la cantidad de
datos que se pueden leer/escribir en un solo paso. Esta amplia definición abarca
tanto a algoritmos prácticos como aquellos que sólo funcionan en teoría, por
ejemplo el método de Newton y la eliminación de Gauss–Jordan funcionan, al
menos en principio, con números de precisión infinita; sin embargo no es posible
programar la precisión infinita en una computadora, y no por ello dejan de ser
algoritmos.
En particular es posible considerar una cuarta propiedad que puede ser usada
para validar la tesis de Church–Turing de que toda función calculable se puede
programar en una máquina de Turing (o equivalentemente, en un lenguaje de
programación suficientemente general): Aritmetizabilidad. Solamente operaciones
innegablemente calculables están disponibles en el paso inicial.
 TIPOS DE DATOS

Primero de todo, recuerda que el objetivo de cualquier programa es procesar

datos. Estos datos tienen que ser de un tipo. Me explico.
Un tipo de datos debe de pertenecer a un grupo de valores, y que estos sean
válidos, para poder procesarlos.
Los tipos de datos en un lenguaje de programación pueden ser muy variados, así
que es difícil preguntarte cuantos tipos de datos hay en un lenguaje, ya que
incluso puedes crearte los tuyos propios, mediante enumeraciones o estructuras.
Ponemos tres ejemplos de tipos de datos básicos que son los más utilizados:
los números, los textos y las fechas.
Si estamos trabajando con números, podemos sumar, restar, multiplicar, dividir…
y muchas operaciones más, como comparar.
Si estamos con textos, podemos comparar (si son iguales o no), podemos sustituir
parte del texto, añadir texto a uno existente, etc.
Con fechas podemos también sumar o restar fechas (o días, meses, años),
compararlas, etc.

Más adelante veremos más tipos de datos que se usan en programación.

Tipos de datos para variables
Cada lenguaje de programación puede trabajar con muchos tipos de datos.
Pero de todos ellos, siempre tendremos los tipos primitivos de datos.
Éstos están incorporados al lenguaje de programación, y nos sirve para poder
hacer cosas más complicadas.
Vamos a hablar de los tipos de datos más comunes, que te puedes encontrar en la
mayoría de los lenguajes de programación, como puede ser Java, C o C++.

Tipo de datos número: int

Los número suelen ser representados en un lenguaje de programación de
maneras diferentes, ya que importa decidir una serie de cuestiones:
 Cual va ser el tamaño que vamos a usar.
 Si va a tener números decimales o no.
 Si va ser negativo.

Empezaremos con el tipo primitivo int. Este tipo de datos representa cualquier
número sin decimales, ya sea positivo o negativo.
Aunque es habitual encontrarlo escrito en el código fuente como int, hay otros
lenguajes, como visual basic, que se escribe integer.
Tipos de datos número real: double o float
Si nos interesa utilizar un número con decimales, sueles encontrar el tipo de
datos double o float.
A esto lo llamamos un número de punto flotante. Declararlo como un tipo u otro
dependerá de la precisión en decimales que quieras tener.
¿Como podemos distinguir una variable si se ha declarado como int o como float?
Por ejemplo, si nos encontramos un número con un punto decimal (3.14).
También puedes ver un número con la letra F o con la letra D, para distinguir si es
un float o un double. Por ejemplo 3.56F.

Tipos de datos cadena: char o string

Suele ser un valor alfanumérico. Si es un sólo carácter individual, tenemos el
tipo char.

Un char es un carácter Unicode, y solemos escribirlo entre comillas simples (‘ ‘).

Pero si es una cadena de caracteres, es decir, caracteres seguidos unos detrás de
otro formando una secuencia, lo solemos encontrar como string.
El tipo string debemos escribirlo entre comillas dobles (» «) para diferenciarlo
del char, aunque puede ser diferente, dependiendo del lenguaje de programación.
En el siguiente código veremos un uso del tipo de datos string, aunque no esté
asociado a una variable:

Console.Write("Hola Mundo");
Tipo de datos booleano: boolean
Los valores lógicos son representados por el tipo primitivo boolean. Representa si
una condición se cumple o no se cumple.
Suelen tener dos valores identificados, true (verdadero) o false (falso). En algunos
lenguajes puede equivaler a los números 0 y 1.
Una variable puede usarse para representar cualquiera de los dos valores, mejor
dicho estados.

Por ejemplo, podríamos hablar

de verdadero o falso, encendido o apagado, sí o no, activado o no activado, etc.
Tipos de datos abstractos
Ahora que ya conocemos los tipos de datos primitivos, podemos saber que
significa tipos de datos abstractos.
Los tipos de datos en programación orientada a objetos suelen ser los básicos que
hemos visto antes, pero podemos encontrarnos con tipos de datos que sean
clases u objetos.

Los tipos de datos abstractos aumentan y extienden la complejidad, ya que tiene

un conjunto de valores y unas operaciones asociadas a ellos.
Luego entraríamos en que estos datos están encapsulados, en la herencia para
aprovechar mejor las operaciones que hemos codificado y el polimorfismo, pero
esos son conceptos que serán explicados más adelante.

PSEUDOCODIGO

Una de las mejores formas de aprender a programar es empezar por los diagramas
de flujo y el pseudocódigo. Ambos facilitan al estudiante su inmersión en la
resolución de problemas mediante algoritmos.
El pseudocódigo es una forma de expresar los distintos pasos que va a realizar un
programa, de la forma más parecida a un lenguaje de programación. Su principal
función es la de representar por pasos la solución a un problema o algoritmo, de la
forma más detallada posible, utilizando un lenguaje cercano al de programación. El
pseudocódigo no puede ejecutarse en un ordenador ya que entonces dejaría de ser
pseudocódigo, como su propio nombre indica, se trata de un código falso (pseudo =
falso), es un código escrito para que lo entienda el ser humano y no la máquina.
Aprender a escribir pseudocódigo para la resolución de un problema permite hacer
mucho más sencilla su programación en un lenguaje convencional, por lo que antes
de empezar a estudiar un lenguaje de programación, sería conveniente realizar
un curso de introducción a la programación que nos muestre el ciclo de desarrollo de
un programa mediante pseudocódigo.
Podemos considerar al pseudocódigo como un lenguaje intermedio, que se
encuentra en medio de nuestro propio lenguaje y el lenguaje de programación que
entiende el ordenador.

Principales características del pseudocódigo

Para comprender qué es el pseudocódigo podemos utilizar un símil: los planos de
una casa sería el pseudocódigo y la casa en sí el programa.
Su principal característica es la de representar un método que facilita la
programación y solución del algoritmo del programa. También se caracteriza por ser
una forma de representación, fácil de utilizar y de manipular, que simplifica el paso
del programa, al lenguaje de programación.

Otra característica que tiene el pseudocódigo es su independencia al código en el

que se va a escribir el programa, proporcionando un método que facilita la posterior
programación y la resolución del algoritmo del programa.

Ventajas y desventajas del pseudocódigo

Las tareas más complejas o repetitivas pueden representarse de forma más sencilla
ya que está escrito en un lenguaje sencillo y no estructurado que permite una
transición sencilla al lenguaje de programación, más complejo y estructurado. Tener
un programa escrito en pseudocódigo facilita la tarea de programar en un lenguaje
formal y mejora la calidad en la resolución de problemas, además de reducir el
espacio necesario a la hora de desarrollar un problema.
El pseudocódigo llega donde el diagrama de flujo no lo hace. La solución de un
diagrama de flujo suele ser la ideal, pero no suele ser fácil de implementar al crear el
programa. El pseudocódigo permite que el diseño del programa y su implementación
sean muy parecidos.

La curva de aprendizaje del pseudocódigo es baja por lo que facilitan enormemente

el aprendizaje de la programación y la iniciación a lenguajes de programación más
avanzados y complejos. Por lo tanto, se trata de una herramienta educativa
interesante.

El pseudocódigo, al ser independiente del lenguaje de programación, permite que su

uso se pueda aplicar utilizando diferentes lenguajes y permitiendo que el
programador no tenga que ser la misma persona que escribió el pseudocódigo.

Una de las desventajas del uso de pseudocódigo es la falta de normas, que puede
hacer que la lógica de un programa, resulte complicada de ver por el programador
que va a implementar este pseudocódigo. Además, en el caso de problemas muy
extensos, puede llegar a ser difícil de entender.
Componentes y sintaxis del pseudocódigo
Para escribir programas utilizando pseudocódigo es necesario seguir unas pautas o
normas de sintaxis para que puedan ser leídos y comprendidos por los
programadores a la hora de pasarlos a un lenguaje de programación. Es muy útil
utilizar herramientas que faciliten esta escritura de pseudocódigo, como es el caso
de PSeInt, que asiste con un simple e intuitivo pseudolenguaje en español y que
además incluye un editor de diagramas de flujo.

Un programa escrito en pseudocódigo debe permitir instrucciones primitivas, de

proceso, de control, de descripción y compuestas.
Opciones del lenguaje (perfiles)
El lenguaje que utilizamos para construir el pseudocódigo no es estándar. Podemos
añadir o eliminar algunas reglas de sintaxis sin ningún problema. En la
opción Configurar-Opciones del Lenguaje (perfiles), podemos escoger las
características del pseudocódigo que vamos a utilizar.
Tenemos tres alternativas:
 Escoger un perfil que define un pseudocódigo utilizado en distintos centros
educativos y universidades.
 Perfil flexible: Está escogido por defecto, y no es muy exigente con las reglas
que hay que utilizar para escribir el pseudocódigo.
 Perfil estricto: Estable ce una reglas que hacen que el pseudocódigo se
parezca más a un lenguaje de programación: se debe definir las variables y
sus tipos, las instrucciones deben terminar en punto y coma,…

Estructura de un algoritmo en pseudocódigo

Todo algoritmo en pseudocódigo tiene la siguiente estructura general:

 Comienza con la palabra clave Proceso (o alternativamente Algoritmo, son
sinónimos) seguida del nombre del programa.
 Le sigue una secuencia (Estructura de control secuencial) de instrucciones.
Una secuencia de instrucciones es una lista de una o más instrucciones y/o
estructuras de control.
 Finaliza con la palabra FinProceso (o FinAlgoritmo).
 La identación no es significativo, pero se recomienda para que el código sea
más legible.
 No se diferencia entre mayúsculas y minúsculas. Preferible las minúsculas,
aunque a veces se añaden automáticamente los nombres con la primera letra
en mayúsculas.

VARIABLES

Las variables se suelen utilizar en muchos ámbitos diferentes, como por ejemplo,
en matemáticas. Pero aquí te encontrarás la definición de variable en
programación.
Una variable es donde se guarda (y se recupera) datos que se utilizan en un
programa.
Cuando escribimos código, las variables se utilizan para:
 Guardar datos y estados.
 Asignar valores de una variable a otra.
 Representar valores dentro de una expresión matemática.
  Mostrar valores por pantalla.
Todas las variables deben ser de un tipo de datos, ya sea un dato de tipo primitivo,
como un número o texto, o un dato abstracto, como un objeto que se ha creado.
Así que básicamente podemos decir que una variable es
Tipo de dato → identificador variable → valor almacenado.
Concepto de variable
Veamos un poco el concepto de lo que hemos explicado, y así sabremos para que
sirve una variable en programación (y su significado).
Primero hablaremos del identificador de una variable, que no deja de ser el
nombre de la variable que le ponemos.
Cuando hablamos de identificadores, no sólo nos referimos a las variables, sino
también cuando ponemos un nombre a una función o una clase.
Lo habitual es que haya una serie de restricciones. La mayoría de los lenguajes de
programación tienen estas condiciones:
 Pueden ser letras, números y el símbolo _. Con estos límites:
o no puede tener espacios.
o no empezar con un número.
o no puede ser una palabra reservada. Por ejemplo, if, for, while…
o Algunos lenguajes pueden permitir empezar con carácter especial,
como $.
Otra cosa a tener en cuenta es que hay lenguajes que distinguen mayúsculas y
minúsculas. Eso se llama case sensitive, por si te lo encuentras alguna vez.
Por ejemplo, la variable total serían una variable diferente de Total en Java, C,
C++. Pero en Visual Basic, no.
Como se declara una variable en programación
La mayoría de lenguajes de programación obliga a declarar la variable (decir como
se va a llamar) con el tipo de datos asociado. Por ejemplo, en C#
int total;
En este caso, la variable se llama total, y sabemos que su tipo de datos es
un número, al poner int.
Eso significa otra cosa muy importante: la variable no puede almacenar otro tipo
de datos. Por ejemplo, para almacenar un número podríamos poner:
total = 10;
A esto se le llama asignación de valores a una variable.
También se podría poner todo en una sola línea:
int total = 10;
Aquí tenemos el tipo de datos, la declaración y un valor inicial, todo condensado.
En muchos otros lenguajes de programación no es necesario declarar el tipo de
datos. Por ejemplo, en Python se puede poner directamente
total_Python = 10
y el lenguaje ya sabe que esa variable es un número.
Ejemplos de variables en programación
Al crear una variable tenemos en mente que es para guardar datos, pero cuando
estamos programando podemos necesitar otra serie de variables que también son
importantes.
Para entender un poco los ejemplos de variables que te puedes encontrar, vamos
a ver algunos tipos de variables que podemos utilizar.
Variable auxiliar
También se llaman variables temporales. Son las que necesitamos para hacer
algo de manera temporal.
Seguramente esa variable no la necesites una vez ha cumplido su objetivo.
Veamos un ejemplo.
Quieres intercambiar los valores de a a b. Para hacerlo, necesitas una variable
auxiliar, que se puede llamar c. El código sería algo así:
c = a;
a = b;
b = c;
Una vez hecho esto, ya no es necesaria la variable c.
Variable acumuladora

Las variables acumuladoras sirven para almacenar un número y sus valores

consecutivos. Por ejemplo, si empieza por 0, luego tendrá el valor de 1, 2, 3, 4…
Es tan habitual que una variable incremente o decremente en 1, que muchos
lenguajes tienen una operación que sólo hace eso. Esta operación es ++ o --.
Suelen utilizarse en bucles, como for o while.

Variable de estado
Las variables de estado se utilizan para saber como se encuentra un objeto en
cada momento.

La más simple podría ser una variable booleana, dónde su valor sería true o false.
Pero también podrías definir varios estados. Por ejemplo, si tienes un objeto
luchador en un juego, puede estar peleando, cayendo, siendo derrotado…
El mismo objeto actuaría de manera diferente dependiendo del estado en el que
se encuentra.
 DIAGRAMA DE FLUJO

Un diagrama de flujo es un diagrama que describe un proceso, sistema o

algoritmo informático. Se usan ampliamente en numerosos campos para
documentar, estudiar, planificar, mejorar y comunicar procesos que suelen ser
complejos en diagramas claros y fáciles de comprender. Los diagramas de flujo
emplean rectángulos, óvalos, diamantes y otras numerosas figuras para definir el
tipo de paso, junto con flechas conectoras que establecen el flujo y la secuencia.
Pueden variar desde diagramas simples y dibujados a mano hasta diagramas
exhaustivos creados por computadora que describen múltiples pasos y rutas.

Si tomamos en cuenta todas las diversas figuras de los diagramas de flujo, son
uno de los diagramas más comunes del mundo, usados por personas con y sin
conocimiento técnico en una variedad de campos. Los diagramas de flujo a veces
se denominan con nombres más especializados, como "diagrama de flujo de
procesos", "mapa de procesos", "diagrama de flujo funcional", "mapa de procesos
de negocios", "notación y modelado de procesos de negocio (BPMN)" o "diagrama
de flujo de procesos (PFD)". Están relacionados con otros diagramas populares,
como los diagramas de flujo de datos (DFD) y los diagramas de actividad de
lenguaje unificado de modelado (UML).

¿QUÉ ES PROGRAMACIÓN?

Programación es el proceso de tomar un algoritmo y codificarlo en una notación,

un lenguaje de programación, de modo que pueda ser ejecutado por una
computadora. Aunque existen muchos lenguajes de programación y muchos tipos
diferentes de computadoras, el primer paso es la necesidad de tener una solución.
Sin un algoritmo no puede haber un programa.

Las ciencias de la programación no son el estudio de la programación. La

programación, sin embargo, es una parte importante de lo que hace un científico
de la computación. La programación es a menudo la manera en la que creamos
una representación para nuestras soluciones. Por tanto, esta representación en un
lenguaje y el proceso de crearla se convierte en una parte fundamental de la
disciplina.
Los algoritmos describen la solución a un problema en términos de los datos
requeridos para representar el caso del problema y el conjunto de pasos
necesarios para producir el resultado pretendido. Los lenguajes de programación
deben suministrar un modo notacional para representar tanto el proceso como los
datos. Para este fin, los lenguajes suministran estructuras de control y tipos de
datos.

Las estructuras de control permiten que los pasos algorítmicos sean

representados de una manera conveniente pero sin ambigüedades. Como mínimo,
los algoritmos requieren estructuras que lleven a cabo procesamiento secuencial,
selección para toma de decisiones e iteraciones para control repetitivo. Siempre y
cuando el lenguaje proporcione estas instrucciones básicas, éste puede ser usado
para la representación del algoritmo.

Todos los ítems de datos en la computadora están representados como cadenas

de dígitos binarios. Con el fin de darle significado a estas cadenas, necesitamos
tener tipos de datos. Los tipos de datos brindan una interpretación para estos
datos binarios de modo que podamos considerarlos en términos que tengan
sentido con respecto al problema que está siendo resuelto. Estos tipos de datos
incorporados de bajo nivel (a menudo denominados tipos de datos primitivos)
proporcionan los bloques constructivos para el desarrollo de algoritmos.

Por ejemplo, la mayoría de lenguajes de programación proporcionan un tipo de

datos para los enteros. Las cadenas de dígitos binarios en la memoria de la
computadora pueden interpretarse como enteros y se les dan los significados
típicos que comúnmente asociamos con los enteros (e.g. 23, 654 y -19). Además,
un tipo de datos también proporciona una descripción de las operaciones en las
que los ítems de datos pueden participar. Con enteros, son comunes las
operaciones tales como la suma, la resta y la multiplicación. Podemos dar por
sentado que los tipos de datos numéricos puedan participar en estas operaciones
aritméticas.

La dificultad que a menudo nos surge es el hecho que los problemas y sus
soluciones son muy complejos. Estas estructuras y tipos de datos simples,
suministrados por el lenguaje, si bien son ciertamente suficientes para representar
soluciones complejas, están típicamente en desventaja a medida que trabajamos
en el proceso de solución de problemas. Requerimos maneras de controlar esta
complejidad y contribuir con la creación de soluciones.
 PSEINT

PSeInt es la abreviatura de los estados de computación de PSeudo Intérprete, una

herramienta educativa creada en Argentina, utilizada principalmente por
estudiantes para aprender los fundamentos de la programación y el desarrollo de
la lógica. Es un software muy popular de su tipo y es ampliamente utilizado en
universidades de Latinoamérica y España.
Utiliza pseudocódigo para la solución de algoritmos.

Propósito de PSeInt

PSeInt está pensado para asistir a los estudiantes que se inician en la

construcción de programas o algoritmos computacionales. El pseudocódigo se
suele utilizar como primer contacto para introducir conceptos básicos como el uso
de estructuras de control, expresiones, variables, etc, sin tener que lidiar con las
particularidades de la sintaxis de un lenguaje real. Este software pretende
facilitarle al principiante la tarea de escribir algoritmos en este pseudolenguaje
presentando un conjunto de ayudas y asistencias, y brindarle además algunas
herramientas adicionales que le ayuden a encontrar errores y comprender la lógica
de los algoritmos.

Características

 Lenguaje Autocompletado
 Ayudas Emergentes
 Plantillas de Comandos
 Soporta procedimientos y funciones
 Indentado Inteligente
 Exportación a otros lenguajes (C, C++, C#, Java, PHP, JavaScript, Visual
Basic .NET, Python, Matlab)
 Graficado, creación y edición de diagramas de flujo
 Editor con coloreado de sintaxis
 Foro oficial de PSeInt
 Software multiplataforma4 sobre Microsoft Windows, GNU/Linux y Mac OS X,
en diciembre de 2016 empezó un desarrollo independiente para Android.
 ESTRUCTURAS CONDICIONALES

Condicionales

Condicional Si-Entonces

La secuencia de instrucciones ejecutadas por la instrucción Si-Entonces-Sino

depende del valor de una condición lógica.
Si <condición>
Entonces
<instrucciones>
Sino
<instrucciones>
FinSi
Al ejecutarse esta instrucción, se evalúa la condición y se ejecutan las
instrucciones que correspondan: las instrucciones que le siguen al Entonces si la
condición es verdadera, o las instrucciones que le siguen al Sino si la condición es
falsa. La condición debe ser una expresión lógica, que al ser evaluada retorna
Verdadero o Falso.
La cláusula Entonces debe aparecer siempre, pero la cláusla Sino puede no
estar. En ese caso, si la condición es falsa no se ejecuta ninguna instrucción y la
ejecución del programa continúa con la instrucción siguiente.
El ejemplo Triangulo lee las medidas de los tres lados de un triángulo y utiliza
esta estructura para determinar cual es el mayor de los tres, y verificar luego si se
trata de un triángulo rectángulo o no.

Selección Multiple

La secuencia de instrucciones ejecutada por una instrucción Segun depende del

valor de una variable numérica.
Segun <variable> Hacer
<número1>: <instrucciones>
<número2>,<número3>: <instrucciones>
<...>
De Otro Modo: <instrucciones>
FinSegun

Esta instrucción permite ejecutar opcionalmente varias acciones posibles,

dependiendo del valor almacenado en una variable de tipo numérico. Al
ejecutarse, se evalúa el contenido de la variable y se ejecuta la secuencia de
instrucciones asociada con dicho valor.
 Cada opción está formada por uno o más números separados por comas, dos
puntos y una secuencia de instrucciones. Si una opción incluye varios números, la
secuencia de instrucciones asociada se debe ejecutar cuando el valor de la
variable es uno de esos números.
Opcionalmente, se puede agregar una opción final, denominada De Otro Modo,
cuya secuencia de instrucciones asociada se ejecutará sólo si el valor almacenado
en la variable no coincide con ninguna de las opciones anteriores.

ESTRUCTUA SWITHC WHILE, FOR DXO WHILE

Estructuras repetitivas
Hemos visto cómo comprobar condiciones, pero no cómo hacer que una cierta
parte de un programa se repita un cierto número de veces o mientras se cumpla
una condición (lo que llamaremos un “bucle”). En C tenemos varias formas de
conseguirlo.

while
Si queremos hacer que una sección de nuestro programa se repita mientras se
cumpla una cierta condición, usaremos la orden “while”. Esta orden tiene dos
formatos distintos, según comprobemos la condición al principio o al final.
En el primer caso, su sintaxis es
while (condición)
sentencia;
Es decir, la sentencia se repetirá mientras la condición sea cierta. Si la condición
es falsa ya desde un principio, la sentencia no se ejecuta nunca. Si queremos que
se repita más de una sentencia, basta agruparlas entre { y }. Como ocurria con "if",
puede ser recomendable incluir siempre las llaves, aunque sea una única
sentencia, para evitar errores posteriores difíciles de localizar.
Un ejemplo que nos diga si cada número que tecleemos es positivo o negativo, y
que pare cuando tecleemos el número 0, podría ser:
/*---------------------------*/
/* Ejemplo en C nº 26: */
/* C026.C */
/* */
/* La orden "while" */
/* */
/* Curso de C, */
/* Nacho Cabanes */
/*---------------------------*/
En este ejemplo, si se introduce 0 la primera vez, la condición es falsa y ni siquiera
se entra al bloque del “while”, terminando el programa inmediatamente.
Nota: si recordamos que una condición falsa se evalúa como el valor 0 y una
condición verdadera como una valor distinto de cero, veremos que ese “while
(numero != 0)” se podría abreviar como “while (numero)”.

Ejercicios propuestos:
Crear un programa que pida al usuario su contraseña (numérica). Deberá terminar
cuando introduzca como contraseña el número 4567, pero volvérsela a pedir
tantas veces como sea necesario.
Crea un programa que escriba en pantalla los números del 1 al 10, usando
?while?.
Crea un programa que escriba en pantalla los números pares del 26 al 10
(descendiendo), usando ?while?.
Crear un programa calcule cuantas cifras tiene un número entero positivo (pista:
se puede hacer dividiendo varias veces entre 10).
3.2.2. do ... while
Este es el otro formato que puede tener la orden “while”: la condición se
comprueba al final. El punto en que comienza a repetirse se indica con la orden
“do”, así:
do
sentencia;

while (condición);
Al igual que en el caso anterior, si queremos que se repitan varias órdenes (es lo
habitual), deberemos encerrarlas entre llaves. Nuevamente, puede ser
recomendable incluir siempre las llaves, como costumbre.
Como ejemplo, vamos a ver cómo sería el típico programa que nos pide una clave
de acceso y nos nos deja entrar hasta que tecleemos la clave correcta. Eso sí,
como todavía no sabemos manejar cadenas de texto, la clave será un número:

for
Ésta es la orden que usaremos habitualmente para crear partes del programa que
se repitan un cierto número de veces. El formato de “for” es
for (valorInicial; CondiciónRepetición; Incremento)
Sentencia;
Recordemos que “contador++” es una forma abreviada de escribir
“contador=contador+1”, de modo que en este ejemplo aumentamos la variable de
uno en uno.

CONTROLES BASICOS

TextBox

Mediante este control podremos realizar tanto la entrada como la salida de datos
en nuestras aplicaciones.
No hace falta que indiquemos las coordenadas de la situación del formulario en
pantalla, simplemente tendremos que marcar sobre el control de la caja de
herramientas y dibujarlo con el tamaño que queramos en nuestro formulario.

Label

Este control es también uno de los más utilizados, aunque su utilidad queda
restringida a la visualización de datos en el mismo, no permitiendo la introducción
de datos por parte del usuario.
La forma de utilizarlo es similar a la del control anterior, dibujar el control en el
formulario con el tamaño que queramos y asignarle un texto en tiempo de diseño o
de ejecución esta vez sin utilizar la propiedad text puesto que no la incorpora, sino
utilizando la propiedad caption.
Este control sirve para mostrar mensajes en nuestro formulario que orienten al
usuario sobre la utilidad de los demás controles que tengamos en la aplicación o
para indicarnos acciones que podemos realizar. En el ejemplo anterior donde
aparecía un textbox en el formulario, hubiera quedado mejor con un mensaje
aclaratorio contenido en un control label:
 CommandButton

Este control es el típico botón que aparece en todas las aplicaciones y que al
hacer click sobre él nos permite realizar alguna operación concreta, normalmente
Aceptar o Cancelar. Aunque según el código que le asociemos podremos realizar
las operaciones que queramos.
En el ejemplo anterior podemos añadir un control de este tipo para salir de la
aplicación sin tener pulsar sobre la equis de la esquina superior derecha.

Pero sólo con introducir un control de este tipo con el texto salir que se introduce a
traves de la propiedad caption no basta. Habrá que asociarle un código que nos
permita salir de la aplicación en el evento adecuado. Y el evento por excelencia de
este control es click. Así pues accederemos al código del control y la sentencia
nos permitirá salir de la aplicación es End, simplemente tecleamos esa palabra en
el evento click y comprobar que realmente finalizaremos nuestra aplicación al
pulsar sobre dicho botón.

OptionButton

Este control nos permite elegir una opción entre varias de las que se nos plantean.
Cada opción será un control optionbutton diferente.
Facilita la introducción de datos por parte del usuario:
De todas las opciones que se nos ofrece, en este caso los 4 colores, sólo
podremos activar una. Si activamos cualquier otra opción, se desactivará
automáticamente la última que teníamos activada.

El marco que está alrededor de los 4 controles optionbutton se trata del

control Frame , es opcional, aunque es conviente colocarlo siempre que hagamos
uso de las opciones. No sólo por motivos de presentación sino porque de esta
manera podremos establecer grupos de controles optionbutton independientes en
los que en cada grupo sólo pueda haber una opcioón activada a la vez. También,
al mover el marco se moverán los controles incluidos en él facilitándonos las
modificaciones.
Para que los controles Optionbutton queden englobados dentro de un
control Frame, primero tendremos que colocar el control Frame en el formulario
con el tamaño adecuado y despues ir colocando los controles Optionbutton dentro
del Frame.
Del control Frame la única propiedad que nos interesará es caption, que es el
texto que aparecerá en el encabezado, en el ejemplo anterior: colores.

PROPIEDADES DE OPTIONBUTTON
Caption: El texto que aparecerá al lado del control: Rojo, verde, etc...
Value: Es el valor que tendrá el control: True si se encuentra activado y False si no
lo está. Para comprobar que opcion ha activado el usuario comprobaremos el
estado de esta propiedad.
Alignment: Alineación del texto respecto al control: Left Justify: el control aparece a
la izquierda del texto. Es el ejemplo anterior.Right Justify: el control aparece a la
derecha del texto.
Los eventos del control son los mismos que en anteriores controles, aunque no se
suele asociar código a los eventos de este tipo de controles, sino únicamente
conocer el valor que tienen: true o false.

APLICACION DE EJEMPLO
Para practicar con los controles que hemos visto vamos a realizar una pequeña
aplicación que consistirá en realizar con 2 números que introduzcamos, una
operación que seleccionemos y mostrar el resultado.
El formulario donde estarán todos los controles es el siguiente:

La propiedad Caption de cada uno de los controles es la que se muestra en el

formulario.
He modificado la propiedad Name de cada control para que al utilizarlos desde el
codigo sepamos cual es el control con el que trabajamos:
Los controles TextBox tienen los nombres: Num1, Num2 y Resul.
Los controles Optionbutton tienen cada uno de ellos el mismo nombre que su
caption
Los controles CommandButton tienen los nombres: Calcular, Limpiar y Salir.
A los controles Label y al Frame no have falta cambiarles el nombre.
Lo que habrá que hacer ahora es asociar codigo a cada uno de los botones que es
de donde se van a
realizar las
operaciones:
 CONCLUSIONES

- Visual Basic es una de las herramientas más populares en el mundo de la

programación.

- Cada uno de los componentes de los diferentes programas son funcionales

en todo momento.

- Es importante aplicarnos en el área de programación y poder lograr

Lo que lograron los estudiantes argentinos con la creación de la aplicación
Pseint.
 BIBLIOGRAFIA

https://runestone.academy/runestone/static/pythoned/Introduction/QueEsPr
ogramacion.html

https://es.wikipedia.org/wiki/PSeInt

http://algoritmoscolegio40.blogspot.com/2012/10/estructuras-en-
pseint_12.html

http://www.aprendeaprogramar.com/mod/resource/view.php?id=607

https://openwebinars.net/blog/que-es-pseudocodigo/

https://www.ecured.cu/Algoritmo