Categoría: Fundamentos de programación

Conceptos fundamentales para comprender la programación, los algoritmos y las herramientas de desarrollo.

Proyecto avanzado en PSeInt: crear un juego RPG por turnos completo

En este proyecto vamos a construir un juego RPG por turnos completo en PSeInt. La idea no es solamente hacer un juego largo: vamos a usarlo para practicar cómo dividir un problema grande en partes más pequeñas mediante SubProcesos y Funciones.

El jugador podrá elegir una clase, combatir enemigos aleatorios, usar pociones, defenderse, comprar mejoras, ganar experiencia, subir de nivel y enfrentarse finalmente a un jefe.

¿Qué vamos a practicar?

  • variables y tipos de datos;
  • condicionales y estructuras Segun;
  • ciclos Mientras;
  • números aleatorios;
  • parámetros por valor y por referencia;
  • SubProcesos y Funciones;
  • manejo del estado de un juego;
  • separación de responsabilidades.

1. La idea del juego

El juego comienza creando un héroe. Cada clase tiene estadísticas diferentes:

  • Guerrero: mucha vida y defensa.
  • Mago: menos vida, pero mucho ataque.
  • Arquero: estadísticas más equilibradas.

Después de cada combate el jugador recibe oro y experiencia. Entre batallas puede visitar una tienda, comprar pociones o mejorar sus estadísticas. Al conseguir cinco victorias aparece el jefe final.

2. ¿Por qué modularizar?

Podríamos escribir todo dentro del proceso principal, pero el código rápidamente se volvería difícil de leer. Por eso separaremos tareas concretas como mostrar el estado del héroe, generar enemigos, calcular daño, administrar la tienda o subir de nivel.

Una Función resulta útil cuando necesitamos calcular y devolver un valor. Un SubProceso es conveniente cuando queremos ejecutar una tarea más amplia y, si hace falta, modificar variables recibidas Por Referencia.

3. Código completo

Copiá el siguiente código en PSeInt y ejecutalo. Después vamos a repasar las partes más importantes.

Funcion resultado <- CalcularDanio(ataque, defensa)
    Definir resultado Como Entero;

    resultado <- ataque + Aleatorio(1,6) - defensa;

    Si resultado < 1 Entonces
        resultado <- 1;
    FinSi
FinFuncion


SubProceso MostrarEstado(nombre, clase, nivel, vida, vidaMaxima, ataque, defensa, experiencia, experienciaNecesaria, oro, pociones, combatesGanados)
    Limpiar Pantalla;

    Escribir "====================================";
    Escribir "        ESTADO DEL HEROE";
    Escribir "====================================";
    Escribir "Nombre: ", nombre;
    Escribir "Clase: ", clase;
    Escribir "Nivel: ", nivel;
    Escribir "Vida: ", vida, "/", vidaMaxima;
    Escribir "Ataque: ", ataque;
    Escribir "Defensa: ", defensa;
    Escribir "Experiencia: ", experiencia, "/", experienciaNecesaria;
    Escribir "Oro: ", oro;
    Escribir "Pociones: ", pociones;
    Escribir "Combates ganados: ", combatesGanados;
FinSubProceso


SubProceso CrearPersonaje(opcion, clase Por Referencia, vidaMaxima Por Referencia, ataque Por Referencia, defensa Por Referencia)
    Segun opcion Hacer
        1:
            clase <- "Guerrero";
            vidaMaxima <- 130;
            ataque <- 18;
            defensa <- 8;

        2:
            clase <- "Mago";
            vidaMaxima <- 90;
            ataque <- 25;
            defensa <- 4;

        3:
            clase <- "Arquero";
            vidaMaxima <- 105;
            ataque <- 21;
            defensa <- 6;

        De Otro Modo:
            clase <- "Guerrero";
            vidaMaxima <- 130;
            ataque <- 18;
            defensa <- 8;
    FinSegun
FinSubProceso


