Ver el código de «Pseudocódigo»

{{Referencias adicionales|t=20170507111842}}
En [[ciencias de la computación]], y [[análisis numérico]], el '''pseudocódigo'''<ref>{{cita libro |autor= KENNETH E. KENDALL |autor2= JULIE E. KENDALL |año= 2005 |título= Análisis y diseño de sistemas |url= https://archive.org/details/analisisydisenod00kend |página= [https://archive.org/details/analisisydisenod00kend/page/n15 599] |capítulo= 16 |edición= 6 |editorial= Pearson Educación |idioma= español |isbn= 978-970-260-577-5  }}</ref> (o [[lenguaje]] de descripción algorítmico) es una descripción de [[Lenguaje de alto nivel|alto nivel]] compacta e informal<ref>{{Cita web |título=Pseudocódigo - Estructuras condicionales |url=http://enriquebarrueto0.tripod.com/algoritmos/sesion04algoritmos.htm |fechaacceso=7 de diciembre de 2012}}</ref> del principio operativo de un [[programa informático]] u otro [[algoritmo]]. 

Utiliza las convenciones estructurales de un [[lenguaje de programación]] real,<ref>{{Cita web |título=Instroducción al PseudoCódigo |url=http://micodigo.bligoo.com.uy/instroduccion-al-pseudocodigo |fechaacceso=7 de diciembre de 2012 |urlarchivo=https://web.archive.org/web/20131112162501/http://micodigo.bligoo.com.uy/instroduccion-al-pseudocodigo |fechaarchivo=12 de noviembre de 2013 }}</ref> pero está diseñado para la lectura humana en lugar de la lectura mediante máquina,<ref>{{cita libro |autor= Harvey M. Deitel |autor2= Paul J. Deitel |año= 2004 |título= Como programar en C/C++y Java |página= 51 |capítulo= 3.3 |edición= 4 |editorial= Pearson Educación |idioma= español |isbn= 978-970-26-0531-7 }}</ref> y con independencia de cualquier otro lenguaje de programación.<ref>{{cita libro |apellido= Flores Cueto |nombre= Juan José |año= 2005 |título= Método de las 6'D. UML - Pseudocódigo - Java. |página= 561 |capítulo= V |edición= 1 |editorial= Universidad de Sam Martin de Porres |idioma= español |isbn= }}</ref> Normalmente, el pseudocódigo omite detalles que no son esenciales para la comprensión humana del algoritmo, tales como declaraciones de variables, código específico del sistema y algunas [[subrutina]]s. El lenguaje de programación se complementa, donde sea conveniente, con descripciones detalladas en [[lenguaje natural]], o con [[notación matemática]] compacta. Se utiliza pseudocódigo pues este es más fácil de entender para las personas que el código del lenguaje de programación convencional, ya que es una descripción eficiente y con un entorno independiente de los principios fundamentales de un algoritmo. Se utiliza comúnmente en los libros de texto y publicaciones científicas que se documentan varios algoritmos, y también en la planificación del desarrollo de programas informáticos, para esbozar la estructura del programa antes de realizar la efectiva codificación. Es comúnmente utilizado por los programadores para omitir secciones de Código o para dar una explicación del paradigma que tomó el mismo programador para hacer sus códigos, esto quiere decir que el pseudocódigo no es programable, sino facilita la programación.

El principal objetivo del pseudocódigo es el de representar la solución a un algoritmo de la forma más detallada posible, y a su vez lo más parecida posible al lenguaje que posteriormente se utilizará para la codificación del mismo.

No existe una [[sintaxis]] estándar para el pseudocódigo, aunque los cinco [[Entorno de desarrollo integrado|IDE]]'s que manejan pseudocódigo en español tengan su sintaxis propia. Aunque sea parecido, el pseudocódigo no debe confundirse con los programas esqueleto que incluyen código ficticio, que pueden ser [[compilador|compilados]] sin errores. Los [[Diagrama de flujo|diagramas de flujo]] y [[UML]] pueden ser considerados como una alternativa gráfica al pseudocódigo, aunque sean más amplios

== Aplicaciones ==
Generalmente se utiliza pseudocódigo en los libros de texto y publicaciones científicas relacionadas con la informática y la computación numérica, para la descripción de algoritmos, de manera que todos los programadores puedan entenderlo, aunque no todos conozcan el mismo lenguaje de programación. Generalmente, en los libros de texto se adjunta una explicación que acompaña a la introducción y que explica las convenciones particulares en uso. El nivel de detalle del seudocientífico puede, en algunos casos, acercarse a la de formalizar los idiomas de propósito general.

Un [[programador]] que tiene que aplicar un algoritmo específico, sobre todo uno desfamiliarizado, generalmente comienza con una descripción en pseudocódigo, y luego "traduce" esa descripción en el lenguaje de programación meta y lo modifica para que interactúe correctamente con el resto del programa. Los programadores también pueden iniciar un proyecto describiendo la forma del código en pseudocódigo en el papel antes de escribirlo en su lenguaje de programación, como ocurre en la estructuración de un enfoque de [[top-down y bottom-up|''top-down'' y ''bottom-up'']].

== Sintaxis ==
En la actualidad y por lo general, el pseudocódigo, como su nombre lo indica, no obedece a las reglas de sintaxis de ningún idioma en particular ni es de forma estándar sistemática, a pesar de que cualquier escritor en particular vaya a pedir prestado las [[estructuras de control]] general, la sintaxis y el estilo, por ejemplo, de algún lenguaje de programación convencional. Pero en caso de que se quiera ejecutar, se debe llevar a forma tipo, para que no genere mensajes de error. Las fuentes populares incluyen la sintaxis de [[Pascal (lenguaje de programación)|Pascal]], [[BASIC]], [[C (lenguaje de programación)|C]], [[C++]], [[Java (lenguaje de programación)|Java]], [[Lisp]], y [[ALGOL]]. Por lo general, se omiten las declaraciones de variables. A veces, las llamadas a funciones, los bloques de código y el código contenido dentro de un loop se remplazan por una sentencia de una línea en lenguaje natural.

Este es un ejemplo de pseudocódigo (para el [[juego matemático]] [[bizz buzz]]):

{| class="wikitable"
|-
|
Pseudocódigo estilo [[Fortran]]:
<!-- javascript syntax color works well for pseudocode -->
<syntaxhighlight lang="Fortran">
programa bizzbuzz
hacer i = 1 hasta 100
    establecer print_number a verdadero
    si i es divisible por 3
        escribir "Bizz"
        establecer print_number a falso
    si i es divisible por 5
        escribir "Buzz"
        establecer print_number a falso
    si print_number, escribir i
    escribir una nueva línea
fin del hacer

</syntaxhighlight>

||
Pseudocódigo estilo [[Pascal (lenguaje de programación)|Pascal]]:
<!-- javascript syntax color works well for pseudocode -->
<syntaxhighlight lang="Pascal">
procedimiento bizzbuzz
para i := 1 hasta 100 hacer
    establecer print_number a verdadero;
    Si i es divisible por 3 entonces
        escribir "Bizz";
        establecer print_number a falso;
    Si i es divisible por 5 entonces
        escribir "Buzz";
        establecer print_number a falso;
    Si print_number, escribir i;
    escribir una nueva línea;
fin

</syntaxhighlight>

||
Pseudocódigo estilo [[C (lenguaje de programación)|C]]:

<!-- javascript syntax color works well for pseudocode -->
<syntaxhighlight lang="c">
subproceso funcion bizzbuzz
para (i <- 1; i<=100; i++) {
    establecer print_number a verdadero;
    Si i es divisible por 3
        escribir "Bizz";
        establecer print_number a falso;
    Si i es divisible por 5
        escribir "Buzz";
        establecer print_number a falso;
    Si print_number, escribir i;
    escribir una nueva línea;
}
</syntaxhighlight>

|}

== Definición de datos en pseudocódigo ==

La definición de datos se da por supuesta, sobre todo en las variables sencillas, si se emplea formaciones: pilas, colas, vectores o registros, se pueden definir en la cabecera del algoritmo, y naturalmente cuando empleemos el pseudocódigo para definir estructuras de datos, esta parte la desarrollaremos adecuadamente.

=== Funciones y operaciones ===
Cada autor usa su propio pseudocódigo con sus respectivas convenciones. Por ejemplo, la instrucción "reemplace el valor de la variable <math>x</math> por el valor de la variable <math>y</math>" puede ser representado como:

* '''asigne a <math>x\,</math> el valor de <math>y\,</math>'''
{{definición|
: <math>
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ y; }}
</math>
: <math>
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ := }} \;
   { \color{OliveGreen} \mathit{ y; }}
</math>
: <math>
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ = }} \;
   { \color{OliveGreen} \mathit{ y; }}
