{"id":7831,"date":"2023-04-20T11:31:30","date_gmt":"2023-04-20T16:31:30","guid":{"rendered":"https:\/\/abudinen.com\/blog\/?p=7831"},"modified":"2023-04-20T11:31:30","modified_gmt":"2023-04-20T16:31:30","slug":"fundamentos-de-programacion","status":"publish","type":"post","link":"https:\/\/abudinen.com\/blog\/2023\/04\/20\/fundamentos-de-programacion\/","title":{"rendered":"Fundamentos de Programaci\u00f3n"},"content":{"rendered":"\nPresentaci\u00f3n de la Materia Fundamentos de Programaci\u00f3n es una asignatura b\u00e1sica que permite crear programas que exhiban un comportamiento deseado. El proceso de escribir c\u00f3digo requiere frecuentemente conocimientos en varias \u00e1reas distintas, adem\u00e1s del dominio del lenguaje a utilizar, algoritmos especializados y l\u00f3gica formal.\n\n\n\nCon esta materia el alumno aprender\u00e1 a escribir, a analizar, probar, depurar y dar mantenimiento al programa generado en un Lenguaje de Programaci\u00f3n.\n\n\n\nContenido Programatico Videos de actualidad tecnol\u00f3gica\n\n\n\nIntroducci\u00f3n\n\n\n\nProgramaci\u00f3n\n\n\n\nSe llama Programaci\u00f3n a la implementaci\u00f3n de un algoritmo en un determinado lenguaje de programaci\u00f3n, para realizar un programa.\n\n\n\nAlgoritmo es una secuencia no ambigua, finita y ordenada de instrucciones que han de seguirse para resolver un problema.\n\n\n\nPrograma (Software en ingl\u00e9s) es una secuencia de instrucciones que una computadora puede interpretar y ejecutar.\n\n\n\nEl proceso de creaci\u00f3n de software es materia de la ingenier\u00eda del software, una de las ramas propias de la Ingenier\u00eda Inform\u00e1tica.\n\n\n\nSeg\u00fan Niklaus Wirth un programa est\u00e1 formado por algoritmos y estructura de datos.\n\n\n\nSe han propuesto diversas t\u00e9cnicas de programaci\u00f3n, cuyo objetivo es mejorar tanto el proceso de creaci\u00f3n de software como su mantenimiento. Entre ellas se pueden mencionar las programaciones lineal, estructurada, modular y orientada a objetos\n\n\n\nSoftware Utilizado pa[...x]<\/span>
ra la Materia<\/strong> Se usara un Programa para ejecuci\u00f3n de Pseudoc\u00f3digos el cual se puede bajar de:<\/p>\n\n\n\n

<\/p>\n\n\n\n

Adicionalmente el CodeBlocks se puede bajar de la siguiente direcci\u00f3n:<\/p>\n\n\n\n

<\/p>\n\n\n\n

U<\/u>NIDAD  1:   Lenguaje Algor\u00edtmico y Estructuras de <\/strong>Control. Algoritmos. Definici\u00f3n formal de Algoritmo<\/strong><\/p>\n\n\n\n

En general, no existe ning\u00fan consenso definitivo en cuanto a la definici\u00f3n formal de algoritmo.<\/p>\n\n\n\n

Muchos autores los se\u00f1alan como listas de instrucciones para resolver un problema abstracto, es decir, que un n\u00famero finito de pasos convierten los datos de un problema (entrada) en una soluci\u00f3n (salida). Sin embargo cabe notar que algunos algoritmos no necesariamente tienen que terminar o resolver un problema en particular.<\/p>\n\n\n\n

 Por ejemplo, una versi\u00f3n modificada de la premisa de Erat\u00f3stenes\u201d que nunca termine de calcular n\u00fameros primos no deja de ser un algoritmo.<\/p>\n\n\n\n

A lo largo de la historia varios autores han tratado de definir formalmente a los algoritmos utilizando modelos matem\u00e1ticos como m\u00e1quinas de Turing entre otros Sin embargo, estos modelos est\u00e1n sujetos a un tipo particular de datos como son n\u00fameros, s\u00edmbolos o gr\u00e1ficas mientras que, en general, los algoritmos funcionan sobre una vasta cantidad de estructuras de datos. En general, la parte com\u00fan en todas las definiciones se puede resumir en las siguientes tres propiedades siempre y cuando no consideremos algoritmos paralelos:<\/p>\n\n\n\n

Tiempo secuencial<\/strong>. Un algoritmo funciona en tiempo discretizado \u2013paso a paso\u2013, definiendo as\u00ed una secuencia de estados “computacionales<\/em>” por cada entrada v\u00e1lida (la entrada<\/em> son los datos que se le suministran al algoritmo antes de comenzar).<\/p>\n\n\n\n

Estado abstracto<\/strong>. Cada estado computacional puede ser descrito formalmente utilizando una Estructura de primer orden y cada algoritmo es independiente de su implementaci\u00f3n (los algoritmos son objetos abstractos) de manera que en un algoritmo las estructuras de primer orden son invariantes bajo isomorfismo.<\/p>\n\n\n\n

Exploraci\u00f3n acotada<\/strong>. La transici\u00f3n de un estado al siguiente queda completamente determinada por una descripci\u00f3n fija y finita; es decir, entre cada estado y el siguiente solamente se puede tomar en cuenta una cantidad fija y limitada de t\u00e9rminos del estado actual.<\/p>\n\n\n\n

En resumen, un algoritmo es cualquier cosa que funcione paso a paso, donde cada paso se pueda describir sin ambig\u00fcedad y sin hacer referencia a una computadora en particular, y adem\u00e1s tiene un l\u00edmite fijo en cuanto a la cantidad de datos que se pueden leer\/escribir en un solo paso. Esta amplia definici\u00f3n abarca tanto a algoritmos pr\u00e1cticos como aquellos que solo funcionan en teor\u00eda, por ejemplo el M\u00e9todos de Newton y la eliminaci\u00f3n Gauss – Jordan funcionan, al menos en principio, con n\u00fameros de precisi\u00f3n infinita; sin embargo no es posible programar la precisi\u00f3n infinita en una computadora, y no por ello dejan de ser algoritmos.<\/p>\n\n\n\n

En particular es posible considerar una cuarta propiedad que puede ser usada para validar la Tesis de Curch- Turing de que toda funci\u00f3n calculable se puede programar en una m\u00e1quina de Turing (o equivalentemente, en un lenguaje de programaci\u00f3n suficientemente general)<\/p>\n\n\n\n

Aritmetizabilidad<\/strong>. Solamente operaciones innegablemente calculables est\u00e1n disponibles en el paso inicial.<\/p>\n\n\n\n

Medios de expresi\u00f3n de un algoritmo<\/strong> Los algoritmos pueden ser expresados de muchas maneras, incluyendo al lenguaje natural, pseudoc\u00f3digo,diagramas de flujo y lenguajes de programaci\u00f3n entre otros.<\/p>\n\n\n\n

Las descripciones en lenguaje natural tienden a ser ambiguas y extensas. El usar pseudoc\u00f3digo y diagramas de flujo evita muchas ambig\u00fcedades del lenguaje natural.<\/p>\n\n\n\n

Dichas expresiones son formas m\u00e1s estructuradas para representar algoritmos; no obstante, se mantienen independientes de un lenguaje de programaci\u00f3n espec\u00edfico.<\/p>\n\n\n\n

La descripci\u00f3n de un algoritmo usualmente se hace en tres niveles:<\/p>\n\n\n\n

    \n
  1. Descripci\u00f3n de alto nivel<\/strong>. Se establece el problema, se selecciona un modelo matem\u00e1tico y se explica el algoritmo de manera verbal, posiblemente con ilustraciones y omitiendo detalles.<\/li>\n\n\n\n
  2. Descripci\u00f3n formal<\/strong>. Se usa pseudoc\u00f3digo para describir la secuencia de pasos que encuentran la soluci\u00f3n.<\/li>\n\n\n\n
  3. Implementaci\u00f3n<\/strong>. Se muestra el algoritmo expresado en un lenguaje de programaci\u00f3n espec\u00edfico o alg\u00fan objeto capaz de llevar a cabo instrucciones.<\/li>\n<\/ol>\n\n\n\n

    Tambi\u00e9n es posible incluir un teorema que demuestre que el algoritmo es correcto, un an\u00e1lisis de complejidad o ambos.<\/p>\n\n\n\n

    Representaci\u00f3n de Algoritmos<\/strong> Hay distintos m\u00e9todos de representar los algoritmos como:
    o Texto: Se usa el lenguaje com\u00fan para describir el algoritmo<\/p>\n\n\n\n

    o Pseudoc\u00f3digo: este tipo de representaci\u00f3n mezcla el lenguaje de programaci\u00f3n con un idioma, ya sea espa\u00f1ol, ingles o cualquier otro, se puede definir como un lenguaje de especificaci\u00f3n de algoritmos. Es la representaci\u00f3n narrativa de los pasos que debe de seguir un algoritmo. Este m\u00e9todo es mas compacto, mas f\u00e1cil de escribir y mas f\u00e1cil de transcribir a un lenguaje de programaci\u00f3n que el diagrama de flujo.<\/p>\n\n\n\n

    o Diagrama de flujo: son herramientas graficas para representar algoritmos. esta compuesto por s\u00edmbolos, como: rect\u00e1ngulos rombos, cuadrados, etc., unidos por flechas, estos s\u00edmbolos representan acciones y orden en como se realizan estas. Es decir, los diagramas de flujo son diagramas que emplean s\u00edmbolos gr\u00e1ficos para representar algoritmos.

    o Diagrama de Nassi-Schneiderman: Tambi\u00e9n conocido como diagrama de Chap\u00edn, es un m\u00e9todo se representaci\u00f3n de algoritmos que combina la descripci\u00f3n textual con la descripci\u00f3n grafica, es como una combinaci\u00f3n del Pseudoc\u00f3digo con el diagrama de flujo. Por lo general todo lo que se puede representar en un diagrama de flujo se puede representar en este tipo de diagrama. Este tipo de representaci\u00f3n cuenta con un conjunto limitado de s\u00edmbolos para representar los pasos del algoritmo<\/p>\n\n\n\n

    El diagrama Nassi-Shneiderman refleja la descomposici\u00f3n del problema en una forma simple usando cajas anidadas para representar cada uno de los sub-problemas. Ejemplos:

    o Nivel de implementaci\u00f3n: consiste en expresar un algoritmo mediante una maquinaria, un programa de computadora o alg\u00fan objeto que realice las acciones planteadas por el algoritmo en cuesti\u00f3n. En general, la implementaci\u00f3n es el objetivo de dise\u00f1ar un algoritmo (pero no siempre).<\/p>\n\n\n\n

     Descripci\u00f3n Narrada<\/strong><\/p>\n\n\n\n

    Este algoritmo es caracterizado porque sigue un proceso de ejecuci\u00f3n com\u00fan y l\u00f3gico, describiendo textualmente paso a paso cada una de las actividades a realizar dentro de una actividad determinada.<\/p>\n\n\n\n

    Ejemplo 1 Algoritmo para asistir a clases:<\/p>\n\n\n\n

    1. Levantarse<\/p>\n\n\n\n

    2. Ba\u00f1arse<\/p>\n\n\n\n

    3. Vestirse<\/p>\n\n\n\n

    4. Desayunar<\/p>\n\n\n\n

    5. Cepillarse los dientes<\/p>\n\n\n\n

    6. Salir de casa<\/p>\n\n\n\n

    7. Tomar el autob\u00fas<\/p>\n\n\n\n

    8. Llegar a la ESPE<\/p>\n\n\n\n

    9. Buscar el aula<\/p>\n\n\n\n

    10. Ubicarse en un asiento<\/p>\n\n\n\n

    Pseudoc\u00f3digo<\/strong> El pseudoc\u00f3digo (falso lenguaje<\/em>, el prefijo pseudo<\/em>significa falso<\/em>) es una descripci\u00f3n de alto nivel de un algoritmo que emplea una mezcla de lenguaje natural con algunas convenciones sint\u00e1cticas propias de lenguajes de programaci\u00f3n, como asignaciones, ciclos y condicionales, aunque no est\u00e1 regido por ning\u00fan est\u00e1ndar. Es utilizado para describir algoritmos en libros y publicaciones cient\u00edficas, y como producto intermedio durante el desarrollo de un algoritmo, como los Diagramas de flujo, aunque presentan una ventaja importante sobre estos, y es que los algoritmos descritos en pseudoc\u00f3digo requieren menos espacio para representar instrucciones complejas.<\/p>\n\n\n\n

    El pseudoc\u00f3digo est\u00e1 pensado para facilitar a las personas el entendimiento de un algoritmo, y por lo tanto puede omitir detalles irrelevantes que son necesarios en una implementaci\u00f3n. Programadores diferentes suelen utilizar convenciones distintas, que pueden estar basadas en la sintaxis de lenguajes de programaci\u00f3n concretos. Sin embargo, el pseudoc\u00f3digo, en general, es comprensible sin necesidad de conocer o utilizar un entorno de programaci\u00f3n espec\u00edfico, y es a la vez suficientemente estructurado para que su implementaci\u00f3n se pueda hacer directamente a partir de \u00e9l.<\/p>\n\n\n\n

    As\u00ed el pseudodoc\u00f3digo cumple con las funciones antes mencionadas para representar algo abstracto los protocolos son los lenguajes para la programaci\u00f3n. Busque fuentes m\u00e1s precisas para tener mayor comprensi\u00f3n del tema.<\/p>\n\n\n\n

    Ejemplo 1<\/p>\n\n\n\n

    Dise\u00f1ar un algoritmo que lea cuatro variables y calcule e imprima su producto, suma y media aritm\u00e9tica.<\/p>\n\n\n\n

    inicio<\/p>\n\n\n\n

    leer (a, b, c, d)<\/p>\n\n\n\n

    producto <– (a * b * c * d)<\/p>\n\n\n\n

    suma <– (a + b + c + d)<\/p>\n\n\n\n

    media <– (a + b + c + d) \/ 4<\/p>\n\n\n\n

    escribir (producto, suma, media)<\/p>\n\n\n\n

    fin<\/p>\n\n\n\n

    Diagramas N-S<\/strong><\/p>\n\n\n\n

    Son herramientas que favorece la programaci\u00f3n estructurada y re\u00fane caracter\u00edsticas gr\u00e1ficas propias de diagramas de flujo y ling\u00fc\u00edsticas propias de pseudoc\u00f3digos. Constan de una serie de cajas contiguas que se leer\u00e1n siempre de arriba-abajo y sus estructuras l\u00f3gicas son las siguientes:<\/p>\n\n\n\n

    Estructura Secuencial<\/p>\n\n\n\n

    <\/figure>\n\n\n\n
    <\/figure>\n\n\n\n
    <\/figure>\n\n\n\n
    <\/figure>\n\n\n\n
    <\/figure>\n\n\n\n

    Diagrama de flujo<\/strong><\/p>\n\n\n\n

    Son la representaci\u00f3n gr\u00e1fica de la soluci\u00f3n algor\u00edtmica de un problema. Para dise\u00f1arlos se utilizan determinados s\u00edmbolos o figuras que representan una acci\u00f3n dentro del procedimiento. Utilizan unos s\u00edmbolos normalizados, con los pasos del algoritmo escritos en el s\u00edmbolo adecuado y los s\u00edmbolos unidos con flechas, denominadas l\u00edneas de flujo, que indican el orden en que los pasos deben ser ejecutados.<\/p>\n\n\n\n

    <\/figure>\n\n\n\n

    La Figura de Diagramas de Flujo que expresa un algoritmo para calcular la ra\u00edz cuadrada de un n\u00famero<\/p>\n\n\n\n

    Los diagramas de flujo son descripciones gr\u00e1ficas de algoritmos; usan s\u00edmbolos conectados con flechas para indicar la secuencia de instrucciones y est\u00e1n regidos por ISO.<\/p>\n\n\n\n

    Los diagramas de flujo son usados para representar algoritmos peque\u00f1os, ya que abarcan mucho espacio y su construcci\u00f3n es laboriosa. Por su facilidad de lectura son usados como introducci\u00f3n a los algoritmos, descripci\u00f3n de un lenguaje y descripci\u00f3n de procesos a personas ajenas a la computaci\u00f3n.<\/p>\n\n\n\n

    Los algoritmos pueden ser expresados de muchas maneras, incluyendo al lenguaje natural, pseudoc\u00f3digo, diagramas de flujo y lenguajes de programaci\u00f3n entre otros. Las descripciones en lenguaje natural tienden a ser ambiguas y extensas.<\/p>\n\n\n\n

     El usar pseudoc\u00f3digo y diagramas de flujo evita muchas ambig\u00fcedades del lenguaje natural. Dichas expresiones son formas m\u00e1s estructuradas para representar algoritmos; no obstante, se mantienen independientes de un lenguaje de programaci\u00f3n espec\u00edfico.<\/p>\n\n\n\n

    Diagramas de Flujo<\/strong><\/p>\n\n\n\n

    <\/figure>\n\n\n\n

    Los diagramas de flujo sirven para representar algoritmos de manera gr\u00e1fica.<\/p>\n\n\n\n

    En matem\u00e1ticas, ciencias de la computaci\u00f3n y disciplinas relacionadas, un algoritmo<\/strong> (del griego y lat\u00edn, dixit algorithmus<\/em> y este a su vez del matem\u00e1tico persa Al-Juarismi ) es un conjunto preescrito de instrucciones o reglas bien definidas, ordenadas y finitas que permite realizar una actividad mediante pasos sucesivos que no generen dudas a quien deba realizar dicha actividad. Dados un estado inicial y una entrada, siguiendo los pasos sucesivos se llega a un estado final y se obtiene una soluci\u00f3n. Los algoritmos son el objeto de estudio de la algoritmia<\/strong>.<\/p>\n\n\n\n

    En la vida cotidiana, se emplean algoritmos frecuentemente 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\u00f3n. Algunos ejemplos en matem\u00e1tica son el algoritmo de la divisi\u00f3n para calcular el cociente de dos n\u00fameros, el Algoritmo de Euclides para obtener el M\u00e1ximo Com\u00fan Divisor de dos enteros positivos, o el M\u00e9todo de Gauss para resolver un Sistema Lineal de Ecuaciones.<\/p>\n\n\n\n

    Para su elaboraci\u00f3n se siguen ciertas reglas:<\/strong><\/p>\n\n\n\n

      \n
    • Se escribe de arriba hacia abajo y de izquierda a derecha<\/li>\n\n\n\n
    • Siempre se usan flechas verticales u horizontales, jam\u00e1s curvas<\/li>\n\n\n\n
    • Evitar cruce de flujos<\/li>\n\n\n\n
    • En cada paso expresar una acci\u00f3n concreta<\/li>\n<\/ul>\n\n\n\n

      Secuencia de flujo normal en una soluci\u00f3n de problema<\/strong><\/p>\n\n\n\n

        \n
      • Tiene un inicio<\/li>\n\n\n\n
      • Una lectura o entrada de datos<\/li>\n\n\n\n
      • El proceso de datos<\/li>\n\n\n\n
      • Una salida de informaci\u00f3n<\/li>\n\n\n\n
      • Un final<\/li>\n<\/ul>\n\n\n\n

        Simbolog\u00eda para dise\u00f1ar flujogramas.<\/p>\n\n\n\n

        <\/figure>\n\n\n\n

        VENTAJAS DE USAR FLUJOGRAMAS<\/strong><\/p>\n\n\n\n

          \n
        • R\u00e1pida comprensi\u00f3n de las relaciones<\/li>\n<\/ul>\n\n\n\n
            \n
          • An\u00e1lisis efectivo de las diferentes secciones del programa<\/li>\n<\/ul>\n\n\n\n
              \n
            • Pueden usarse como modelos de trabajo en el dise\u00f1o de nuevos programas o sistemas<\/li>\n<\/ul>\n\n\n\n
                \n
              • Comunicaci\u00f3n con el usuario<\/li>\n<\/ul>\n\n\n\n
                  \n
                • Documentaci\u00f3n adecuada de los programas<\/li>\n<\/ul>\n\n\n\n
                    \n
                  • Codificaci\u00f3n eficaz de los programas<\/li>\n<\/ul>\n\n\n\n
                      \n
                    • Depuraci\u00f3n y pruebas ordenadas de programas<\/li>\n<\/ul>\n\n\n\n

                      DESVENTAJAS DE LOS FLUJOGRAMAS<\/p>\n\n\n\n

                        \n
                      • Diagramas complejos y detallados suelen ser laboriosos en su planteamiento y dise\u00f1o<\/li>\n<\/ul>\n\n\n\n
                          \n
                        • Acciones a seguir tras la salida de un s\u00edmbolo de decisi\u00f3n, pueden ser dif\u00edciles de seguir si existen      diferentes caminos<\/li>\n<\/ul>\n\n\n\n
                            \n
                          • No existen normas fijas para la elaboraci\u00f3n de los diagramas de flujo que permitan incluir todos los detalles que el usuario desee introducir.<\/li>\n<\/ul>\n\n\n\n

                            Representando el ejemplo como flujograma tenemos:<\/p>\n\n\n\n

                            <\/figure>\n\n\n\n

                            Sistemas formales<\/strong><\/p>\n\n\n\n

                            La teor\u00eda de aut\u00f3matas y la teor\u00eda de funciones recursivas proveen modelos matem\u00e1ticos que formalizan el concepto de algoritmo<\/em>.<\/p>\n\n\n\n

                            Los modelos m\u00e1s comunes son la m\u00e1quina de Turing, m\u00e1quina de registro y funciones u-recursivas. Estos modelos son tan precisos como un lenguaje de m\u00e1quina, careciendo de expresiones coloquiales o ambig\u00fcedad, sin embargo se mantienen independientes de cualquier computadora y de cualquier implementaci\u00f3n<\/p>\n\n\n\n

                            Implementaci\u00f3n<\/strong><\/p>\n\n\n\n

                            Muchos algoritmos son ideados para implementarse en un programa. Sin embargo, los algoritmos pueden ser implementados en otros medios, como una red neuronal, un circuito el\u00e9ctrico o un aparato mec\u00e1nico y el\u00e9ctrico. Algunos algoritmos inclusive se dise\u00f1an especialmente para implementarse usando l\u00e1piz y papel. El algortitmo de multiplicaci\u00f3n tradicional, elalgoritmo de Euclides, la criba de Er\u00e1stones y muchas formas de resolver la ra\u00edz cuadrada son s\u00f3lo algunos ejemplos.<\/p>\n\n\n\n

                            Variables<\/strong><\/p>\n\n\n\n

                            Son elementos que toman valores espec\u00edficos de un tipo de datos concreto. La declaraci\u00f3n de una variable puede realizarse comenzando con var<\/strong>. Principalmente, existen dos maneras de otorgar valores iniciales a variables:<\/p>\n\n\n\n

                              \n
                            1. Mediante una sentencia de asignaci\u00f3n.<\/li>\n\n\n\n
                            2. Mediante un procedimiento de entrada de datos (por ejemplo: ‘read’).<\/li>\n<\/ol>\n\n\n\n


                              Ejemplo:<\/p>\n\n\n\n

                                   …<\/p>\n\n\n\n

                                  i:=1;<\/p>\n\n\n\n

                                  read(n);<\/p>\n\n\n\n

                                  while i < n do begin<\/p>\n\n\n\n

                                     (* cuerpo del bucle *)<\/p>\n\n\n\n

                                     i := i + 1<\/p>\n\n\n\n

                                  end;<\/p>\n\n\n\n

                                   …<\/p>\n\n\n\n

                              Estructuras secuenciales<\/strong><\/p>\n\n\n\n

                              La estructura secuencial es aquella en la que una acci\u00f3n sigue a otra en secuencia. Las operaciones se suceden de tal modo que la salida de una es la entrada de la siguiente y as\u00ed sucesivamente hasta el fin del proceso. La asignaci\u00f3n de esto consiste, en el paso de valores o resultados a una zona de la memoria. Dicha zona ser\u00e1 reconocida con el nombre de la variable que recibe el valor. La asignaci\u00f3n se puede clasificar de la siguiente forma:<\/p>\n\n\n\n

                                \n
                              1. Simples<\/strong>: Consiste en pasar un valor constante a una variable (a \u2190 15)<\/li>\n\n\n\n
                              2. Contador<\/strong>: Consiste en usarla como un verificador del n\u00famero de veces que se realiza un proceso (a \u2190 a + 1)<\/li>\n\n\n\n
                              3. Acumulador<\/strong>: Consiste en usarla como un sumador en un proceso (a \u2190 a + b)<\/li>\n\n\n\n
                              4. De trabajo<\/strong>: Donde puede recibir el resultado de una operaci\u00f3n matem\u00e1tica que involucre muchas variables (a \u2190 c + b*2\/4).<\/li>\n<\/ol>\n\n\n\n

                                Un ejemplo de estructura secuencial, Codificado en C++, como obtener la \u00e1rea de un tri\u00e1ngulo:<\/p>\n\n\n\n

                                Inicio<\/p>\n\n\n\n

                                …<\/p>\n\n\n\n

                                    float b, h, a;<\/p>\n\n\n\n

                                    printf(“Diga la base”);<\/p>\n\n\n\n

                                    scanf(“%f”, &b);<\/p>\n\n\n\n

                                    printf(“Diga la altura”);<\/p>\n\n\n\n

                                    scanf(“%f”, &h);<\/p>\n\n\n\n

                                    a = (b*h)\/2;<\/p>\n\n\n\n

                                    printf(“El \u00e1rea del tri\u00e1ngulo es %f”, a)<\/p>\n\n\n\n

                                …<\/p>\n\n\n\n

                                Fin<\/p>\n\n\n\n

                                INSTRUCCIONES SI … ENTONCES SI Y SI … ENTONCES – SINO<\/em><\/strong><\/p>\n\n\n\n

                                La instrucci\u00f3n Si … Entonces permite controlar qu\u00e9 procesos tienen lugar en funci\u00f3n del valor de una o varias variables o de las decisiones del usuario. Escribiremos esta instrucci\u00f3n de la siguiente manera:<\/p>\n\n\n\n

                                <\/figure>\n\n\n\n

                                Se podr\u00e1n introducir instrucciones a realizarse en caso de no cumplirse la condici\u00f3n:<\/p>\n\n\n\n

                                <\/figure>\n\n\n\n

                                N\u00f3tese que el uso de sangr\u00edas permite identificar el bloque de sentencias a ejecutar. Gr\u00e1ficamente:INSTRUCCI\u00d3N SI – ENTONCES<\/strong><\/em><\/p>\n\n\n\n

                                <\/figure>\n\n\n\n

                                INSTRUCCI\u00d3N SI – ENTONCES – SINO<\/strong><\/em><\/p>\n\n\n\n

                                <\/figure>\n\n\n\n

                                Recordemos que para expresar condiciones disponemos de s\u00edmbolos matem\u00e1ticos como =, >, <, etc. as\u00ed como de los operadores y (and) y \u00f3 (or).<\/p>\n\n\n\n

                                <\/figure>\n\n\n\n

                                EJEMPLO<\/p>\n\n\n\n

                                <\/figure>\n\n\n\n

                                La instrucci\u00f3n Si … Entonces es anidable dentro de s\u00ed misma. Esto significa que puede haber un bloque Si … Entonces dentro de otro. Se hace m\u00e1s necesario que nunca el sangrado para que el pseudoc\u00f3digo sea legible. Ha de verificarse que todo Si se cierra con un FinSi<\/p>\n\n\n\n

                                <\/figure>\n\n\n\n
                                <\/figure>\n\n\n\n
                                <\/figure>\n\n\n\n
                                <\/figure>\n\n\n\n

                                Los anidamientos se pueden convertir en triples, cu\u00e1druples, qu\u00edntuples, etc. lo cual convierte en farragosa la lectura y seguimiento del pseudoc\u00f3digo. Habr\u00e1 que tratar de evitar excesos usando otros recursos, desviando a m\u00f3dulos independientes, etc.<\/p>\n\n\n\n

                                Cuando sea necesario por la complejidad en la toma de decisiones, se recurrir\u00e1 a una tabla de decisi\u00f3n como paso previo a la confecci\u00f3n del pseudoc\u00f3digo o diagrama de flujo.<\/p>\n\n\n\n

                                EN RESUMEN:<\/p>\n\n\n\n

                                Una instrucci\u00f3n de control condicional<\/strong> es un bloque de c\u00f3digo que se ejecuta si cumple una condici\u00f3n<\/strong>, que nosotros pongamos. Esta condici\u00f3n<\/strong> es una expresi\u00f3n l\u00f3gica que debe dar como resultado true<\/strong> o false<\/strong>, para ello es habitual usar los operadores relacionales y l\u00f3gicos.<\/p>\n\n\n\n

                                Las dos mas utilizadas son:<\/p>\n\n\n\n

                                  \n
                                • Condicional simple<\/strong>: si la condici\u00f3n es verdadera se ejecuta el bloque de c\u00f3digo que contenga y ya esta. Su sintaxis es:<\/li>\n<\/ul>\n\n\n\n

                                  SI (condici\u00f3n) Entonces<\/strong><\/p>\n\n\n\n

                                  Instrucciones<\/p>\n\n\n\n

                                  Fin-Si<\/strong><\/p>\n\n\n\n

                                  Por ejemplo:<\/p>\n\n\n\n

                                  123456<\/td>Inicio<\/code>   <\/code>Leer numero1<\/code>   <\/code>Si (numero1>0) Entonces<\/code>      <\/code>Escribir numero1 \" es mayor que 0\"<\/code>   <\/code>FinSi<\/code> <\/code>Fin<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
                                    \n
                                  • Condicional doble<\/strong>: si la condici\u00f3n es verdadera se ejecuta el bloque de c\u00f3digo que contenga y sino se cumple pues ejecuta otro bloque de codigo. Ejecuta uno o otro. Su sintaxis es:<\/li>\n<\/ul>\n\n\n\n

                                    SI (condici\u00f3n) Entonces<\/strong><\/p>\n\n\n\n

                                    Instrucciones<\/p>\n\n\n\n

                                    Sino<\/strong><\/p>\n\n\n\n

                                    Instrucciones<\/p>\n\n\n\n

                                    Fin-Si<\/strong><\/p>\n\n\n\n

                                    12345678<\/td>Inicio<\/code>    <\/code>Leer numero1<\/code>    <\/code>Si (numero1>0) Entonces<\/code>       <\/code>Escribir numero1 \" es mayor que 0\"<\/code>    <\/code>Sino<\/code>       <\/code>Escribir numero1 \" es menor que 0\"<\/code>    <\/code>FinSi<\/code> <\/code>Fin<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

                                    Algo que se suele hacer es anidar<\/strong> estructuras Si<\/strong>, se puede usar para especificar aun mas una condici\u00f3n  Debemos recordar que debemos cerrar las estructuras Si<\/strong> que abramos, es recomendable tabular las instrucciones para mayor legibilidad. Veamos un ejemplo:<\/p>\n\n\n\n

                                    1234567891011<\/td>Inicio<\/code>   <\/code>Si (condicion) Entonces<\/code>      <\/code>Si (condicion) Entonces<\/code>         <\/code>Instrucciones<\/code>      <\/code>Sino<\/code>         <\/code>Intrucciones<\/code>      <\/code>FinSi<\/code>   <\/code>Sino<\/code>      <\/code>Instrucciones<\/code>   <\/code>FinSi<\/code>Fin<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

                                    Tambi\u00e9n existe otra instrucci\u00f3n de control condicional, llamado segun sea<\/strong>, que seg\u00fan un valor (de una variable, una constante, etc.)  o expresi\u00f3n hace una operaci\u00f3n u otra. No puede ser una condici\u00f3n. Su sintaxis es:<\/p>\n\n\n\n

                                    Segun (valor<\/strong> o expresion) hacer<\/strong><\/p>\n\n\n\n

                                    valor1:<\/strong><\/p>\n\n\n\n

                                    Instrucciones<\/p>\n\n\n\n

                                    valor2:<\/strong><\/p>\n\n\n\n

                                    Instrucciones<\/p>\n\n\n\n

                                    \u2026.<\/p>\n\n\n\n

                                    FinSegun<\/strong><\/p>\n\n\n\n

                                    Por ejemplo:<\/p>\n\n\n\n

                                    \n
                                    \n
                                    \n
                                    1234567891011121314151617181920212223242526272829<\/td>Inicio<\/code> <\/code>Leer mes<\/code> <\/code>Segun mes Hacer<\/code>    <\/code>1:<\/code>       <\/code>escribir \"Enero\"<\/code>    <\/code>2:<\/code>       <\/code>escribir \"Febrero\"<\/code>    <\/code>3:<\/code>       <\/code>escribir \"Marzo\"<\/code>    <\/code>4:<\/code>       <\/code>escribir \"Abril\"<\/code>    <\/code>5:<\/code>       <\/code>escribir \"Mayo\"<\/code>    <\/code>6:<\/code>       <\/code>escribir \"Junio\"<\/code>    <\/code>7:<\/code>       <\/code>escribir \"Julio\"<\/code>    <\/code>8:<\/code>       <\/code>escribir \"Agosto\"<\/code>    <\/code>9:<\/code>       <\/code>escribir \"Septiembre\"<\/code>    <\/code>10:<\/code>       <\/code>escribir \"Octubre\"<\/code>    <\/code>11:<\/code>       <\/code>escribir \"Noviembre\"<\/code>    <\/code>12:<\/code>       <\/code>escribir \"Diciembre\"<\/code> <\/code>FinSegun<\/code>Fin<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n<\/div><\/div>\n<\/div>\n<\/div>\n\n\n\n

                                    M\u00faltiples (En caso de): Las estructuras de comparaci\u00f3n m\u00faltiples, es una toma de decisi\u00f3n especializada que permiten evaluar una variable con distintos posibles resultados, ejecutando para cada caso una serie de instrucciones especificas. La forma es la siguiente:<\/p>\n\n\n\n

                                    Pseudoc\u00f3digo:<\/p>\n\n\n\n

                                    <\/figure>\n\n\n\n

                                    Diagrama de flujo:<\/p>\n\n\n\n

                                    <\/figure>\n\n\n\n

                                    Veamos algunos ejemplos donde se aplique todo lo anterior: <\/p>\n\n\n\n

                                    <\/figure>\n\n\n\n
                                    <\/figure>\n\n\n\n

                                    Se pide leer tres notas del alumno, calcular su definitiva en un rango de 0-5 y enviar un mensaje donde diga si el alumno aprob\u00f3 o reprob\u00f3 el curso. Exprese el algoritmo usando Pseudoc\u00f3digo y diagrama de flujos. <\/p>\n\n\n\n

                                    Pseudoc\u00f3digo: <\/p>\n\n\n\n

                                    INICIO <\/p>\n\n\n\n

                                       Not1, Not2, Not 3 :REAL <\/p>\n\n\n\n

                                       Def: REAL <\/p>\n\n\n\n

                                       LEA Nota1, Nota2, Nota3 <\/p>\n\n\n\n

                                       Def \u00df (Not1 + Not2 + Not3) \/3 <\/p>\n\n\n\n

                                       Si Def < 3 entonces <\/p>\n\n\n\n

                                          Escriba Reprob\u00f3 el curso<\/p>\n\n\n\n

                                       Sino <\/p>\n\n\n\n

                                          Escriba Aprob\u00f3 el curso <\/p>\n\n\n\n

                                       Fin-Si <\/p>\n\n\n\n

                                    FIN <\/p>\n\n\n\n

                                    <\/figure>\n\n\n\n

                                    EJEMPLO:<\/p>\n\n\n\n

                                    Se desea escribir un algoritmo que pida la altura de una persona, si la altura es menor o igual a 150 cm env\u00ede el mensaje: Persona de altura baja; si la altura est\u00e1 entre 151 y 170 escriba el mensaje: Persona de altura media y si la altura es mayor al 171 escriba el mensaje: Persona alta. Exprese el algoritmo usando Pseudoc\u00f3digo y diagrama de flujos. <\/p>\n\n\n\n

                                    Pseudoc\u00f3digo: <\/p>\n\n\n\n

                                    INICIO <\/p>\n\n\n\n

                                       Altura: ENTERO <\/p>\n\n\n\n

                                       ESCRIBA Cu\u00e1l es tu altura?  <\/p>\n\n\n\n

                                       LEA Altura <\/p>\n\n\n\n

                                       Si Altura <=150 entonces <\/p>\n\n\n\n

                                          ESCRIBA persona de altura baja <\/p>\n\n\n\n

                                       Sino <\/p>\n\n\n\n

                                          Si Altura <=170 entonces <\/p>\n\n\n\n

                                             ESCRIBA persona de altura media <\/p>\n\n\n\n

                                          Sino <\/p>\n\n\n\n

                                             Si Altura>170 ENTONCES <\/p>\n\n\n\n

                                                ESCRIBA persona alta <\/p>\n\n\n\n

                                             Fin-Si <\/p>\n\n\n\n

                                          Fin-Si <\/p>\n\n\n\n

                                       Fin-Si <\/p>\n\n\n\n

                                    FIN <\/p>\n\n\n\n

                                    Diagrama de flujo: <\/p>\n\n\n\n

                                    <\/figure>\n\n\n\n

                                    EJEMPLO:<\/p>\n\n\n\n

                                    Dado un numero entre 1 y 7 escriba su correspondiente d\u00eda de la semana as\u00ed: <\/p>\n\n\n\n

                                    1- Lunes 2- Martes 3- Mi\u00e9rcoles 4- Jueves 5- Viernes 6- S\u00e1bado 7- Domingo <\/p>\n\n\n\n

                                    Exprese el algoritmo usando Pseudoc\u00f3digo y diagrama de flujos. <\/p>\n\n\n\n

                                    Pseudoc\u00f3digo: Pseudoc\u00f3digo: <\/p>\n\n\n\n

                                    INICIO <\/p>\n\n\n\n

                                       Dia: ENTERO <\/p>\n\n\n\n

                                       ESCRIBA Diga un n\u00famero para escribir su d\u00eda <\/p>\n\n\n\n

                                       LEA Dia <\/p>\n\n\n\n

                                       En-caso-de Dia haga <\/p>\n\n\n\n

                                          Caso 1: ESCRIBA Lunes <\/p>\n\n\n\n

                                          Caso 2: ESCRIBA Martes <\/p>\n\n\n\n

                                          Caso 3: ESCRIBA Mi\u00e9rcoles <\/p>\n\n\n\n

                                          Caso 4: ESCRIBA Jueves <\/p>\n\n\n\n

                                          Caso 5: ESCRIBA Viernes <\/p>\n\n\n\n

                                          Caso 6: ESCRIBA S\u00e1bado <\/p>\n\n\n\n

                                          Caso 7: ESCRIBA Domingo <\/p>\n\n\n\n

                                         SINO: ESCRIBA Escribi\u00f3 un numero fuera del rango 1-7 <\/p>\n\n\n\n

                                       Fin-Caso <\/p>\n\n\n\n

                                    FIN <\/p>\n\n\n\n

                                    <\/figure>\n\n\n\n

                                    Estructuras Repetitivas<\/em><\/h2>\n\n\n\n

                                    El computador est\u00e1 especialmente dise\u00f1ado para aplicaciones en las que una operaci\u00f3n o un conjunto de ellas deben repetirse muchas veces. En este sentido, definiremos  bucle o lazo (loop), como un segmento de un programa cuyas instrucciones se repiten bien un n\u00famero determinado de veces o mientras se cumpla una determinada condici\u00f3n.<\/p>\n\n\n\n

                                     Es imprescindible que se establezcan mecanismos para controlar esta tarea repetitiva, ya que si \u00e9stos no existen, el bucle puede convertirse en un proceso infinito. As\u00ed, en el bucle representado por el organigrama de la Figura , se observa que las instrucciones incluidas en \u00e9l se repiten indefinidamente. El mecanismo de control citado se establece mediante una condici\u00f3n que se comprueba en cada paso o iteraci\u00f3n del bucle.<\/p>\n\n\n\n

                                    <\/figure>\n\n\n\n

                                     En la Figura  se coloca una condici\u00f3n tras la lectura de la variable N (comprobar si su valor es cero), de forma que tenemos la oportunidad de que el bucle deje de ser infinito, ya que podr\u00e1 interrumpirse cuando la condici\u00f3n sea verdadera.<\/p>\n\n\n\n

                                    Los procesos que se repiten varias veces en un programa necesitan en muchas ocasiones contar el numero de repeticiones habidas. Una forma de hacerlo es utilizar una variable llamada contador, cuyo valor se incrementa o decrementa en una cantidad constante en cada repetici\u00f3n que se produzca.<\/p>\n\n\n\n

                                    La Figura siguiente presenta un diagrama de flujo para un algoritmo en el que se desea repetir 50 veces un grupo de instrucciones, que llamaremos cuerpo del bucle, donde el contador se representa con la variable CONT. La instrucci\u00f3n que actualiza al contador es la asignaci\u00f3n:<\/p>\n\n\n\n

                                     CONT \u00df  CONT+1.<\/p>\n\n\n\n

                                    El contador puede ser positivo (incrementos de uno en uno) o negativo (decrementos de uno en uno).<\/p>\n\n\n\n

                                     En la Figura, el contador cuenta desde 1 a 50 y deja de repetirse cuando la variable CONT toma el valor 51 y termina el bucle.<\/p>\n\n\n\n

                                    <\/figure>\n\n\n\n

                                    <\/p>\n\n\n\n

                                     En la Figura siguiente se muestra un algoritmo que efect\u00faa la operaci\u00f3n de multiplicaci\u00f3n n x m, sumando m un n\u00famero n de veces. En \u00e9l, el contador se decrementa: comienzaa contar en n y se va decrementando hasta llegar a cero; en ese momento se termina el bucle y se realiza la acci\u00f3n escribir.<\/p>\n\n\n\n

                                    <\/figure>\n\n\n\n

                                    <\/p>\n\n\n\n

                                    Otro tipo de variable, normalmente asociada al funcionamiento de un bucle es un acumulador o totalizador, cuya misi\u00f3n es almacenar una cantidad variable, resultante de operaciones sucesivas y repetidas. Un acumulador realiza una funci\u00f3n parecida a la de un contador, con la diferencia de que el incremento o decremento, de cada operaci\u00f3n es variable en lugar de constante.<\/p>\n\n\n\n

                                    Una  estructura repetitiva es aquella que marca la reiteraci\u00f3n de una serie de acciones bas\u00e1ndose en un bucle. De acuerdo con lo anterior, esta estructura debe constar de tres partes b\u00e1sicas:<\/p>\n\n\n\n

                                    – decisi\u00f3n (para finalizar la repetici\u00f3n)<\/p>\n\n\n\n

                                    – cuerpo del bucle (conjunto de instrucciones que se repiten)<\/p>\n\n\n\n

                                    – salida del bucle (instrucci\u00f3n a la que se accede una vez  se decide finalizar)<\/p>\n\n\n\n

                                    Tomando el caso anterior, donde para obtener la suma de una serie de n\u00fameros, hemos utilizado la estrategia siguiente: tras leer cada n\u00famero lo a\u00f1adimos a una variable SUMA que contenga las sucesivas sumas parciales (SUMA se hace igual a cero al inicio).<\/p>\n\n\n\n

                                    Observemos que el algoritmo correspondiente deber\u00e1 utilizar sucesivamente instrucciones tales como:<\/p>\n\n\n\n

                                    leer n\u00famero<\/p>\n\n\n\n

                                    si N < 0 entonces<\/p>\n\n\n\n

                                       escribir SUMA<\/p>\n\n\n\n

                                    si-no<\/p>\n\n\n\n

                                       SUMA  \u00df SUMA+n\u00famero<\/p>\n\n\n\n

                                    fin-si<\/p>\n\n\n\n

                                    que se pueden repetir muchas veces; \u00e9stas constituyen el cuerpo del bucle.<\/p>\n\n\n\n

                                    Una vez se ha decidido el cuerpo del bucle, se plantea la cuesti\u00f3n de cu\u00e1ntas veces se debe repetir. De hecho conocemos ya la necesidad de contar con una condici\u00f3n para detener el bucle. En el Ejemplo 8, se pide al usuario el n\u00famero N de n\u00fameros que desea sumar, esto es, el n\u00famero de iteraciones del bucle.<\/p>\n\n\n\n

                                    Usamos un contador de iteraciones, TOTAL, que se inicializa a N y a continuaci\u00f3n se decrementa en uno cada vez que el bucle se repite; para ello introducimos una acci\u00f3n m\u00e1s al cuerpo del bucle: TOTAL \u00df  TOTAL -1. Tambi\u00e9n podr\u00edamos inicializar la variable TOTAL en 0 o en 1, e ir increment\u00e1ndolo en uno, en cada iteraci\u00f3n, hasta llegar al n\u00famero deseado N.<\/p>\n\n\n\n

                                    Ejemplo :<\/p>\n\n\n\n

                                    Hallar la suma de N n\u00fameros, a trav\u00e9s de una estructura repetitiva<\/p>\n\n\n\n

                                    algoritmo suma_n\u00fameros<\/p>\n\n\n\n

                                    {leer n\u00famero total de n\u00fameros a sumar en variable N}<\/p>\n\n\n\n

                                    TOTAL \u00df   N<\/p>\n\n\n\n

                                    SUMA \u00df  0   { la suma parcial es 0 al inicio}<\/p>\n\n\n\n

                                    {comienzo de bucle}<\/p>\n\n\n\n

                                    mientras que TOTAL > 0 hacer<\/p>\n\n\n\n

                                    leer n\u00famero<\/p>\n\n\n\n

                                    SUMA \u00df  SUMA+n\u00famero<\/p>\n\n\n\n

                                    TOTAL \u00df  TOTAL-1<\/p>\n\n\n\n

                                    fin_mientras<\/p>\n\n\n\n

                                    {fin del bucle}<\/p>\n\n\n\n

                                    escribir \u201cla suma de los\u201d , N , \u201cn\u00fameros es \u201c , SUMA<\/p>\n\n\n\n

                                    Aunque la condici\u00f3n de finalizaci\u00f3n puede evaluarse en distintos lugares del algoritmo, no es recomendable que \u00e9sta se pueda efectuar a mitad del cuerpo del bucle, por lo que es bueno que se produzca al principio o al final del mismo. Seg\u00fan donde se sit\u00fae la  condici\u00f3n de salida, dar\u00e1 lugar a distintos tipos de estructuras repetitivas que analizaremos a continuaci\u00f3n: estructura desde-hasta, estructura mientras y estructura repetir-hasta_que.<\/p>\n\n\n\n

                                    ESTRUCTURA DESDE-HASTA<\/em><\/p>\n\n\n\n

                                    Esta estructura consiste en que la condici\u00f3n de salida se basa en un contador que cuenta el n\u00famero de iteraciones. Por ejemplo, el ejemplo 8 podr\u00eda hacerse de la siguiente manera:<\/p>\n\n\n\n

                                    desde i = 1 hasta N con_incremento 1 hacer<\/p>\n\n\n\n

                                                leer n\u00famero<\/p>\n\n\n\n

                                                SUMA \u00df  SUMA + n\u00famero<\/p>\n\n\n\n

                                    fin_desde<\/p>\n\n\n\n

                                    donde i es un contador que cuenta desde un valor inicial (1) hasta el valor final (N) con los incrementos que se consideren (de uno en uno en este caso). Esta es la llamada estructura Desde (\u201cfor\u201d), que es la m\u00e1s simple desde el punto de vista de la condici\u00f3n de salida, ya que viene predeterminada por el c\u00f3digo. Su utilidad reside en el hecho de que, en muchas ocasiones, se conoce de antemano el n\u00famero de iteraciones. Esta estructura ejecuta las acciones del cuerpo del bucle, un n\u00famero especificado de veces y de modo autom\u00e1tico controla el n\u00famero de iteraciones. Su formato en pseudoc\u00f3digo es:<\/p>\n\n\n\n

                                    desde v=vi hasta vf hacer<\/p>\n\n\n\n

                                       <acciones><\/p>\n\n\n\n

                                       .<\/p>\n\n\n\n

                                       .<\/p>\n\n\n\n

                                    fin_desde<\/p>\n\n\n\n

                                    v: variable \u00edndice<\/p>\n\n\n\n

                                    vi, vf: valores inicial y final de la variable<\/p>\n\n\n\n

                                    La variable \u00edndice o de control normalmente ser\u00e1 de tipo entero y es normal emplear como identificador, las letras I,J,K como herencia de los \u00edndices y sub\u00edndices utilizados en c\u00e1lculo cient\u00edfico. El incremento  de la variable \u00edndice es 1 en cada iteraci\u00f3n si no se indica expresamente lo contrario. Si debemos expresar incrementos distintos de +1 el formato de la estructura es:<\/p>\n\n\n\n

                                    desde v = vi hasta vf inc incremento hacer<\/p>\n\n\n\n

                                       <acciones>  si vi > vf entonces usar<\/p>\n\n\n\n

                                       .  en lugar de  inc incremento<\/p>\n\n\n\n

                                       .  la expresi\u00f3n dec decremento<\/p>\n\n\n\n

                                    fin_desde<\/p>\n\n\n\n

                                    Obviamente, si el valor inicial de la variable \u00edndice es menor que el valor final, los incrementos deben ser positivos, ya que en caso contrario la secuencia de acciones no se ejecutar\u00eda. De igual modo si el valor inicial es mayor que el valor final, el incremento debe ser en este caso negativo. As\u00ed:<\/p>\n\n\n\n

                                    desde I=20 hasta 10 hacer<\/p>\n\n\n\n

                                    <acciones><\/p>\n\n\n\n

                                    fin_desde<\/p>\n\n\n\n

                                    for(v=vi; v<=vf; vt+=step)<\/p>\n\n\n\n

                                    <accion o bloque de acciones ><\/p>\n\n\n\n

                                     (m\u00e1s gen\u00e9ricamente)<\/p>\n\n\n\n

                                    for(inicio;condici\u00f3n;actualizaci\u00f3n)<\/p>\n\n\n\n

                                    <accion o bloque de acciones ><\/p>\n\n\n\n

                                    ESTRUCTURA MIENTRAS<\/em><\/p>\n\n\n\n

                                    verdadera, entonces se ejecuta el cuerpo del bucle. No todos los lenguajes incluyen<\/em><\/p>\n\n\n\n

                                    la estructura mientras.<\/p>\n\n\n\n

                                    En lenguaje C:<\/p>\n\n\n\n

                                    Cuando la condici\u00f3n de salida del bucle se realiza al principio del mismo, \u00e9ste se ejecuta mientras se verifica una cierta condici\u00f3n. Es la llamada estructura repetitiva mientras (\u201cwhile\u201d); en ella el cuerpo del bucle se repite mientras se cumple una determinada condici\u00f3n. Su pseudoc\u00f3digo es:<\/p>\n\n\n\n

                                    mientras condici\u00f3n hacer<\/p>\n\n\n\n

                                    <acciones><\/p>\n\n\n\n

                                    fin_mientras<\/p>\n\n\n\n

                                    Cuando se ejecuta la instrucci\u00f3n mientras, la primera cosa que sucede es la evaluaci\u00f3n de la condici\u00f3n. Si es falsa, no se ejecuta ninguna acci\u00f3n y el programa prosigue en la siguiente instrucci\u00f3n a la finalizaci\u00f3n del bucle; si la condici\u00f3n es<\/p>\n\n\n\n

                                    while (condicion)<\/p>\n\n\n\n

                                    <accion><\/p>\n\n\n\n

                                    Obs\u00e9rvese que en una estructura mientras si la primera evaluaci\u00f3n de la condici\u00f3n es  falsa, el cuerpo del bucle nunca se ejecuta. Puede parecer in\u00fatil ejecutar el cuerpo del bucle cero veces, ya que no tendr\u00e1 efecto en ning\u00fan valor o salida; sin embargo, puede ser una acci\u00f3n deseada. Por ejemplo el siguiente bucle para procesar las notas de unos examenes contando el n\u00famero de alumnos presentados dejar\u00e1 de ejecutarse cuando el numero le\u00eddo sea negativo. Si la primera nota introducida fuera negativa, la acci\u00f3n deseada es, efectivamente, que no se ejecute el bucle ninguna vez.<\/p>\n\n\n\n

                                    C  \u00df 0<\/p>\n\n\n\n

                                    leer nota<\/p>\n\n\n\n

                                    mientras nota = 0 hacer<\/p>\n\n\n\n

                                    {procesar nota}<\/p>\n\n\n\n

                                    C  \u00df C+1<\/p>\n\n\n\n

                                    leer nota<\/p>\n\n\n\n

                                    fin_mientras<\/p>\n\n\n\n

                                    ESTRUCTURA REPETIR-HASTA_QUE<\/em><\/p>\n\n\n\n

                                    En esta estructura la condici\u00f3n de salida se sit\u00faa al final del bucle; el bucle se ejecuta hasta que se verifique una cierta condici\u00f3n. Es la llamada estructura Repetir-hasta (\u201crepeat-until\u201d). Existen muchas situaciones en las que se desea<\/strong> que un bucle se ejecute al menos una vez, antes de comprobar la condici\u00f3n de repetici\u00f3n. Para ello la estructura repetir-hasta_que se ejecuta hasta que se cumpla una condici\u00f3n determinada que se comprueba al final del bucle. En pseudoc\u00f3digo se escribe:<\/p>\n\n\n\n

                                    repetir<\/p>\n\n\n\n

                                       <acciones><\/p>\n\n\n\n

                                    hasta_que <condici\u00f3n><\/p>\n\n\n\n

                                    do<\/p>\n\n\n\n

                                    <accion o bloque><\/p>\n\n\n\n

                                    while (condicion);<\/p>\n\n\n\n

                                    (en C se \u201cdice\u201d mientras se cumpla la condici\u00f3n, no hasta que se cumpla)<\/p>\n\n\n\n

                                    El bucle repetir-hasta_que se repite mientras la condici\u00f3n sea falsa, justo lo opuesto a la estructura mientras. Sea el siguiente algoritmo:<\/p>\n\n\n\n

                                    inicio<\/p>\n\n\n\n

                                                contador \u00df 1<\/p>\n\n\n\n

                                                repetir<\/p>\n\n\n\n

                                                leer n\u00famero<\/p>\n\n\n\n

                                                ontador  \u00df contador+1<\/p>\n\n\n\n

                                                hasta_que contador > 30<\/p>\n\n\n\n

                                                escribir \u201cn\u00fameros le\u00eddos: 30\u201d<\/p>\n\n\n\n

                                    fin<\/p>\n\n\n\n

                                    Este bucle se repite hasta que el valor de variable contador exceda a 30, lo que suceder\u00e1 despu\u00e9s de 30 ejecuciones del mismo. N\u00f3tese que si en vez de 30 pusi\u00e9ramos 0, el cuerpo del bucle se ejecutar\u00e1 siempre al menos una vez.<\/p>\n\n\n\n

                                    Ejemplo :<\/p>\n\n\n\n

                                    Calcular el factorial de un n\u00famero N, usando la estructura repetir.<\/p>\n\n\n\n

                                    inicio<\/p>\n\n\n\n

                                                leer N<\/p>\n\n\n\n

                                                Factorial  \u00df1<\/p>\n\n\n\n

                                                I \u00df  1<\/p>\n\n\n\n

                                                repetir<\/p>\n\n\n\n

                                                            Factorial  Factorial * I<\/p>\n\n\n\n

                                                            I \u00df  I+1<\/p>\n\n\n\n

                                                hasta_que I > N<\/p>\n\n\n\n

                                                escribir \u201cel factorial del n\u00famero\u201d, N, \u201ces\u201d, Factorial<\/p>\n\n\n\n

                                    fin<\/p>\n\n\n\n

                                    Las tres estructuras repetitivas son susceptibles de intercambio entre  ellas, as\u00ed por ejemplo es posible, sustituir una estructura desde, por una mientras; con incrementos positivos o negativos de la variable \u00edndice. En efecto, la estructura desde <\/strong>con incremento positivo es equivalente a la estructura mientras marcada con la A), y la estructura desde con incremento negativo es equivalente a la estructuramientras marcada con la B).<\/p>\n\n\n\n

                                    A)                                                                   B)<\/p>\n\n\n\n

                                    v \u00df  vi                                                           v \u00df  vi<\/p>\n\n\n\n

                                    mientras v < = vf hacer                               mientras v > = vf hacer<\/p>\n\n\n\n

                                                <acciones>                                                             <acciones><\/p>\n\n\n\n

                                    v \u00df  v + incremento                                   v \u00df  v – decremento<\/p>\n\n\n\n

                                    fin_mientras                                                            fin_mientras<\/p>\n\n\n\n

                                    Ejemplo 10:<\/p>\n\n\n\n

                                    Calcular los factoriales de n n\u00fameros le\u00eddos por el teclado.<\/p>\n\n\n\n

                                    El problema consiste en realizar una primera estructura repetitiva de n iteraciones del algoritmo de c\u00e1lculo del factorial, que a su vez se efect\u00faa con una segunda estructura repetitiva.<\/p>\n\n\n\n

                                    inicio<\/p>\n\n\n\n

                                    leer n  {lectura de la cantidad de n\u00fameros}<\/p>\n\n\n\n

                                    desde i = 1 hasta n hacer<\/p>\n\n\n\n

                                    leer NUMERO<\/p>\n\n\n\n

                                    FACTORIAL \u00df 1<\/p>\n\n\n\n

                                    desde j = 1 hasta NUMERO hacer<\/p>\n\n\n\n

                                    FACTORIAL\u00df  FACTORIAL *j<\/p>\n\n\n\n

                                    fin_desde<\/p>\n\n\n\n

                                    escribir \u201cel factorial del n\u00famero\u201d, NUMERO, \u201ces\u201d, FACTORIAL<\/p>\n\n\n\n

                                    fin_desde<\/p>\n\n\n\n

                                    fin<\/p>\n<\/div>","protected":false},"excerpt":{"rendered":"

                                    Presentaci\u00f3n de la Materia Fundamentos de Programaci\u00f3n es una asignatura b\u00e1sica que permite crear programas que exhiban un comportamiento deseado. El proceso de escribir c\u00f3digo requiere frecuentemente conocimientos en varias \u00e1reas distintas, adem\u00e1s del dominio del lenguaje a utilizar, algoritmos especializados y l\u00f3gica formal. Con esta materia el alumno aprender\u00e1 a escribir, a analizar, probar, … Leer m\u00e1s<\/a><\/p>\n\n

                                    \n Sharing is caring<\/span><\/strong> \n <\/i> Share<\/span><\/a>\n <\/i> +1<\/span><\/a>\n <\/i> Tweet<\/span><\/a>\n <\/i> Share<\/span><\/a>\n <\/i> Share<\/span><\/a>\n 6747 words 151 views<\/w>\n <\/p>","protected":false},"author":1,"featured_media":7868,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-7831","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-sin-categoria"],"_links":{"self":[{"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/posts\/7831","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/comments?post=7831"}],"version-history":[{"count":7,"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/posts\/7831\/revisions"}],"predecessor-version":[{"id":7869,"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/posts\/7831\/revisions\/7869"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/media\/7868"}],"wp:attachment":[{"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/media?parent=7831"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/categories?post=7831"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/abudinen.com\/blog\/wp-json\/wp\/v2\/tags?post=7831"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}