SubProceso CrearEnemigo(nivel, combatesGanados, nombreEnemigo Por Referencia, vidaEnemigo Por Referencia, ataqueEnemigo Por Referencia, defensaEnemigo Por Referencia)
    Definir enemigo Como Entero;

    Si combatesGanados >= 5 Entonces
        nombreEnemigo <- "Dragon Oscuro";
        vidaEnemigo <- 180 + nivel * 20;
        ataqueEnemigo <- 22 + nivel * 3;
        defensaEnemigo <- 8 + nivel;
    SiNo
        enemigo <- Aleatorio(1,4);

        Segun enemigo Hacer
            1:
                nombreEnemigo <- "Goblin";
                vidaEnemigo <- 45 + nivel * 10;
                ataqueEnemigo <- 10 + nivel * 2;
                defensaEnemigo <- 2 + nivel;

            2:
                nombreEnemigo <- "Esqueleto";
                vidaEnemigo <- 55 + nivel * 10;
                ataqueEnemigo <- 12 + nivel * 2;
                defensaEnemigo <- 3 + nivel;

            3:
                nombreEnemigo <- "Orco";
                vidaEnemigo <- 75 + nivel * 12;
                ataqueEnemigo <- 15 + nivel * 2;
                defensaEnemigo <- 5 + nivel;

            4:
                nombreEnemigo <- "Hechicero oscuro";
                vidaEnemigo <- 60 + nivel * 10;
                ataqueEnemigo <- 18 + nivel * 2;
                defensaEnemigo <- 3 + nivel;
        FinSegun
    FinSi
FinSubProceso


SubProceso SubirNivel(experiencia Por Referencia, experienciaNecesaria Por Referencia, nivel Por Referencia, vida Por Referencia, vidaMaxima Por Referencia, ataque Por Referencia, defensa Por Referencia)
    Mientras experiencia >= experienciaNecesaria Hacer
        experiencia <- experiencia - experienciaNecesaria;
        nivel <- nivel + 1;
        experienciaNecesaria <- experienciaNecesaria + 50;

        vidaMaxima <- vidaMaxima + 20;
        ataque <- ataque + 4;
        defensa <- defensa + 2;
        vida <- vidaMaxima;

        Escribir "";
        Escribir "====================================";
        Escribir "        ¡SUBISTE DE NIVEL!";
        Escribir "====================================";
        Escribir "Ahora sos nivel ", nivel;
        Escribir "Tu vida, ataque y defensa aumentaron.";
    FinMientras
FinSubProceso


SubProceso Tienda(oro Por Referencia, pociones Por Referencia, ataque Por Referencia, defensa Por Referencia)
    Definir opcion Como Entero;

    Limpiar Pantalla;
    Escribir "====================================";
    Escribir "              TIENDA";
    Escribir "====================================";
    Escribir "Oro disponible: ", oro;
    Escribir "";
    Escribir "1. Poción - 20 oro";
    Escribir "2. Mejorar ataque - 50 oro";
    Escribir "3. Mejorar defensa - 50 oro";
    Escribir "4. Volver";
    Leer opcion;

    Segun opcion Hacer
        1:
            Si oro >= 20 Entonces
                oro <- oro - 20;
                pociones <- pociones + 1;
                Escribir "Compraste una poción.";
            SiNo
                Escribir "No tenés suficiente oro.";
            FinSi;

        2:
            Si oro >= 50 Entonces
                oro <- oro - 50;
                ataque <- ataque + 3;
                Escribir "Tu ataque aumentó.";
            SiNo
                Escribir "No tenés suficiente oro.";
            FinSi;

        3:
            Si oro >= 50 Entonces
                oro <- oro - 50;
                defensa <- defensa + 2;
                Escribir "Tu defensa aumentó.";
            SiNo
                Escribir "No tenés suficiente oro.";
            FinSi;
    FinSegun

    Esperar Tecla;
FinSubProceso