</math>
}}

Las operaciones aritméticas se representan de la forma usual en matemáticas.
{{definición|
: <math>
   { \color{Gray}  \mathit{ \{ Esto \; es \; un \; comentario \; normalmente \; matem \acute{a} tico \} }}
</math>
: <math>
   { \color{OliveGreen} \mathrm{ volumen }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Red}  \mathit{ \pi }}
   { \color{Oliveblack} \mathit{ r }} {}^2
   { \color{OliveGreen} \mathit{ h }}
</math>
: <math>
   { \color{Gray}  \mathit{ // y \; este \; es \; otro \; comentario \; normalmente \; de \; texto // }}
</math>
: <math>
   { \color{OliveGreen} \mathrm{ hipotenusa }} \;
   { \color{BlueViolet}  \mathrm{ \gets }} \;
   \sqrt{
      { \color{OliveGreen} \mathit{ a }} {}^2 \;
      { \color{BlueViolet}  \mathit{ + }} \;
      { \color{OliveGreen} \mathit{ b }} {}^2 \;
   }
</math>
: <math>
   { \color{OliveGreen} \mathrm{ resultado }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Tan}   \mathrm{ sin }}
   (
      { \color{OliveGreen} \mathit{ a }}
   )
</math>
}}

== Estructuras de control ==
En la redacción de pseudocódigo se utiliza tres tipos de estructuras de control: las secuenciales,
las selectivas y las iterativas.

