Conceptos básicos de programación

Aprende a programar con Karel

En esta lección veremos algunos conceptos de programación un tanto complejos. Dominar estos conceptos es un proceso que tarda tiempo y experiencia con un lenguaje de programación. En este curso, no esperamos que domines estos conceptos de inmediato, pero es recomendable que los conozcas para que puedas aplicarlos en el futuro.

Conceptos básicos de programación

  • Programación: es la actividad por la cual las personas entregan a una computadora un conjunto de instrucciones que, al ejecutarlas, permite a la computadora resolver un problema.
  • Los conjuntos de instrucciones que las computadoras reciben se denominan programas.
  • En programación, muchas veces se pueden seguir diferentes rutas para completar una tarea, y el programador debe imaginar cuáles son y elegir una.
  • Algunos de estos caminos pueden ser más eficientes que otros.
  • Para darle instrucciones a una computadora, necesitamos utilizar un lenguaje de programación.
  • En esta lección, aprenderemos conceptos básicos de programación para desarrollar el pensamiento abstracto y lógico necesario para comunicarnos eficientemente con la computadora.
  • El lenguaje de programación que usaremos es R.
  • Para comprender algunas ideas básicas de programación, utilizaremos a Karel, un robot que se mueve por mundos rectangulares.
  • En esta primera lección, el objetivo no es aprender R, sino comprender conceptos básicos de programación y cómo se aplican en R.
  • Las dos habilidades que deberás desarrollar son:
    • Diseñar algoritmos: desarrollar o elegir un algoritmo que resuelva un problema.
    • Codificación: escribir el algoritmo en un lenguaje de programación para que la computadora pueda entenderlo y ejecutarlo.

Qué es Karel

  • Karel es un robot que vive en un mundo de cuadrículas diseñado para enseñar conceptos básicos de programación.
  • Karel recibe instrucciones en español para moverse por el mundo y realizar tareas específicas.
  • Gracias a que observarás cómo Karel se mueve y realiza tareas, podrás comprender mejor los conceptos de programación, así como los errores que pueden surgir al programar.
  • Los errores de programación se llaman bugs, palabra que viene de un error en una computadora en 1947 debido a una polilla.
  • Le daremos a Karel instrucciones para que resuelva un problema (algoritmo). Cada instrucción del algoritmo modifica el mundo (entorno) de alguna manera y se denomina acción.

Instalar Karel en R

Primero, necesitas instalar y cargar el paquete karel en R. Esta es una de las pocas lecciones que requieren que tengas R instalado en tu computadora ya que el código de Karel genera una animación que no se puede visualizar en la versión en línea. Si tienes problemas en instalarlo, no dudes en comunicarte con nosotros.

Para instalar Karel, ejecuta el siguiente código. Un paquete se instala una sola vez, pero cada vez que lo queramos usar debemos cargarlo para que las herramientas que trae queden a nuestra disposición.

Tip

Cuando veas un bloque de código como el que sigue, puedes copiarlo y pegarlo en la consola de R para ejecutarlo. Si acercas el cursor al bloque, verás un botón para copiar el código en la parte superior derecha.

install.packages("karel")

library(karel)

Si no puedes instalarlo con este código, intenta con el código alternativo que se muestra a continuación. Si ya pudiste instalarlo, puedes saltar al siguiente paso.

Primero tienes que instalar devtools, que es un paquete que te permite instalar paquetes directamente desde GitHub. Después, instala el paquete karel desde GitHub.

install.packages("devtools")
devtools::install_github("mpru/karel")
library(karel)

Generar un mundo

  • Si ya cargaste el paquete karel, estás listo para comenzar a programar a Karel.
  • El primer paso es crear un mundo para Karel.
  • Esto se hace con la función generar_mundo().
  • Dentro de los paréntesis, debes especificar el nombre del mundo que deseas crear.
  • El paquete Karel viene con varios mundos predefinidos que puedes usar. Por ejemplo, mundo001.
  • Corre el siguiente código para generar el mundo llamado mundo001.
