Pensamiento Computacional
PEC7 - 2021-2
Fecha límite de realización: 27/12/2022
Objetivos
● Aprender a usar estructuras de control repetitivas, o lo que es lo mismo, bucles,
empleándolos adecuadamente para conseguir los requerimientos de un programa.
● Avanzar en el conocimiento del entorno del lenguaje de programación Processing.
● Aprender a crear un programa claro, debidamente estructurado y comentado para
poder ser fácilmente modificado e interpretado por cualquier persona que acceda al
código fuente.
Formato y fecha de entrega
Esta PEC consta de 4 ejercicios, que deben entregarse en archivos .pde independientes.
Asimismo, el ejercicio 1 consta de dos programas que también deberán entregarse de
forma independiente (no integrando ambos programas en un mismo programa). El
ejercicio 3 tiene además dos partes escritas que deberás incorporar como comentarios
dentro de tu programa. Se deben subir al REC del aula correspondiente en una carpeta
.zip.
Observaciones
Además de conseguir escribir el código fuente correspondiente a las especificaciones de
cada ejercicio, es muy importante que el código esté bien estructurado, organizado en
bloques lógicamente ordenados, así como que las líneas de código estén comentadas.
Por eso, comenta el código, estructura bien tu programa, y ​comenta cuál es la finalidad de
cada bloque de código.
1
Enunciado
Después de estudiar la documentación correspondiente a la PEC7, escribe las líneas de
código que sean necesarias para responder a las especificaciones de los ejercicios que
aparecen a continuación.
Ejercicio 1: Contando huecos (3.5 puntos)
A continuación se te muestra un código (por practicidad también lo tienes en formato .pde
adjunto a este enunciado) que pretende servir para contar cuántas letras minúsculas hay
entre una letra del abecedario seleccionada al azar y la letra z (sin contar la ñ):
// Obtenemos un número aleatorio entre 97 y 122, que, siguiendo el código ASCII, será la letra inicial
// (aleatoria)
// La instrucción int nos asegura que el número entre 97 y 122 elegido no va a tener decimales (va a ser un
// número entero)
int letter = int(random(97, 122));
// Declaramos una variable displacement para contar cuántos huecos hemos tenido que movernos hasta la
// letra z
int displacement = 0;
// Imprimimos la letra en la consola
println("Letra: ", char(letter));
// ESTO TE TOCA A TI
// Mientras la letra no sea la z (o lo que es lo mismo, mientras que la letra sea < 122), la hacemos avanzar
// hacia la z e incrementamos el valor de displacement
// Imprimimos la cantidad de huecos que ha tenido que avanzar la letra hasta la z
println("We needed " + displacement + " movements to get to the z letter");
Para tu información, los ordenadores, para poder trabajar con letras, y dado que
internamente solo pueden trabajar con 0 y 1, asocian un número a cada letra (en realidad
asocian un número a cada carácter, lo cual incluye letras minúsculas, mayúsculas, con
tildes, y caracteres especiales como por ejemplo ? o [ ). Una de las codificaciones más
habituales es el código ASCII, según el cual la letra ‘a’ minúscula es el número 97, la ‘b’ el
98… Y así hasta la ‘z’, que es el número 122 (sin contar la ñ). Así que si queremos decirle
a Processing que nos escriba en la consola la ‘a’, podemos decirle println(“a”); o también
podemos decirle println(char(97));. En este último caso, lo que le estamos diciendo es:
“Imprime por la consola el carácter asociado al número 97 en código ASCII”. Es decir, la
‘a’ minúscula.
En el programa que se te da, inicialmente definimos una variable letter que adoptará un
valor aleatorio entre 97 y 122 (y que estará asociada a una letra minúscula del abecedario
2
según el código ASCII), así como también se define una variable displacement que se
inicializa a cero. Asimismo, se imprime por la consola la letra que nos ha salido
aleatoriamente.
Tu misión consiste en crear dos programas diferentes, uno con un bucle while y otro
con un bucle for, que se encargue de hacer avanzar la variable letter hasta la z (o lo que
es lo mismo, hasta el valor 122), y aprovechar ese mismo bucle para que displacement
guarde el número de saltos que ha tenido que dar la letra en cuestión hasta llegar a la
letra z.
Al final del todo se escribirá una texto en la consola que dirá cuántos saltos ha tenido que
dar letter hasta llegar a la z. Aprovecha esta información para comprobar que tu programa
funciona adecuadamente.
Nota 1: como lo que estamos evaluando es tu capacidad de escribir bucles, y no tu
capacidad para dar un resultado correcto a este ejercicio, no se aceptará que realices
operaciones del estilo de displacement = 122 - letter ni similares. La variable displacement
ha de contar el número de saltos gracias al funcionamiento del bucle, simultáneamente al
avance de la variable letter (y, con esta última frase, ya te hemos dado mucha
información).
Nota 2: por las mismas razones que se acaban de exponer, no puedes emplear draw() en
este ejercicio.
Nota 3: entrega tus dos programas, con el bucle while y con el bucle for, en dos archivos
diferentes (como si fuesen dos ejercicios diferentes).
3
Ejercicio 2: Círculos aleatorios de colores (3.25
puntos)
A continuación se te muestra un código (por practicidad también lo tienes en formato .pde
adjunto a este enunciado) que dibuja un solo círculo con posición y tamaño aleatorio en el
lienzo. Verás que, además, en el código existe una variable llamada limit que no se utiliza.
int top = 865; // Número total de círculos
int diam_Max = 200; // Diámetro máximo de los círculos
float diameter; // Diámetro de los círculos
float pos_X, pos_Y; // Variables para la posición en X y en Y del centro de los círculos
float green, blue; // Variables para el color de los círculos
size(650, 650); // Tamaño del lienzo
background(255, 0, 0); // Fondo de color rojo
green = random(255); // Cantidad de verde aleatoria
blue = random(255); // Cantidad de azul aleatoria
noStroke(); // Sin contorno
fill(0, green, blue, 128); // Relleno de cada círculo
pos_X = random(width); // Posición en X del círculo aleatoria
pos_Y = random(height); // Posición en Y del círculo aleatoria
diameter = random(diam_Max); // Diámetro del círculo aleatorio
circle(pos_X, pos_Y, diameter); // Dibujo del círculo
Modifica el código utilizando un bucle for o while para que éste dibuje tantos círculos
como indique la variable top. El resultado que debes obtener debe ser similar al siguiente:
Nota 1: al igual que en el ejercicio anterior, no puedes emplear draw() para este ejercicio.
Nota 2: verás que a la instrucción fill() le hemos puesto 4 valores. El cuarto valor es la
opacidad (cómo de transparente es el relleno indicado sobre 255, en este caso al 50%).
4
Ejercicio 3: Círculos aleatorios de colores 2 (1.5
puntos)
Ahora repite el ejercicio 2, pero utilizando las funciones setup() y draw(). Para ello copia el
código del programa anterior, declara arriba de todo las variables, introduce la instrucción
size() dentro de setup() y el resto del código dentro de draw(), y ejecuta el código
(importante: la instrucción background debe ser la primera instrucción dentro de
draw(), y debe estar fuera del bucle que dibuja los círculos). Verás que tu programa, a
pesar de seguir siendo el mismo, ha cambiado su comportamiento de forma muy
evidente.
Explica, añadiendo un comentario en el ejercicio, qué pasa y por qué. Puesto que
estamos en la PEC de estructuras iterativas, tu enfoque debe dar una respuesta a lo que
está sucediendo desde la perspectiva de los bucles. Quizás te ayuda pensar en la
expresión bucle anidado.
Ahora que ya has probado los bucles while y los bucles for, y sabiendo que muchas veces
se pueden utilizar los dos, añade otro comentario al ejercicio y explica, bajo tu criterio,
cuándo crees que puede ser más útil un bucle while y cuándo un bucle for.
Ejercicio 4: Tiles (azulejos) (1.75 puntos)
A continuación se te muestra un código (por practicidad también lo tienes en formato .pde
adjunto a este enunciado) que dibuja una columna de cuadrados azules a la izquierda del
lienzo.
// Variable con el lado de los cuadrados
int square_side = 20;
int cell_side = 30;
void setup() {
size(780, 600); // Tamaño del lienzo
background(255); // Fondo blanco
rectMode(CENTER); // Vamos a situar los cuadrados respecto a su centro, no respecto a su esquina
superior izquierda
}
void draw() {
// Número total de filas y columnas
int columns = 780/30;
int rows = 600/30;
// Relleno de color azul para los cuadrados
fill(0, 0, 255);
5
for (int i = 0; i < rows; i++) { // Filas
// Aquí es donde tendrás que añadir tú el resto de columnas
square(15, i*30+15, 20);
}
}
Si ejecutas el código tal cual está, deberías ver lo siguiente:
Si te fijas, primero tienes una variable donde definimos el lado de los cuadrados
(square_side) que queremos dibujar, así como una variable con la anchura de las celdas
en las que vamos a dividir todo el lienzo (cell_side). Ten en cuenta que los cuadrados van
a ir dentro de las celdas, con lo que las celdas son ligeramente más grandes que los
cuadrados (o azulejos).
A continuación, aparte del setup() que ya conoces, tienes el cálculo de dos variables, que
son la cantidad de filas y columnas en las que vamos a dividir el lienzo. Luego tenemos el
relleno de los azulejos, y finalmente un bucle for que dibuja una columna de azulejos, ya
que sabemos cuántas filas caben. Observa que para dibujar los azulejos se utilizan las
variables “i” y “rows” para que todo se haga automáticamente.
Modifica el programa para conseguir dos cosas:
● La primera, cambia todos los valores numéricos que puedas por sus variables
correspondientes (en realidad no te hará falta declarar ninguna nueva variable, sino
simplemente sustituir los valores numéricos que puedas por las variables que ya
tienes declaradas. Ojo, porque hay muchos más valores por sustituir de los que
puedas imaginar a simple vista).
● La segunda, que todo el lienzo se llene de azulejos, de forma que la imagen final
sea la siguiente (PISTA: Tendrás que hacer dos bucles anidados, es decir, uno
dentro del otro. Para el bucle que falta, puedes partir de la base del primero
adaptando las variables que necesites):
6
Nota 1: al mirar la imagen anterior, es posible que veas que, entre las esquinas de los
azulejos azules, hay pequeños azulejos de color azul claro o gris. Esto no es más que una
ilusión óptica de tu cerebro, así que no te dejes engañar por ellos: no existen, con lo que
no has de conseguirlos.
Criterios de corrección:
A la hora de corregir esta PAC se tendrán en cuenta los siguientes aspectos:
● El peso de cada programa está en el propio enunciado.
● Funcionalidad del programa. El código fuente debe poder ejecutarse
adecuadamente, y producir la funcionalidad solicitada en el ejercicio.
● Idoneidad del código fuente. Se valorará haber programado un código fuente
eficiente, sin haber recurrido a atajos.
● Estructura, claridad y comentarios del código. El código de programación deberá
estar adecuadamente estructurado, así como comentado para esclarecer su
contenido.
● Uso adecuado de las variables, condicionales y estructuras de repetición.
7