==== Estructuras secuenciales====
Las instrucciones se siguen en una secuencia fija que normalmente viene dada por el número de renglón. Es decir que las instrucciones se ejecutan de arriba hacia abajo.
{{definición|
: <math>
   { \color{BlueViolet}  \mathrm{ instrucci \acute{o} n_1; }}
</math>
: <math>
   { \color{BlueViolet}  \mathrm{ instrucci \acute{o} n_2; }}
</math>
: <math>
   { \color{BlueViolet}  \mathrm{ instrucci \acute{o} n_3; }}
</math>
: <math>
   \cdots
</math>
: <math>
   { \color{BlueViolet}  \mathrm{ instrucci \acute{o} n_{\it n}; }}
</math>
}}

==== Estructuras selectivas ====
Las instrucciones selectivas representan instrucciones que pueden o no ejecutarse, según el cumplimiento de una condición.
[[Archivo:Condicional1.png|thumb|200px|Diagrama de flujo que muestra el funcionamiento de la instrucción condicional.]]

{{definición|
: <math>
   { \color{Sepia} \mathrm{ Si }} \;
   { \color{OliveGreen} \mathrm{ condici \acute{o} n }} \;
   { \color{Sepia} \mathrm{ Entonces }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Si }}
</math>
}}

La condición es una expresión booleana. ''Instrucciones'' es ejecutada solo si la condición es verdadera.

==== Selectiva doble (alternativa) ====
La instrucción alternativa realiza una instrucción de dos posibles, según el cumplimiento de una condición.
[[Archivo:Condicional.png|thumb|200px|Diagrama de flujo que muestra el funcionamiento de la instrucción condicional.]]

{{definición|
: <math>
   { \color{Sepia} \mathrm{ Si }} \;
   { \color{OliveGreen} \mathrm{ condici \acute{o} n }} \;
   { \color{Sepia} \mathrm{ Entonces }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones_1; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Si \; no \; Entonces }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones_2; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Si }}
</math>
}}

La condición es una variable booleana o una función reducible a booleana (lógica, Verdadero/Falso). Si esta condición es cierta se ejecuta ''Instrucciones''<sub>1</sub>, si no es así, entonces se ejecuta ''Instrucciones''<sub>2</sub>.

==== Selectiva múltiple ====
También es común el uso de una selección múltiple que equivaldría a anidar varias funciones de selección.
{{definición|
: <math>
   { \color{Sepia} \mathrm{ Si }} \;
   { \color{OliveGreen} \mathrm{ condici \acute{o} n_1 }} \;
   { \color{Sepia} \mathrm{ Entonces }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones_1; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Si \; no \; si }} \;
   { \color{OliveGreen} \mathrm{ condici \acute{o} n_2 }} \;
   { \color{Sepia} \mathrm{ Entonces }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones_2; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Si \; no \; si }} \;
   { \color{OliveGreen} \mathrm{ condici \acute{o} n_3 }} \;
   { \color{Sepia} \mathrm{ Entonces }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones_3; }}
</math>
: <math>
   \cdots
</math>
: <math>
   { \color{Sepia} \mathrm{ Si \; no \; Entonces }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones_{\it n}; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Si }}
</math>
}}

En este caso hay una serie de condiciones que tienen que ser mutuamente excluyentes, si una de ellas se cumple las demás tienen que ser falsas necesariamente, hay un caso '''si no''' que será cierto cuando las demás condiciones sean falsas.

