Ejercicios

Enlace al paquete de este capítulo.

  1. Escriba un programa que muestre cualquier polígono regular, como se ha descrito en este capítulo. Intente con los siguientes parámetros:
    1. N = 7

      [IMAGEN]: Ejercicio 1a
      Ejercicio 1a
    2. N = 10

      [IMAGEN]: Ejercicio 1b
      Ejercicio 1b
    3. N = 25

      [IMAGEN]: Ejercicio 1c
      Ejercicio 1c

    Elija valores para la resolución y el radio que convengan.

    Como una extensión al algoritmo, podemos agregar un ángulo inicial, ánguloi. Esto nos ayudará para "colocar" el primer vértice donde queramos. Consecuentemente, los demás vértices también serán colocados según el ángulo inicial. Esto implica que la figura será rotada tantos radianes desde la horizontal, que pasa por el centro geométrico del polígono al igual que el de la circunferencia. El algoritmo extendido es el siguiente:

    Polígono_Regular( N, centro, radio, ánguloi )
    1. Crear una lista de N vértices: vértices
    2. alfa ← 2π / N
    3. Bucle: i ← 1 hasta N
    4. vértices[i].x ← centro.x + radio * cos( (i-1)*alfa + ánguloi )
    5. vértices[i].y ← centro.y + radio * sen( (i-1)*alfa + ánguloi )
    6. Dibujar_Polígono( vértices, N )
    7. Terminar.
  2. Escriba un programa para dibujar una estrella. Para esto, seguimos el algoritmo para dibujar un polígono regular. Sin embargo, a la hora de dibujar el polígono, necesitamos implementar nuestra propia función que va dibujando cada línea de un vértice a otro vecino, pero saltándose cada 2,3,4,…,N/2 vértices en nuestra lista. El algoritmo es simplemente el siguiente:

    Estrella( N, centro, radio, ánguloi, salto )
    1. Crear una lista de N vértices: vértices
    2. alfa ← 2π / N
    3. Bucle: i ← 1 hasta N
    4. vértices[i].x ← centro.x + radio * cos( (i-1)*alfa + ánguloi )
    5. vértices[i].y ← centro.y + radio * sen( (i-1)*alfa + ánguloi )
    6. Dibujar_Estrella( vértices, N, salto )
    7. Terminar.

    El algoritmo de Dibujar_Estrella() se basa en manipular los índices de nuestra lista de vértices para así dibujar líneas entre un vértice y el siguiente según el valor de salto. Por lo tanto, nos basaremos en la operación del módulo o resto de una división, descrito como mod. He aquí el algoritmo:

    Dibujar_Estrella( vértices, N, salto )
    1. Bucle: i ← 0 hasta N-1
    2. j ← (i+salto) mod N
    3. Dibujar_Línea( vértices[i+1].x, vértices[i+1].y, vértices[j+1].x, vértices[j+1].y )
    4. Terminar.
    Pruebe con los siguientes valores:
    1. N = 7, salto = 2

      [IMAGEN]: Ejercicio 2a
      Ejercicio 2a
    2. N = 7, salto = 3

      [IMAGEN]: Ejercicio 2b
      Ejercicio 2b
    3. N = 10, salto = 4

      [IMAGEN]: Ejercicio 2c
      Ejercicio 2c
    4. N = 12, salto = 5

      [IMAGEN]: Ejercicio 2d
      Ejercicio 2d
    5. N = 25, salto = 5

      [IMAGEN]: Ejercicio 2e
      Ejercicio 2e
    6. N = 25, salto = 12

      [IMAGEN]: Ejercicio 2f
      Ejercicio 2f
  3. Muestre las estrellas anteriores, pero sólo los perímetros. Es decir, sin que se vean las líneas interiores de la estrella, en sí. Para esto, tenemos que calcular los vértices donde se crucen las líneas al crear la estrella. Las líneas cruzantes indican un punto común para ambas líneas. Esto implica que tenemos que resolver el siguiente sistema de ecuaciones, para averiguar las coordenadas x e y de tal punto común:
    y = (By - Ay) / (Bx - Ax) * (x - Ax) + Ay,
    y = (Dy - Cy) / (Dx - Cx) * (x - Cx) + Cy
    donde tenemos las líneas, o mejor dicho los segmentos, AB y CD.

    [IMAGEN]: Ejercicio 3 - Segmentos cortantes
    Ejercicio 3 - Segmentos cortantes

    Simplificando, obtenemos que,
    x = (m*Ax - Ay - n*Cx + Cy) / (m-n),
    y = m*(x - Ax) + Ay,

    donde,
    m = (By - Ay) / (Bx - Ax), y
    n = (Dy - Cy) / (Dx - Cx)

    [IMAGEN]: Ejercicio 3a
    Ejercicio 3a
    [IMAGEN]: Ejercicio 3b
    Ejercicio 3b
    [IMAGEN]: Ejercicio 3c
    Ejercicio 3c
    [IMAGEN]: Ejercicio 3d
    Ejercicio 3d
    [IMAGEN]: Ejercicio 3e
    Ejercicio 3e
    [IMAGEN]: Ejercicio 3f
    Ejercicio 3f

    Algunas sugerencias para la implementación son:
    1. Calcule los vértices de la estrella, como se ha explicado anteriormente, en el ejercicio #2. Luego, calcule los vértices como se ha explicado previamente, en este ejercicio. Esto implica que nuestra lista de vértices ahora será de 2*N, ya que existe el doble de vértices que en el caso anterior de la estrella. El segmento AB se basa en el vértice i y el siguiente, i+salto, mientras que el segmento CD se crea con el vértice contiguo i+1 y su anterior, i+1-salto. Por supuesto, hay que tener en cuenta que no podemos sobrepasar los valores de los índices. Esto implica que necesitamos "dar la vuelta", por lo que necesitaremos usar la operación del módulo.
    2. En el cálculo de las coordenadas del punto común (x,y), debemos asegurarnos de que m y n sean valores determinables (calculables). Si nos fijamos, cada valor se basa en una división, por lo que es posible que el denominador sea cero. Consecuentemente, m o n no podrían ser calculados. Si esto ocurre, entonces implica que uno de los segmentos es vertical: AB o CD. En este caso, sabemos el valor de x, ya que éste no varía, al ser un segmento vertical; o sea, x = Ax = Bx o x = Cx = Dx. Sabiendo esto, sólo tenemos que calcular el valor de y, a partir del sistema de ecuaciones presentado anteriormente. Se nos presenta un caso similar, si el segmento es horizontal, que ocurriría cuando m o n es cero - cuando el numerador es cero. En este caso, conoceremos el valor de y, por lo que podemos calcular fácilmente el valor de x. Hay que tener en cuenta que surge un problema cuando el denominador de tanto m o n es cero, pero no existe ningún problema si el numerador de m o n es cero, únicamente que podemos simplificar los cálculos.
  4. Cree un programa para mostrar estrellas, como se ha explicado en el ejercicio #3. Esta vez, modificaremos el radio según el valor del ángulo basado en alfa. Es decir, el radio será ahora una función dependiente de una expresión conteniendo alfa. El algoritmo será parecido al siguiente:

    4. vértices[i].x ← centro.x + radio((i-1)*alfa + ánguloi) * cos((i-1)*alfa + ánguloi) 5. vértices[i].y ← centro.y + radio((i-1)*alfa + ánguloi) * sen((i-1)*alfa + ánguloi)
    Pruebe con los siguientes valores y funciones:

    1. N = 25, salto = 11,

      Real radio( t )
      1. a ← 12
      2. b ← 30
      3. x ← a*cos( t ) + b*sen( a*t/2 )
      4. y ← a*cos( t ) - b*sen( a*t/2 )
      5. resultado ← √( (x2+y2) / ((a+b)2 + (a-b)2) )
      6. Terminar( resultado )

      [IMAGEN]: Ejercicio 4a
      Ejercicio 4a
    2. N = 12, salto = 5,

      Real radio( t )
      1. a ← 0,1
      2. b ← 1
      3. x ← 2*a*cos( t ) + b*cos( a*t )
      4. y ← 2*a*sen( t ) - b*cos( a*t )
      5. resultado ← √( (x+y) / ((2*a+b)2 + (2*a-b)2) )
      6. Terminar( resultado )

      [IMAGEN]: Ejercicio 4b
      Ejercicio 4b
  5. Basándose en la figura 17, dibuje otras dos figuras:
    1. Extendiendo la cara agregando un cuerpo con brazos y piernas, y

      [IMAGEN]: Ejercicio 5a
      Ejercicio 5a
    2. Diseñando otra cara expresando otro sentimiento, como por ejemplo: sorpresa, sueño, enfado, perplejidad, etc..

      [IMAGEN]: Ejercicio 5b
      Ejercicio 5b
  6. Usando la técnica de composición, dibuje una casa. Puede basarse en la siguiente ilustración.

    [IMAGEN]: Ejercicio 6
    Ejercicio 6
  7. Cree un programa que recoja datos de un fichero y mostrarlos en dos gráficas en forma de a) barras y b) círculo, junto con algunos resultados estadísticos, si se desea. Por ejemplo, muestre los porcentajes de cada sector del gráfico circular incluyendo una leyenda para indicar la representación de cada color. También se podría calcular e indicar visualmente el promedio, varianza, desviación estándar, etc. en la gráfica de barras.
  8. Cree un programa que permita construir un diagrama de un circuito eléctrico según los datos guardados en un fichero o indicado directamente por el usuario. Por ejemplo, el programa podría crear un circuito con dos generadores eléctricos, cuatro condensadores, tres resistencias, dos inductores, y un interruptor. La complejidad del programa es responsabilidad del programador; se puede crear un programa altamente adaptable a cada tipo de circuito o un programa muy simple que agrega un componente detrás de otro, secuencialmente.

    [IMAGEN]: Ejercicio 8
    Ejercicio 8
    Como una sugerencia, cree funciones para poder dibujar cada componente de forma general. El programa principal invocará cada función para dibujar el componente eléctrico según los datos que describen el circuito. La descripción del circuito puede ser simple, como una cadena de caracteres. Por ejemplo, "GRRCCILGLCCR", donde G indica un generador, R es una resistencia, C es condensador, I es interruptor, y L es inductor.
  9. Diseñe un campo de fútbol. Se puede basar en el siguiente diagrama.

    [IMAGEN]: Ejercicio 9
    Ejercicio 9
  10. Diseñe una figura usando curvas de Bézier. No es necesario que el dibujo se base exclusivamente en curvas de Bézier. Por ejemplo, intente diseñar un logotipo propio o quizá copiarse de uno existente. Otro ejemplo puede ser recrear una letra del abecedario usando estas curvas. Se aconseja hacer uso del applet de Java presentado anteriormente en este capítulo para diseñar curvas de Bézier.

    [IMAGEN]: Ejercicio 10
    Ejercicio 10