Estamos en un proceso de migración de contenidos desde el sitio scratchbydsigno.com.ar hacia este nuevo blog.

La prioridad está centrada en los 3 Tutoriales que constituyen la base de dicho sitio, para luego seguir con el resto de los contenidos.

En caso de que encuentres algún error de visualización, o links rotos, puedes comunicármelo usando el formulario de contacto...

3er paso: generalizar un algoritmo (parte IV)

"¿Qué tal la relectura que dejé de tarea? ¿vino bien? ¿tomamos lección? Por las caras de pánico de algunos sospecho que no me han sido del todo sinceros con sus respuestas. Esto de ser viento, vela y navío es de veras cansador…"—extractado del libro "Crónicas de un docente del nuevo siglo", próximamente en todas las librerías y otros puntos de venta—
Siendo ya dueños de un gran bagaje de nuevos conocimientos y competencias, y con Pier más que recuperado (lo que no nos mata nos hace más fuerte, dicen que dijo Nietzsche), clavemos nuestros ojos con decisión al problema que tenemos enfrente.

Un flashback necesario

Intentemos con un voluntario flashback para refrescar ideas y ver donde estamos parados. Allí lejos y hace tiempo enunciamos las metas de nuestro 3er paso… dijimos cosas como:

"¿Existirá alguna manera de que con un sólo programa podamos indicarle a Pier que dibuje el polígono regular que querramos? Dicho de otra manera ¿se podrá llegar a un algoritmo genérico?
La meta del 3er paso será generar ese algoritmo, en el cual además con solo cambiar un (1) valor numérico podremos indicarle a Pier que dibuje el polígono regular que se nos ocurra…"

Referiéndonos luego a los 5 valores del algoritmo (el que ya conseguimos) que posibilitaban el correcto trazado de los polígonos, expresamos:

"… intentaremos ver de que forma interrelacionar los 5 valores de nuestro algoritmo de tal manera que 4 de ellos sean dependientes del valor restante (este último es el que tomaría el papel de variable independiente)"

Decidimos luego escoger como variable independiente al número de lados (n) de nuestros polígonos regulares.
Poco más adelante concluímos:

"Ya tenemos entonces una primera pieza para poder seguir nuestro trabajo: nuestra 1ª fórmula, justamente la que vincula los dos valores más relevantes dentro del algoritmo a la hora de dibujar nuestros polígonos regulares."

Hablamos allí de la fórmula γ = 360º / n, que vincula la cantidad de lados n y el ángulo de giro  γ  necesario para nuestro algoritmo genérico.
(FIN DEL FLASHBACK)
Vamos a trabajar a continuación sobre esta 1ra pieza , dejando la búsqueda de las 3 fórmulas restantes para más adelante.

Cuestión de vínculos

Tenemos un primer vínculo matemático entre dos variables, veremos ahora como reflejarlo en nuestro algoritmo.
Y si decimos que queremos controlar a voluntad la cantidad de lados del polígono a dibujar cambiando sólo un valor, deberemos tener en nuestro programa un lugar donde almacenar dicho valor para posteriormente referenciarlo usando su nombre… como ya lo habrás deducido, necesitamos crear una variable en el nuevo programa para Pier.
Deberemos abrir alguno de nuestros ya viejos proyectos que tuvieron a Pier de protagonista: puede ser el del cuadrado, el del triángulo o el del pentágono. Guardémoslo ahora con otro nombre (polígonos-1 puede ser una buena elección).
Es momento para crear una variable que llamaremos n (muy poco original), la que será el contenedor donde almacenaremos ese valor central para el funcionamiento de nuestro algoritmo: el número de lados del mismo.
Hasta aquí sin novedad en el frente. Ya tenemos una "cajita" para almacenar nuestra variable independiente número de lados n. ¿Pero cómo hacer ahora para determinar/calcular el valor de la variable dependiente ángulo de giro  γ ? ¿Cómo "reflejar el vínculo" entre ambas dentro de Scratch?
La respuesta está en el Área de Selección de bloques. Deberemos hacer clic en el botón Operadores… allí aparecererán una gran cantidad de bloques de operaciones —algebraicas, lógicas o booleanas, de trabajo con cadena de textos, etc.—
Estos bloques nos permitirán operar utilizando números y variables de contenido numérico o de texto, pero también pueden introducirse valores de los atributos de un objeto (posición, etc), o el resultado de la comprobación por verdadero o falso de alguno de los distintos sensores, y aún más: permiten la creación de expresiones de un alto grado de complejidad.
Sin embargo nuestras necesidades presentes no llegan a tanto: nuestra fórmula γ = 360º / n puede considerarse simple, y la manera en que se refleja en nuestro algoritmo y en nuestro programa a través de los bloques de instrucciones también lo será.
selección operadores

cálculo de ángulo
Fijate que en nuestro programa/algoritmo lo que va a terminar apareciendo son las implicancias de lo que una fórmula representa: una igualdad entre valores
es lo mismo colocar dentro de una casilla de bloques 90º que 360º/4