En esta estructura si ''Condición''<sub>1</sub> es cierta, entonces se ejecuta solo ''Instrucciones''<sub>1</sub>. En general, si ''Condición''<sub>i</sub> es verdadera, entonces solo se ejecuta ''Instrucciones''<sub>i</sub>

==== Selectiva múltiple-Casos ====
Una construcción similar a la anterior (equivalente en algunos casos) es la que se muestra a continuación.
{{definición|
: <math>
   { \color{Sepia} \mathrm{ Seg\acute{u}n }} \;
   { \color{OliveGreen} \mathrm{ variable }} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
:: <math>
  { \color{Sepia} \mathrm{ caso }} \;
  { \color{OliveGreen} \mathrm{ valor_1; }}
</math>
::: <math>
  { \color{BlueViolet}  \mathrm{ instrucciones_1; }}
</math>
:: <math>
  { \color{Sepia} \mathrm{ caso }} \;
  { \color{OliveGreen} \mathrm{ valor_2; }}
</math>
::: <math>
  { \color{BlueViolet}  \mathrm{ instrucciones_2; }}
</math>
:: <math>
  { \color{Sepia} \mathrm{ caso }} \;
  { \color{OliveGreen} \mathrm{ valor_3; }}
</math>
::: <math>
  { \color{BlueViolet}  \mathrm{ instrucciones_3; }}
</math>
:: <math>
  \cdots
</math>
:: <math>
  { \color{Sepia} \mathrm{ De \; Otro \; Modo}}
</math>
::: <math>
  { \color{BlueViolet}  \mathrm{ instrucciones_{\it n}; }}
</math>
: <math>
  { \color{Sepia} \mathrm{ Fin \; Seg\acute{u}n }}
</math>
}}

En este caso hay un ''Indicador'' es una variable o una función cuyo valor es comparado en cada caso con los valores "''Valor''<sub>i</sub>", si en algún caso coinciden ambos valores, entonces se ejecutarán las ''Instrucciones''<sub>i</sub> correspondientes. La sección '''en otro caso''' es análoga a la sección '''si no''' del ejemplo anterior.

== Estructuras iterativas ==
Las instrucciones iterativas representan la ejecución de instrucciones en más de una vez.

=== Bucle mientras ===
{{AP|Bucle while}}
El bucle se repite mientras la condición sea cierta, si al llegar por primera vez al bucle mientras la condición es falsa, el cuerpo del bucle no se ejecuta alguna vez.
[[Archivo:Ciclo mientras.png|thumb|200px|Diagrama de flujo que muestra el funcionamiento de la instrucción ''mientras'']]

{{definición|
: <math>
   { \color{Sepia} \mathrm{ Mientras }} \;
   { \color{OliveGreen} \mathrm{ condici \acute{o} n }} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Mientras }}
</math>}}

=== Bucle repetir ===
Existen otras variantes que se derivan a partir de la anterior. La estructura de control ''repetir'' se utiliza cuando es necesario que el cuerpo del bucle se ejecuten al menos una vez y hasta que se cumpla la condición:
{{definición|
: <math>
   { \color{Sepia} \mathrm{ Repetir }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Hasta \; Que }} \;
   { \color{OliveGreen} \mathrm{ condici \acute{o} n }}
</math>}}

La estructura anterior equivaldría a escribir:
{{definición|
: <math>
   { \color{BlueViolet} \mathrm{ instrucciones; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Mientras }} \;
   { \color{BlueViolet}  \mathrm{ \neg }}
   (
      { \color{OliveGreen} \mathrm{ condici \acute{o} n }}
   ) \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Mientras }}
</math>
}}

=== Bucle hacer ===
El Bucle hacer se utiliza para repetir un [[bloque de código]] mientras se cumpla cierta condición.
{{definición|
: <math>
   {\color{Sepia}      \mathrm{ Hacer }} \;
</math>
:: <math>
   {\color{BlueViolet} \mathrm{ instrucciones; }} \;
</math>
: <math>
   {\color{Sepia} \mathrm{ Mientras}} \;
   {\color{OliveGreen} \mathrm{ condici \acute{o} n }}
</math>
}}

=== Bucle para ===
{{AP|Bucle for}}
Una estructura de control muy común es el ciclo ''FOR'', la cual se usa cuando se desea iterar un número conocido de veces, empleando como índice una variable que se incrementa (o decrementa):
{{definición|
: <math>
   { \color{Sepia} \mathrm{ Para }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{Sepia} \mathrm{ Hasta }} \;
   { \color{OliveGreen} \mathit{ n }} \;
   { \color{Sepia} \mathrm{ Con \; Paso }} \;
   { \color{OliveGreen} \mathit{ z}} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Para }}