SubProceso Combatir(nombre, clase, vida Por Referencia, vidaMaxima, ataque, defensa, pociones Por Referencia, nombreEnemigo, vidaEnemigo Por Referencia, ataqueEnemigo, defensaEnemigo)
    Definir opcion, danio, danioEnemigo, probabilidad Como Entero;

    Mientras vida > 0 Y vidaEnemigo > 0 Hacer
        Limpiar Pantalla;

        Escribir "====================================";
        Escribir nombre, " VS ", nombreEnemigo;
        Escribir "====================================";
        Escribir nombre, ": ", vida, "/", vidaMaxima, " HP";
        Escribir nombreEnemigo, ": ", vidaEnemigo, " HP";
        Escribir "";
        Escribir "1. Atacar";
        Escribir "2. Ataque especial";
        Escribir "3. Defender";
        Escribir "4. Usar poción";
        Leer opcion;

        Segun opcion Hacer
            1:
                danio <- CalcularDanio(ataque, defensaEnemigo);
                probabilidad <- Aleatorio(1,100);

                Si probabilidad <= 15 Entonces
                    danio <- danio * 2;
                    Escribir "¡GOLPE CRITICO!";
                FinSi

                vidaEnemigo <- vidaEnemigo - danio;
                Escribir "Causás ", danio, " puntos de daño.";

            2:
                Segun clase Hacer
                    "Guerrero":
                        danio <- ataque * 2 - defensaEnemigo;
                        Escribir "¡GOLPE DEVASTADOR!";

                    "Mago":
                        danio <- ataque * 2 + Aleatorio(5,15);
                        Escribir "¡BOLA DE FUEGO!";

                    "Arquero":
                        danio <- ataque + Aleatorio(10,20);
                        Escribir "¡FLECHA PRECISA!";
                FinSegun

                Si danio < 1 Entonces
                    danio <- 1;
                FinSi

                vidaEnemigo <- vidaEnemigo - danio;
                Escribir "Causás ", danio, " puntos de daño.";

            3:
                Escribir "Te preparás para recibir el ataque.";

            4:
                Si pociones > 0 Entonces
                    vida <- vida + 40;

                    Si vida > vidaMaxima Entonces
                        vida <- vidaMaxima;
                    FinSi

                    pociones <- pociones - 1;
                    Escribir "Usaste una poción. Vida actual: ", vida;
                SiNo
                    Escribir "No te quedan pociones.";
                FinSi;
        FinSegun

        Si vidaEnemigo > 0 Entonces
            danioEnemigo <- CalcularDanio(ataqueEnemigo, defensa);

            Si opcion = 3 Entonces
                danioEnemigo <- Trunc(danioEnemigo / 2);
            FinSi

            vida <- vida - danioEnemigo;
            Escribir nombreEnemigo, " te causa ", danioEnemigo, " de daño.";
        FinSi

        Esperar Tecla;
    FinMientras
FinSubProceso