generar_mundo("mundo001")
  • Una vez que hayas ejecutado el código, verás una ventana emergente con el mundo de Karel.
  • Observa que el mundo está formado por cuadrículas y Karel se encuentra en una posición específica.
  • Las calles son las fila del mundo rectangular, es decir, las calles corren horizontalmente.
  • Las avenidas corren verticalmente (columnas).
  • La intersección entre una calle y una avenida es llamada celda y se puede identificar por los números fuera del recuadro.
  • Karel siempre mira hacia una de las cuatro direcciones posibles: este, norte, oeste o sur.
  • Los bordes negros representan paredes que Karel no puede cruzar.
  • El cubo morado se llama en el programa un coso. Estos cosos pueden ser tomados por Karel y guardarlos en su mochila. En el mundo que acabamos de crear, el coso se encuentra en la celda (2, 1)

Acciones de Karel

  • Karel puede realizar las siguientes acciones:
  • avanzar(), se mueve un paso hacia la celda que tiene adelante, si no hay una pared que se lo impida.
  • girar_izquierda(), rota 90 grados hacia su izquierda (sentido contrarreloj).
  • juntar_coso(), levanta el coso que hay en su celda y lo guarda en su mochila. Debe haber al menos un coso en la celda para que Karel pueda realizar esta acción.
  • poner_coso(), toma un coso de su mochila y lo coloca en la celda. Debe haber al menos un coso en la mochila de Karel para que pueda realizar esta acción.
  • ejecutar_acciones(), después de decirle a Karel que queremos que haga, esta función le dice a Karel que ejecute las instrucciones.

Como vimos previamente, una función en R se escribe igual que las acciones de Karel. Piensa en la función print(). Recuerda que las funciones reciben argumentos dentro de los paréntesis, como print("Hola, mundo!").

Veamos un primer ejemplo. Vamos a pedirle a Karel que avance, junte el coso y vuelva a avanzar:

generar_mundo("mundo001")
avanzar()
juntar_coso()
avanzar()
ejecutar_acciones()

Warning

Qué pasa si intentas avanzar cuando hay una pared enfrente de Karel? Intenta hacerlo y observa el resultado.

generar_mundo("mundo001")
avanzar()
juntar_coso()
avanzar()
avanzar()
ejecutar_acciones()

Ejercicio 2

  • Karel junte el coso, lo coloque en la Calle 2 y Avenida 5 y finalmente avance a la Calle 2 y Avenida 6

  • Los primeros tres comandos que necesitamos en el programa son los mismos de antes, pero luego Karel tiene que girar a su izquierda para poder bordear la pared y avanzar un lugar, quedando de cara al norte:

  • Ahora necesitamos que Karel gire a la derecha, para que quede mirando al este.
  • Sin embargo, Karel sólo sabe girar a la izquierda, no existe ninguna función girar_derecha()
  • se puede lograr el mismo efecto girando tres veces a la izquierda. Luego, sólo resta que avance, coloque el coso y vuelva a avanzar una vez
> generar_mundo("mundo001")
> avanzar()
> juntar_coso()
> avanzar()
> girar_izquierda()
> avanzar()
> girar_izquierda()
> girar_izquierda()
> girar_izquierda()
> avanzar()
> avanzar()
> poner_coso()
> avanzar()
> ejecutar_acciones()

Descomponer un problema en pasos

  • Los algoritmos pueden dividirse en subalgoritmos que abordan partes más pequeñas del problema, lo que se conoce como descomposición algorítmica o modular.
  • Un subalgoritmo se escribe una vez y es reutilizado por cualquier algoritmo que lo necesite.
  • Los subalgoritmos son útiles en los siguientes casos:
    • Algoritmos complejos: Escribir un algoritmo complejo como un único bloque de código lo hace difícil de entender. Separar las partes en subalgoritmos independientes reduce la complejidad.
    • Operaciones repetidas: Si un problema implica tareas que se repiten varias veces, esas tareas pueden definirse como un subalgoritmo separado, escrito una vez pero usado en múltiples lugares.
  • En programación, existen varios términos para diferentes tipos de subalgoritmos, como subrutinas, funciones, procedimientos, métodos y subprogramas. En este tutorial, al usar R, nos referiremos a los subalgoritmos como funciones.
  • Muchas de las funciones que usamos en R son funciones predefinidas, como print(), mean(), sum(), etc.
  • Sin embargo, también podemos crear nuestras propias funciones para resolver problemas específicos.

Función Girar Derecha

  • En la sección anterior Karel necesitaba doblar a la derecha y lo logramos indicándole que gire tres veces a la izquierda.
  • Vamos a crear una función que nos permita girar a la derecha.
  • En R, las funciones se crean con la palabra clave function. Observa el siguiente código que indica la estructura básica de una función en R:
nombre_funcion_nueva <- function() {
    # Código de la función
}
  • Ahora, para crear la función girar_derecha(), necesitamos que Karel gire tres veces a la izquierda.
  • Vamos a crearla:
girar_derecha <- function() {
  girar_izquierda()
  girar_izquierda()
  girar_izquierda()
}
  • Observa que usamos el operador de asignación <- para asociar a ese nombre la definición de una función, similar a como lo hacemos con las variables.
  • Nota que tienes que ejecutar el código para que la función girar_derecha() esté disponible en tu sesión de R.
  • Ahora, vamos a usar la función girar_derecha() en el programa de Karel para que pueda girar a la derecha.
generar_mundo("mundo001")
avanzar()
juntar_coso()
avanzar()
girar_izquierda()
avanzar()
# Ahora Karel puede girar a la derecha
girar_derecha()
avanzar()
avanzar()
poner_coso()
avanzar()
ejecutar_acciones()

Función Dar Vuelta

  • Ahora vamos a crear una función que nos permita dar vuelta a Karel 180 grados que permita a Karel mirar hacia la dirección contraria.
  • Para esto, vamos a crear la función dar_vuelta() que consiste en dos giros a la izquierda.
  • Intenta crear la función dar_vuelta() en R.
  • Si tienes problemas, puedes ver la solución a continuación.
Mostrar Respuesta 
dar_vuelta <- function() {
  girar_izquierda()
  girar_izquierda()
}
  • Ahora, vamos a usar la función dar_vuelta() en el programa de Karel para que pueda girar 180 grados.
  • Si tienes problemas, puedes ver la solución a continuación.
Mostrar Respuesta 
generar_mundo("mundo001")
avanzar()
juntar_coso()
avanzar()
girar_izquierda()
avanzar()
girar_derecha()
avanzar()
avanzar()
poner_coso()
avanzar()
# Ahora Karel puede dar vuelta
dar_vuelta()
avanzar()
ejecutar_acciones()

Funciones integradas

  • La mayoría de las veces, los paquetes de R vienen con funciones predefinidas que puedes usar para realizar tareas específicas.
  • El paquete de Karel tiene algunas funciones extra que podemos utilizar sin necesidad de crear nuestras funciones propias.
  • Para esto, tenemos que cargar la función cargar_super_karel() para que Karel pueda usar estas funciones.
  • Observa que esto es similar a lo que hacemos con los paquetes de R, como library().
library(karel)
cargar_super_karel()
  • Con esto, podemos usar girar_derecha() y darse_vuelta() sin necesidad de crear nuestras propias funciones.

más ejercicios

  • Antes de continuar con los siguientes temas, intenta resolver los siguientes ejercicios con lo que has aprendido hasta ahora.

  • Si tienes problemas en solucionarlos, corre el código de Karel con pocos pasos y observa lo que está haciendo bien y lo que está haciendo mal.

  • genera el mundo mundo010 y resuelve el siguiente problema:

  • Karel debe tomar los 4 cosos y dejarlos en 4 posiciones distintas.

Mostrar posible Respuesta 
generar_mundo("mundo010")
avanzar()
juntar_coso()
juntar_coso()
juntar_coso()
juntar_coso()
avanzar()
poner_coso()
avanzar()
poner_coso()
avanzar()
poner_coso()
girar_izquierda()
avanzar()
poner_coso()
ejecutar_acciones()

:::

  • Genera el mundo mundo004 y toma el coso de la celda (1,6). Luego, Karel debe avanzar hasta la celda (1,8) y poner el coso en esa celda.
Mostrar posible Respuesta 
cargar_super_karel()
generar_mundo("mundo004")
avanzar()
avanzar()
avanzar()
avanzar()
avanzar()
# funcion de super_karel
girar_derecha()
avanzar()
juntar_coso()
darse_vuelta()
avanzar()
girar_derecha()
avanzar()
avanzar()
girar_derecha()
avanzar()
poner_coso()
ejecutar_acciones()

:::

  • Intenta crear funciones para las tareas repetidas. Por ejemplo, si necesitas que Karel avance 3 veces, puedes crear una función avanzar_tres() que haga avanzar a Karel 3 veces.

  • Extra: Inenta solucionar el siguiente ejercicio. Carga el mundo mundo009 e intenta que karel llegue al final del laberinto (donde se encuentra el coso) y lo tome. En la siguiente lección veremos cómo hacer esto de manera más eficiente.

  • Trata de cargar más mundos y explora!