</math>
}}

la cual se define como:
{{definición|
: <math>
   { \color{OliveGreen} \mathit{ i}} \;
   { \color{BlueViolet}  \mathrm{ \gets }} \;
   { \color{OliveGreen} \mathit{ x}}
</math>
: <math>
   { \color{Sepia} \mathrm{ Mientras }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ \leq }} \;
   { \color{OliveGreen} \mathit{ n }} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones; }}
</math>
:: <math>
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathrm{ \gets }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathrm{ + }} \;
   { \color{OliveGreen} \mathit{ z; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Mientras }}
</math>
}}

=== Bucle para cada ===
Por último, también es común usar la estructura de control ''para cada''. Esta sentencia se usa cuando se tiene una [[Lista enlazada|lista]] o un [[conjunto]] <math>L</math> y se quiere iterar por cada uno de sus elementos:
{{definición|
: <math>
   { \color{Sepia} \mathrm{ Para \; Cada }} \;
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \in }} \;
   { \color{OliveGreen} \mathit{ L }} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Para \; Cada }}
</math>
}}

Si asumimos que los elementos de <math>L</math> son <math>L_0,L_1,\dots,L_n</math>, entonces esta sentencia equivaldría a:
{{definición|
: <math>
   { \color{Sepia} \mathrm{ Para }} \;
   { \color{OliveGreen} \mathit{ i}} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathrm{ 0}} \;
   { \color{Sepia} \mathrm{ Hasta }} \;
   { \color{OliveGreen} \mathit{ n}} \;
   { \color{Sepia} \mathrm{ Con \; Paso }} \;
   { \color{OliveGreen} \mathrm{ 1}} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
:: <math>
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets}} \;
   { \color{OliveGreen} \mathit{ L_i }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Para }}
</math>}}

Que es lo mismo que:
{{definición|
: <math>
   { \color{Sepia} \mathrm{ Para }} \;
   { \color{OliveGreen} \mathit{ i}} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathrm{ 0}} \;
   { \color{Sepia} \mathrm{ Hasta }} \;
   { \color{OliveGreen} \mathit{ n}} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
:: <math>
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets}} \;
   { \color{OliveGreen} \mathit{ L_i }}
</math>
:: <math>
   { \color{BlueViolet}  \mathrm{ instrucciones; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Para }}
</math>}}

Sin embargo, en la práctica existen mejores formas de implementar esta instrucción dependiendo del problema.

Es importante recalcar que el pseudocódigo no es un lenguaje estandarizado. Eso significa que diferentes autores podrían dar otras estructuras de control o bien usar estas mismas estructuras, pero con una notación diferente. Sin embargo, las funciones matemáticas y lógicas toman el significado usual que tienen en matemática y lógica, con las mismas expresiones.

=== El anidamiento ===
Cualquier instrucción puede ser sustituida por una estructura de control. El siguiente ejemplo muestra el pseudocódigo del [[ordenamiento de burbuja]], que tiene varias estructuras anidadas. Este algoritmo ordena de menor a mayor los elementos de una lista <math>L</math>.
{{definición|<math>
\begin{array}{l}
{ \color{Sepia} \mathrm{Procedimiento} } \;
{ \color{BlueViolet} \mathrm{Ordenar} } \; (
{ \color{OliveGreen} L} \; ) \\
 \left \updownarrow
 \begin{array}{l}
 { \color{Gray} // Comentario: \; L=(L_1,L_2,\dots,L_n) \; es \; una \; lista \; con \; n \; elementos // } \\
 { \color{OliveGreen} k } \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} 0;} \\
 { \color{Sepia} \mathrm{Repetir} } \\
 \left \updownarrow
 \begin{array}{l}
 { \color{OliveGreen} \mathrm{intercambio} } \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} \mathrm{Falso};} \\
 { \color{OliveGreen} k } \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} k + 1;} \\
 { \color{Sepia} \mathrm{Para} } \;
 { \color{OliveGreen} i} \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} 1} \;
 { \color{Sepia} \mathrm{Hasta} } \;
 { \color{OliveGreen} n - k} \;
 { \color{Sepia} \mathrm{Con \; Paso} } \;
 { \color{OliveGreen} 1} \;
 { \color{Sepia} \mathrm{Hacer} } \\
 \left \updownarrow
 \begin{array}{l}
 { \color{Sepia} \mathrm{Si} } \;
 { \color{OliveGreen} L_i } \;
 { \color{BlueViolet} > } \;
 { \color{OliveGreen} L_{i+1} } \;
 { \color{Sepia} \mathrm{Entonces} } \; \\
 \left \updownarrow
 \begin{array}{l}
 { \color{BlueViolet} \mathrm{intercambiar} } \; (
 { \color{OliveGreen} L_i , L_{i+1} } \; ) \\
 { \color{OliveGreen} \mathrm{intercambio} } \;
 { \color{BlueViolet} \gets } \;
 { \color{OliveGreen} \mathrm{Verdadero};}
 \end{array}
 \right . \\
 { \color{Sepia} \mathrm{Fin \; Si} } \; \\
 \end{array}
 \right . \\
 { \color{Sepia} \mathrm{Fin \; Para} } \\
 \end{array}
 \right . \\
{ \color{Sepia} \mathrm{Hasta \; Que} } \;
 { \color{OliveGreen} \mathrm{intercambio} } \;
 { \color{bluet} = } \;
 { \color{OliveGreen} \mathrm{Falso};}