Proceso RPG_ClubProgramador
    Definir nombre, clase, nombreEnemigo Como Cadena;
    Definir vida, vidaMaxima, ataque, defensa Como Entero;
    Definir nivel, experiencia, experienciaNecesaria Como Entero;
    Definir oro, pociones, combatesGanados Como Entero;
    Definir vidaEnemigo, ataqueEnemigo, defensaEnemigo Como Entero;
    Definir opcion Como Entero;
    Definir jugando Como Logico;

    Limpiar Pantalla;

    Escribir "====================================";
    Escribir "       REINOS DE PSEINT";
    Escribir "====================================";
    Escribir "¿Cómo se llama tu héroe?";
    Leer nombre;

    Escribir "";
    Escribir "Elegí una clase:";
    Escribir "1. Guerrero";
    Escribir "2. Mago";
    Escribir "3. Arquero";
    Leer opcion;

    CrearPersonaje(opcion, clase, vidaMaxima, ataque, defensa);

    vida <- vidaMaxima;
    nivel <- 1;
    experiencia <- 0;
    experienciaNecesaria <- 100;
    oro <- 30;
    pociones <- 3;
    combatesGanados <- 0;
    jugando <- Verdadero;

    Mientras jugando Hacer
        MostrarEstado(nombre, clase, nivel, vida, vidaMaxima, ataque, defensa, experiencia, experienciaNecesaria, oro, pociones, combatesGanados);

        Escribir "";
        Escribir "1. Buscar enemigo";
        Escribir "2. Ir a la tienda";
        Escribir "3. Descansar";
        Escribir "4. Salir";
        Leer opcion;

        Segun opcion Hacer
            1:
                CrearEnemigo(nivel, combatesGanados, nombreEnemigo, vidaEnemigo, ataqueEnemigo, defensaEnemigo);

                Escribir "";
                Escribir "¡APARECE ", nombreEnemigo, "!";
                Esperar Tecla;

                Combatir(nombre, clase, vida, vidaMaxima, ataque, defensa, pociones, nombreEnemigo, vidaEnemigo, ataqueEnemigo, defensaEnemigo);

                Si vida <= 0 Entonces
                    Limpiar Pantalla;
                    Escribir "====================================";
                    Escribir "             GAME OVER";
                    Escribir "====================================";
                    Escribir nombre, " ha sido derrotado.";
                    Escribir "Nivel alcanzado: ", nivel;
                    Escribir "Combates ganados: ", combatesGanados;
                    jugando <- Falso;
                SiNo
                    Si nombreEnemigo = "Dragon Oscuro" Entonces
                        Limpiar Pantalla;
                        Escribir "====================================";
                        Escribir "        ¡VICTORIA FINAL!";
                        Escribir "====================================";
                        Escribir nombre, " derrotó al Dragon Oscuro.";
                        Escribir "El reino vuelve a estar a salvo.";
                        jugando <- Falso;
                    SiNo
                        combatesGanados <- combatesGanados + 1;
                        oro <- oro + Aleatorio(15,35);
                        experiencia <- experiencia + Aleatorio(35,60);

                        Escribir "¡Victoria! Ganaste oro y experiencia.";

                        SubirNivel(experiencia, experienciaNecesaria, nivel, vida, vidaMaxima, ataque, defensa);
                        Esperar Tecla;
                    FinSi
                FinSi;

            2:
                Tienda(oro, pociones, ataque, defensa);

            3:
                vida <- vidaMaxima;
                Escribir "Descansaste y recuperaste toda tu vida.";
                Esperar Tecla;

            4:
                jugando <- Falso;

            De Otro Modo:
                Escribir "Opción inválida.";
                Esperar Tecla;
        FinSegun
    FinMientras

    Escribir "";
    Escribir "Gracias por jugar.";
FinProceso

4. La función CalcularDanio

CalcularDanio() recibe el ataque de quien golpea y la defensa de quien recibe el golpe. Agregamos un pequeño valor aleatorio para que los ataques no causen exactamente el mismo daño en cada turno.

La función devuelve un número entero y garantiza un mínimo de 1 punto de daño. Es un buen ejemplo de una tarea pequeña que conviene aislar porque se utiliza tanto para el jugador como para los enemigos.

5. Parámetros Por Referencia

En varios SubProcesos usamos Por Referencia. Esto permite que una modificación realizada dentro del SubProceso afecte directamente a la variable original.

Por ejemplo, la tienda puede descontar oro y aumentar el ataque:

Tienda(oro, pociones, ataque, defensa);

Como esas variables se reciben Por Referencia, los cambios siguen existiendo cuando volvemos al proceso principal.

6. Generación de enemigos

CrearEnemigo() usa Aleatorio(1,4) para elegir uno de cuatro enemigos. Sus estadísticas además dependen del nivel actual del jugador, por lo que los combates se vuelven progresivamente más difíciles.

Cuando el jugador alcanza cinco victorias dejamos de generar enemigos normales y aparece el Dragón Oscuro.

7. El sistema de combate

Mientras tanto el jugador como el enemigo tengan vida, el combate continúa. Cada turno permite:

  • realizar un ataque normal;
  • usar una habilidad especial propia de la clase;
  • defenderse para reducir el siguiente daño;
  • usar una poción.