¿Se te está complicando? Pensá entonces metafóricamente: Pier anda "calculadora en mano", y cuando se enfrenta a este bloque debe hacer la cuenta pertinente, fijándose antes en el número que está dentro de la cajita de nombre n

Algoritmos face to face

Me parece que es buen momento para comparar dos algoritmos/programas: aquel algoritmo particular que implementamos para nuestro querido cuadrado (al finalizar el 1er paso de este Tutorial), y este algoritmo genérico del proyecto polígonos-1 que estamos tratando de implementar (todavía incompleto, es cierto).
cuadrado
cuadrado genérico
¿Vas viendo de que va la cosa? Prestá atención (en la 2ª imagen) a un detalle importante: una vez que fijamos el valor que tomará nuestra variable, ya no deberemos preocuparnos por "rellenar" la cantidad de repeticiones del bucle ni el ángulo de giro necesario que usará Pier.
Supongo que ya hiciste los cambios al programa original y lo habrás probado ¡Funciona exactamente igual! ¡El cuadrado dibujado por Pier es idéntico al que obtuvimos en su momento!
Probá ahora fijar n a 3 ¡Voilá!  Pier dibuja un triángulo similar al que también obtuvimos hace tiempo ¡y sólo cambiamos un número!

Vayamos al caso en que determinemos que n  valga 5: el resultado es calcado al que ya vimos al finalizar el 2do paso de nuestro Tutorial. Recordá que en esa misma página analizamos cuales valores debíamos cambiar en el algoritmo particular asociado al dibujo de un pentágono regular, de manera que pudiésemos cumplir con ciertas metas   [que el polígono quede centrado, que los colores de cada lado no se repitan y que se recorra el espectro de colores de manera equiespaciada, are you remember?].
Si no entendés a qué me refiero en este último párrafo —o porque nunca leíste la página en cuestión, o porque la pasaste por arriba, o porque te olvidaste de los contenidos allí expuestos— te recomiendo su lectura/relectura… lo que tenemos que seguir tratando a continuación está muy ligado a ello.

Les llegó el turno a los colores

Ya materializamos nuestro primer vínculo entre variables. Veamos ahora como vincular n con el valor a colocar en el bloque que instruye a Pier sobre el cambio de colores:   cambiar color del lápiz por ( )
¿Por qué seguir con el cambio de colores? Simplemente porque la meta propuesta y el análisis para concretarla ya estuvieron más que clarificadas… si no me creés mirá aquí.
La idea es que determinemos el valor del cambio en el color del lápiz pensando en "saltar" dentro de todo el espectro de colores una cantidad de veces igual a la que tenga los lados del polígono regular… de esa manera a Pier le quedaría en la mano (la pata, buéh) el mismo color azul tanto al inicio como al final de su periplo. Además esos "saltos" están pensados como equiespaciados.
La fórmula deducible para alcanzar esta meta indica que el cambio de color debe ser de 200 / n, y la construcción usando los bloques de programación es en un todo similar a la que usamos previamente para el ángulo de giro, por lo que no abundaremos en más explicaciones.
algoritmo genérico

Recordemos que esta meta propuesta del "salto" de colores es totalmente arbitraria, es una entre tantas posibles. No tiene ninguna incidencia sobre el objetivo central de nuestro proyecto, que es conseguir el dibujo de polígonos regulares a través de un algoritmo único.

Con este nuevo cambio conseguimos un segundo vínculo entre variables: ya no deberemos preocuparnos por cambiar el valor dentro del bloque cambiar color del lápiz por ( ) ya que el mismo será dependiente del valor de , y de aquí en adelante será calculado por el mismísimo programa —Pier y su calculadora—.
Ya es momento de guardar los cambios a este proyecto polígonos-1 (o el nombre que le hayas puesto).
Una vez hecho esto dedicate un tiempo para "jugar" cambiando los valores de , intentando que el polígono dibujado por Pier quede dentro del escenario y centrado. La experiencia que vas a ganar en este desafío va a ser muy importante para entender la solución que te voy a presentar recién en la página siguiente, paciencia.

¿Qué nos queda?

Lo que nos resta en adelante es inferir fórmulas de algún tipo que vinculen la cantidad de lados del polígono n con los 2 valores que controlan su tamaño y su posición dentro del escenario… todo un tema.
Por suerte Pier ya se adaptó al hecho de que tiene que "espiar y recordar" el valor que le pusimos en la cajita/variable etiquetada con n , y a que debe andar con la calculadora a mano para usarla allí donde sea necesario. El mismo arte, pero ahora con más ciencia…
Última actualización: Febrero 24, 2014

No hay comentarios.:

Publicar un comentario

© Scratch CodeLab | D153ñ0 b454d0 3n l4 pl4n71ll4 SimpleRWD d3 Oloblogger