\end{array}
\right . \\
{ \color{Sepia} \mathrm{Fin \; Procedimiento} } \; \\
\end{array}
</math>}}

En general, las estructuras anidadas se muestran indentadas, para hacer más sencilla su identificación a simple vista.
En el ejemplo, además de la sangría, se ha conectado con flechas los pares de delimitadores de cada nivel de anidamiento.

=== Funciones y procedimientos ===
Muchas personas prefieren distinguir entre ''funciones'' y ''procedimientos''. Una ''función'', al igual que una [[función matemática]], recibe uno o varios valores de ''entrada'' y regresa una ''salida'' mientras que un ''procedimiento'' recibe una entrada y no genera alguna salida aunque en algún caso podría devolver resultados a través de sus parámetros de entrada si estos se han declarado por referencia (ver [[Argumento (informática)#Paso de Argumentos|formas de pasar argumentos a una función o procedimiento]]).

En ambos casos es necesario dejar en claro cuáles son las entradas para el algoritmo, esto se hace comúnmente colocando estos valores entre paréntesis al principio o bien declarándolo explícitamente con un enunciado. En el caso de las funciones, es necesario colocar una palabra como '''regresar''' o '''devolver''' para indicar cuál es la salida generada por el algoritmo. Por ejemplo, el pseudocódigo de una función que permite calcular <math>a^n</math> (un número <math>a</math> elevado a potencia <math>n</math>).
{{definición|
: <math>
   { \color{Sepia} \mathrm{ Funci \acute{o} n }} \;
   { \color{BlueViolet}  \mathrm{ potencia }} \;
   (
      { \color{OliveGreen} \mathit{ a,n}}
   )
</math>
: <math>
   { \color{Gray} \mathit{
      // Comentario: \; Este \; algoritmo \; calcula \; a^n \; con \;
      a \; y \; n \; n \acute{u} meros \; naturales // }}
</math>
:: <math>
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ n; }}
</math>
:: <math>
   { \color{OliveGreen} \mathit{ r }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Plum}  \mathrm{ 1;}}
</math>
:: <math>
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ a; }}
</math>
:: <math>
   { \color{Sepia} \mathrm{ Mientras }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ > }} \;
   { \color{Plum}  \mathrm{ 0 }} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
::: <math>
   { \color{Sepia} \mathrm{ Si }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet} \mathit{ \% }} \;
   { \color{Plum}  \mathrm{ 2}}
   { \color{BlueViolet}  \mathit{ \neq }} \;
   { \color{Plum}  \mathrm{ 0}} \;
   { \color{Sepia} \mathrm{ Entonces }} \;
   { \color{Gray} \mathit{
      //\; Si \; i \; es \; impar \; (\% \; es \; resto)}}
</math>
:::: <math>
   { \color{OliveGreen} \mathit{ r }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ r }} \;
   { \color{BlueViolet}  \mathit{ * }} \;
   { \color{OliveGreen} \mathit{ x; }}
</math>
::: <math>
   { \color{Sepia} \mathrm{ Fin \; Si }}
</math>
::: <math>
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ x }} \;
   { \color{BlueViolet}  \mathit{ * }} \;
   { \color{OliveGreen} \mathit{ x; }}
</math>
::: <math>
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{BlueViolet}  \mathit{ / }} \;
   { \color{Plum}  \mathrm{ 2; }} \;
</math>
:: <math>
   { \color{Sepia} \mathrm{ Fin \; Mientras }}