Los ataques normales tienen además un 15 % de probabilidad de convertirse en golpes críticos y causar el doble de daño.

8. Experiencia y niveles

Después de cada victoria se obtiene experiencia. Cuando alcanza el valor necesario se ejecuta SubirNivel().

Al subir de nivel aumentan la vida máxima, el ataque y la defensa. También restauramos completamente la vida del personaje.

Usamos un ciclo Mientras dentro del SubProceso para contemplar incluso el caso en que una recompensa grande permita subir más de un nivel.

9. La tienda

El oro ganado puede invertirse en:

  • pociones;
  • mejoras de ataque;
  • mejoras de defensa.

Esta mecánica introduce una pequeña decisión estratégica: guardar oro para mejorar estadísticas o gastar antes para tener más recursos durante los combates.

10. Ideas para seguir mejorándolo

El juego todavía puede crecer mucho. Algunos desafíos interesantes son:

  • agregar maná y hacer que los ataques especiales tengan un costo;
  • incorporar enfriamiento para las habilidades especiales;
  • crear más clases;
  • agregar armaduras y armas;
  • incorporar distintos jefes;
  • crear probabilidades de esquivar ataques;
  • agregar estados como veneno o quemadura;
  • crear un inventario con vectores;
  • guardar puntuaciones de diferentes jugadores;
  • incorporar un mapa o mazmorra usando matrices.

Desafío

Intentá agregar una cuarta clase llamada Paladín. Debería tener mucha defensa y una habilidad especial que, además de causar daño, recupere una pequeña cantidad de vida.

Después intentá agregar un enemigo nuevo con una habilidad especial propia.

Seguí aprendiendo PSeInt

Si todavía no trabajaste con SubProcesos y Funciones, te conviene revisar primero nuestra guía:

Funciones y SubProcesos en PSeInt →

También podés encontrar todos los ejercicios y proyectos en la guía principal:

Aprender PSeInt: guía completa y ejercicios resueltos →

Base matemática

Una intriga muy común que surge en todo nuevo aprendiz en la programación es el nivel matemático requerido para esta disciplina. En las carreras universitarias del área siempre nos vamos a encontrar con materias como álgebra, cálculo, probabilidad, estadísticas, matemática discreta, geometría analítica, entre otras, dependiendo del grado del título de la carrera.  Estas asignaturas proporcionan un importante sustento científico a los estudiantes que obtendrán su título para ejercer como futuros profesionales.

Pero vayamos al caso que nos interesa aquí, las personas que quieren aprender a programar por cuenta propia y deciden comenzar con la visita a diversos sitios que se correspondan al tema o leen libros hasta que se topan con esta gran interrogación: ¿Necesito saber matemática para programar?

Los cálculos que se procesan en un sistema pertenecen a un algoritmo que un programador tuvo que diseñar previamente, es decir, se efectúan operaciones que su creador tuvo que entender antes de resolverlas o al menos saber aplicarlas.

Lo cierto es que para adentrarse con un pie derecho en este mundo lo primero que se necesita es aprender propiedades básicas algebraicas que nos permitan resolver cálculos o plantear ecuaciones y funciones para desarrollar un problema en papel y luego poder programarlo en la computadora. Si ya tenes un poco de este manejo entonces podrás animarte a comenzar con la introducción a la lógica de programación y aprender a desarrollar algoritmos que resuelvan  tareas sencillas que en su conjunto conformarán un programa.

Entonces, de nuevo, ¿Es necesario saber matemática para programar?, la respuesta es sí, pero lo bueno es que podemos ir aprendiendo sus utilidades a medida que las vayamos necesitando. Como en cualquier disciplina que uno se tome con responsabilidad, sino sabemos como resolver algo tendremos que informarnos e investigar hasta dar con la respuesta que sepamos que es la correcta.

Por ejemplo, se puede no saber utilizar el 100% de las herramientas y utilidades que tiene Microsoft Word, pero si manejo las que necesito en cada caso podré crear un currículum, un informe, un libro u otro documento formal sin usar mas que una pequeña parte de esas utilidades. Si un día no se como aplicar una determinada sangría por ejemplo, entonces buscaré ejemplos en internet o lo consultare con alguien que si sepa lo que necesito para así aprender y luego aplicarlo.

Lo más importante acá es estar siempre dispuesto a seguir aprendiendo cosas nuevas o que mejoren lo que ya sabemos hacer. De nada sirve ir a la universidad, obtener un título y solo quedarnos con eso. La programación es un mundo que avanza muy rápidamente y no tardara en quedar obsoleto todo aquel que no se mantenga un poco actualizado. Internet es una gran herramienta tanto para el que está aprendiendo a programar como para el que ya trabaja como programador, en ambos casos siempre es necesario buscar ejemplos de cosas que queremos hacer como también aprender acerca del manejo de nuevos lenguajes, frameworks, etc. Antes solo habían libros para consulta, que son una gran fuente de aprendizaje pero podemos tardar mucho más en encontrar una respuesta que se ajuste a nuestro problema, entonces aprovechemos esta gran ventaja que nos deja la web.

La idea de esta publicación es animar a todos aquellos que tengan miedo a encontrarse con matemáticas en la carrera del programador…sepan que no es tan difícil como suele plantearse. En la mayoría de los casos, todo depende mas bien del área en el que nos vayamos a desarrollar…pero con esfuerzo y dedicación mas que nada todo se aprende.

 

 

Trazas: verificación de algoritmos

La traza de un programa indica la secuencia de instrucciones de su ejecución, así como, el valor de las variables del algoritmo después de cada instrucción. Cada fila de la tabla es un ciclo de ejecución, excepto la primera que contiene los valores iniciales. El principal objetivo de una traza es evaluar la ejecución de un algoritmo para corroborar que haga exactamente lo que se quiere y detectar errores en el caso de que no. Solo necesitamos el algoritmo a evaluar, un lápiz y un papel.

En el siguiente ejemplo puede verse un algoritmo que suma números y a su derecha la traza correspondiente para los valores iniciales de variables «nro» igual a 1 y «resul» igual a 0. Se debe seguir paso a paso cada instrucción del algoritmo como si nosotros fuéramos el procesador y en cada ciclo del «Mientras» se obtendrán nuevos valores para las variables mencionadas, en el primer ciclo se obtiene que nro = 2 y resul = 1, en el siguiente ciclo tacho estos valores (a modo de evitar confusiones) y en la fila siguiente completo los valores correspondientes que serían en este caso nro = 3 y resul = 3. Esto continúa repetitivamente hasta que se cumpla la condición de corte del ciclo «Mientras» y después seguiría hasta finalizar cada instrucción siguiente del algoritmo. Se obtienen los siguientes valores del proceso total del algoritmo: nro = 5 y resul = 10.

Compiladores, Intérpretes y Entornos de desarrolo

COMPILADORES DE LENGUAJES

Un compilador es un programa informático, que se encarga de traducir el código fuente de una aplicación que esté en desarrollo.  Convierte un programa hecho en lenguaje de programación de alto nivel a un lenguaje de máquina, el cual es conocido como de bajo nivel, de tal forma que sea  más entendible y mucho más fácil de procesar en el equipo en el que se esta ejecutando.

En el desarrollo de un programa, durante la fase de codificación se lleva a cabo la compilación, que consiste en que el compilador traducirá el código fuente a código máquina, también llamado código objeto, siempre y cuando, el propio compilador no detecte ningún error en dicho código fuente.

 

CONVERSION
La imagen ilustra como el código fuente ingresado por el programador es convertida a lenguaje máquina para traducirse en un programa ejecutable.

 

CONVERSION 2
Secuencia empleada por un compilador para llegar desde el código fuente al código máquina resultante antes de ejecutarse.

 

CONVERSION 3
Ejemplo de una compilación de codigo fuente escrito con lenguaje de programación Java.

INTÉRPRETES DE LENGUAJES

Es un programa capaz de analizar y ejecutar programas escritos en un determinado lenguaje de programación.