</math>
:: <math>
   { \color{Sepia} \mathrm{ Escribir }} \;
   { \color{OliveGreen} \mathit{ r; }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Funci \acute{o} n }}
</math>
}}

Un ejemplo de procedimiento sería el algoritmo de [[ordenamiento de burbuja]], por el que partiendo de una lista de valores estos se ordenan, nótese que en un procedimiento, no se calcula el valor de una función, sino que se realiza una acción, en este caso ordenar la lista.
{{definición|
: <math>
   { \color{Sepia} \mathrm{ Procedimiento }} \;
   { \color{BlueViolet}  \mathrm{ DeLaBurbuja }} \;
   (
      { \color{OliveGreen}  \mathit{ a }}
      { \color{Plum}   \mathrm{ {}_0 }} ,
      { \color{OliveGreen}  \mathit{ a }}
      { \color{Plum}   \mathrm{ {}_1 }} ,
      { \color{OliveGreen}  \mathit{ a }}
      { \color{Plum}   \mathrm{ {}_2 }} ,
      \ldots,
      { \color{OliveGreen}  \mathrm{ a }} {}_(
      { \color{OliveGreen}  \mathit{ {}_n }}
      { \color{BlueViolet}   \mathit{ {}_- }}
      { \color{Plum}   \mathrm{ {}_1}} {}_)
   )
</math>
:: <math>
   { \color{Sepia} \mathrm{ Para }} \;
   { \color{OliveGreen} \mathit{ i}} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Plum}  \mathrm{ 2}} \;
   { \color{Sepia} \mathrm{ Hasta }} \;
   { \color{OliveGreen} \mathit{ n}} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
::: <math>
   { \color{Sepia} \mathrm{ Para }} \;
   { \color{OliveGreen} \mathit{ j}} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{Plum} \mathrm{ 0}} \;
   { \color{Sepia} \mathrm{ Hasta }} \;
   { \color{OliveGreen} \mathit{ n }} \;
   { \color{BlueViolet}  \mathit{ - }} \;
   { \color{OliveGreen} \mathit{ i }} \;
   { \color{Sepia} \mathrm{ Hacer }}
</math>
:::: <math>
   { \color{Sepia} \mathrm{ Si }} \;
   { \color{OliveGreen} \mathit{ a }}    {}_(
   { \color{OliveGreen} \mathit{ {}_j }} {}_) \;
   { \color{BlueViolet}  \mathit{ < }} \;
   { \color{OliveGreen} \mathit{ a }} {}_(
   { \color{OliveGreen} \mathit{ {}_j }}
   { \color{BlueViolet}  \mathit{ {}_+ }}
   { \color{Plum}  \mathrm{ {}_1}} {}_) \;
   { \color{Sepia} \mathrm{ Entonces }}
</math>

::::: <math>
   { \color{OliveGreen} \mathrm{ aux }} \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ a }}    {}_(
   { \color{OliveGreen} \mathit{ {}_j }} {}_) \;
</math>
::::: <math>
   { \color{OliveGreen} \mathit{ a }}    {}_(
   { \color{OliveGreen} \mathit{ {}_j }} {}_) \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathit{ a }} {}_(
   { \color{OliveGreen} \mathit{ {}_j }}
   { \color{BlueViolet}  \mathit{ {}_+ }}
   { \color{Plum}  \mathrm{ {}_1}} {}_)
</math>
::::: <math>
   { \color{OliveGreen} \mathit{ a }} {}_(
   { \color{OliveGreen} \mathit{ {}_j }}
   { \color{BlueViolet}  \mathit{ {}_+ }}
   { \color{Plum}  \mathrm{ {}_1}} {}_) \;
   { \color{BlueViolet}  \mathit{ \gets }} \;
   { \color{OliveGreen} \mathrm{ aux }}
</math>
:::: <math>
   { \color{Sepia} \mathrm{ Fin \; Si }}
</math>
::: <math>
   { \color{Sepia} \mathrm{ Fin \; Para }}
</math>
:: <math>
   { \color{Sepia} \mathrm{ Fin \; Para }}
</math>
: <math>
   { \color{Sepia} \mathrm{ Fin \; Procedimiento }}
</math>
}}

== Desarrollo de algoritmos ==
Con el pseudocódigo se puede desarrollar cualquier algoritmo que:

* Tenga un único punto de inicio.
* Tenga un número finito de posibles puntos de término.
* Halla un número finito de caminos, entre el punto de inicio y los posibles puntos de término.