Los intérpretes se diferencian de los compiladores  en que mientras estos traducen un programa desde su código fuente  escrito en un lenguaje de programación al código máquina del sistema, los intérpretes sólo realizan la traducción a medida que sea necesaria, instrucción por instrucción, y normalmente no guardan el resultado de dicha traducción.

Usando un intérprete, un solo archivo fuente puede producir resultados iguales incluso en sistemas sumamente diferentes (ejemplo. una PC y una PlayStation 4).

Usando un compilador, un solo archivo fuente puede producir resultados iguales solo si es compilado a distintos códigos ejecutables específicos a cada sistema.

interprete
Secuencia que realiza un intérprete para llegar desde el código fuente al código máquina a medida que se va ejecutando.

NIVELES DE LENGUAJES DE PROGRAMACIÓN

Los lenguajes de programación tienen una estructura que permite a los programadores diseñar programas de una forma mucho más amigable y comprensible que si tuvieran que hacerlo directamente en el código máquina que entiende la computadora, el  cual se compone únicamente de ceros y unos. De acuerdo a la complejidad de la traducción que existe para llegar de un lenguaje formal de programación al lenguaje máquina se determinan los siguientes niveles:

niveles

DEPURACIÓN DE PROGRAMAS

La depuración de un programa es el proceso de identificar y corregir errores de programación. En inglés se le conoce como debugging y si bien existen depuradores que permiten encontrar errores sistemáticos existen prácticas manuales asociadas a la calidad del software en desarrollo.

ENTORNO DE DESARROLLO INTEGRADO (IDE)

Un entorno de desarrollo integrado es un entorno de programación conformado por un editor de código, un compilador, un depurador y un constructor de interfaz gráfica (GUI).

Algunos ejemplos de entornos de desarrollo:

Entornos para C++:

  • Borland C
  • Code Blocks

Entornos para Java:

  • Netbeans
  • Jcreator
  • Eclipse

Entornos para VB, C#, Asp.Net:

  • Microsoft Visual Studio

 

Llevá estos conceptos a la práctica

Después de entender compiladores, intérpretes y entornos de desarrollo, podés empezar a practicar lógica de programación con la guía completa de PSeInt.

Si preferís avanzar hacia un lenguaje de programación, también tenés disponible la ruta completa de Python.

Continúa aquí con el siguiente post.

Introducción básica

En este primer post, como era de esperarse, veremos un poco de teoría introductoria, solo un poco antes de comenzar con la acción, si bien suele ser la parte aburrida para muchos, es necesaria para el manejo de conceptos básicos que se utilizaran en la práctica.

Informática es un término que reúne dos conceptos, el de “información” y el de “automático”. De esta forma, la informática se refiere al procesamiento automático de datos mediante dispositivos electrónicos y sistemas computacionales para así obtener información útil para el usuario.

proceso

Para que las máquinas y computadoras puedan procesar datos ingresados, se utilizan algoritmos cuyas instrucciones indican como será el procesamiento de estos para así devolver información útil para el usuario.

ALGORITMOS

Un algoritmo es una lista bien definida, ordenada y finita de operaciones, que permite encontrar la solución a un problema determinado. Es conceptual y se puede describir usando el lenguaje natural que usamos día a día, diagramas de flujo o pseudocódigo para luego ser implementado en uno o varios lenguajes formales de programación.

PSEUDOCÓDIGO

Se llama pseudocódigo a una forma intermedia entre usar lenguaje natural y un lenguaje de programación. No posee una forma estricta pero normalmente se respeta lo siguiente:

Se usa el concepto de variable y asignación.

Ej: “a <- 5” significa que a la variable a se le asignó el valor 5.

Se indican los datos de entrada y de salida.

Utilizan instrucciones condicionales e instrucciones de ciclo.

Ejemplo 1:

//Algoritmo para definir si un triángulo es escaleno, isósceles o equilátero.

Datos de entrada: l1, l2, l3 //lados del triángulo