=== Ventajas del pseudocódigo sobre los diagramas de flujo ===
El uso de pseudocódigo<ref>{{Cita web|url=https://informaticamaestra.com/pseudocodigo/|título=Pseudocódigo Ejemplos y Ejercicios|fechaacceso=2024-04-12|sitioweb=Informatica Maestra|idioma=es}}</ref> ofrece una serie de ventajas:

# '''Eficiencia espacial''': Requiere menos espacio durante el desarrollo del problema en comparación con los diagramas de flujo.
# '''Facilidad para representar operaciones complejas repetitivas''': Permite expresar de manera sencilla y comprensible operaciones que se repiten en el problema de forma compleja.
# '''Transición más sencilla a lenguajes de programación formales''': Facilita la transición del pseudocódigo a un lenguaje de programación formal, simplificando así el proceso de codificación.
# '''Estructura visualmente clara''': Al seguir las reglas de sangría, se pueden observar claramente los niveles en la estructura del programa, lo que facilita su comprensión y mantenimiento.
# '''Facilita el aprendizaje''': En el proceso de enseñanza de la programación, los alumnos están más cerca del siguiente paso (codificación en un lenguaje específico) cuando utilizan pseudocódigo en comparación con los diagramas de flujo.
# '''Mejora la claridad de la solución''': Proporciona una solución más clara y comprensible para el problema en cuestión.

== Véase también ==
{{Columnas}}
* [[PSeInt]]
* [[Algoritmo]]
* [[Programación]]
* [[Resolución de problemas de programación]]
* [[Diagrama de flujo]]
* [[Estructuras de control]]
{{Nueva columna}}
* [[Bucle (programación)]]
* [[Bucle for]]
* [[Bucle do]]
* [[Bucle while]]
* [[Bucle repetir]]
* [[Bucle infinito]]
{{Final columnas}}

== Enlaces externos ==
* [https://web.archive.org/web/20180618230245/http://www.uaa.mx/direcciones/dgdv/editorial/docs/algoritmos.pdf PROBLEMARIO DE ALGORITMOS RESUELTOS CON DIAGRAMAS DE FLUJO Y  PSEUDOCÓDIGO]
* [http://mmc.geofisica.unam.mx/acl/Herramientas/Programacion/DiagramasFlujoYPseudocodigo/Pseudocodigo.pdf Guía práctica de estudio 04: Pseudocódigo] {{Wayback|url=http://mmc.geofisica.unam.mx/acl/Herramientas/Programacion/DiagramasFlujoYPseudocodigo/Pseudocodigo.pdf |date=20201030215650 }}
* [http://www.algoritmos.cedetec.cl/images/pdf/Pseudocodigo.pdf Pseudocódigo]
* [https://www.academia.edu/33629823/Libro_de_Dise%C3%B1o_de_Algoritmos_en_Pseudoc%C3%B3digo_y_Ordinogramas Libro de Diseño de Algoritmos en Pseudocódigo y Ordinogramas]
* [http://www.utm.mx/~mgarcia/DA3(Definiciones).pdf UNIDAD II: ALGORITMOS Y PSEUDOCÓDIGO]
* [https://mirayhazlo.com/que-es-un-pseudocodigo-y-para-que-sirve/ ¿Que es un pseudocodigo y para qué sirve? Aprendamos lo básico.]

== Referencias ==
{{listaref}}

== Bibliografía ==
# {{Cita libro|apellidos=Peña Marí |nombre=Ricardo |título=Diseño de programas: formalismo y abstracción |edición=3 |año=2005 |editorial=Pearson Alhambra|isbn=978-84-205-4191-4 |página=488}}
# {{Cita libro |título=Pseudocódigos y programación estructurada |edición=1 |fecha = 2  de 1997|editorial=Centro Técnico Europeo de Enseñanzas Profesionales|isbn=978-84-8199-065-2}}
# {{Cita libro|apellidos=Brassard |nombre=Gilles|autor2=Bratley, Paul|otros=Peña Mari, Ricardo Tr. |título=Algorítmica: concepción y análisis |edición=1 |año=1996 |editorial=Masson, S.A.|isbn=978-84-458-0535-0 |página=384}}
# {{Cita libro |editor=Rodeira |título=Pseudocódigos e programación estructurada |edición=1 |fecha = 6  de 1994|idioma=gallego |isbn=978-84-8116-287-5}}
# {{Cita libro |editor=Edebé |título=Pseudocódigos y programación estructurada |edición=1 |año=1993|mes=8|isbn=978-84-236-3126-1}}

{{Control de autoridades}}
[[Categoría:Programación]]
[[Categoría:Diseño de software]]