Datos de salida: tipo

Algoritmo triangulos
	Si (lado1 = l2) y (l1 = l3) entonces
	  tipo <- equilátero
	sino
	   Si (l1=l2) ó (l1=l3) ó (l2=l3) entonces
	      tipo <- isósceles
	   Sino
	       tipo <- escaleno
	   FinSi
	FinSi
FinAlgoritmo

Ejemplo 2:

//Algoritmo que suma los números del 1 al 9 inclusive.
	nro <- 1
	resultado <- 0
		Mientras nro<=9
			resultado <- resultado + nro
			nro <- nro +1
		Fin Mientras
	Escribir resultado
FinAlgoritmo

Ejemplo 3:

//Algoritmo que suma los números pares comprendidos entre
 1 y 15 inclusive.

Algoritmo suma
	nro <- 1
	resultado <- 0
		Mientras nro<=15
	  		Si nro MOD 2 = 0 entonces 
	                    resultado <- resultado + nro 			
                        FinSi 			
                        nro -> nro+1
		Fin Mientras
	Escribir resultado
FinAlgoritmo

 

  • En el ejemplo anterior se utiliza la función MOD, la cual calcula el resto de la división entre dos nros. Si el resto de la división del nro por 2 es 0 entonces es par y se suma al resultado, de lo contrario es impar y no se suma al resultado.

DIAGRAMA DE FLUJO DE DATOS (DFD)

El diagrama de flujo es una metodología gráfica de representar un algoritmo, cada instrucción existente en pseudocódigo tiene su correspondiente símbolo gráfico en DFD. Favorecen la comprensión de un proceso mediante el uso de un dibujo.
La simbología en DFD puede variar un poco de acuerdo a la aplicación que la grafique y sus normas de estandarización pero en general se utilizan las que muestra la siguiente imagen:

simbolos

Ejemplo : En el siguiente ejemplo se presenta un algoritmo que determina si un número es positivo o negativo y a lado se muestra su gráfico correspondiente en DFD:

InicioAlgoritmodfd1

Leer n

Si n > 0 entonces

        Escribir “Positivo”

Sino

        Escribir  “Negativo”

FinAlgoritmo

PROGRAMA

Básicamente, un programa informático es un conjunto de instrucciones en forma secuencial, que a través de su interpretación por el sistema operativo o hardware, le permiten desarrollar una tarea específica a una computadora.

Diferencias entre Programas y Algoritmos:

  • Cuando hablamos de programa siempre existe la idea de que será ejecutado por una computadora mientras que un algoritmo podría ser ejecutado por una persona.
  • Un programa está escrito en lenguaje máquina o por lo menos en un lenguaje de programación que pueda ser compilado o interpretado por algún tipo de máquina.

LENGUAJES DE PROGRAMACIÓN

  • Es un idioma artificial diseñado para expresar instrucciones que pueden ser llevadas a cabo por máquinas y computadoras.
  • Está formado de un conjunto de símbolos y reglas sintácticas y semánticas que definen su estructura y el significado de sus elementos y expresiones.

Algunos ejemplos de lenguajes de programación son los siguientes:

LOGOS

CÓDIGO FUENTE DE UN PROGRAMA

El código fuente es el archivo con las instrucciones necesarias escritas en un lenguaje de programación, que sirve para compilar posteriormente un programa que pueda ser utilizado por el usuario de forma directa ejecutándolo.

Ejemplo 1: Código fuente en lenguaje de programación C

C

Ejemplo 2: Código fuente en lenguaje de programación Java

java

Ejemplo 3: Código fuente en lenguaje de programación PHP

php

Empezá a practicar con PSeInt

Si querés llevar estos conceptos de algoritmos y pseudocódigo a la práctica, podés continuar con la guía completa de PSeInt y los 20 ejercicios resueltos de ciclos y condicionales.

Cuando ya tengas una base sólida, también podés dar el salto a un lenguaje real con De PSeInt a Python: 10 algoritmos traducidos paso a paso.

Continúa aquí con el siguiente post.