Computación I

Clase del Lunes 8 de Marzo

Presentación del curso

Objetivos de la clase: presentar el curso a los alumnos.

Temas:

Objetivos del curso.
Temario.
Metodología.
Reglas del juego.
Conceptos básicos.

Esta es la clase que yo voy a hacer. Los demás profesores pueden presentar el curso de la forma que ellos estimen conveniente.

Objetivos del Curso

La idea es deducir cuáles son los objetivos del curso a través del siguiente mapa conceptual.

Cuando el alumno se convierta en un profesional, se le pedirá que resuelva problemas computacionalmente. Como profesional tendrá que elaborar soluciones para esos problemas.

Por lo tanto los objetivos del curso son:

Resolver problemas con la ayuda del computador. (Lo que implica que la principal actividad del curso será la programación de computadoras).
Desarrollar el razonamiento algorítmico.
Adquirir una visión general de las áreas temáticas de la disciplina de Computación:
- Algoritmos y estructuras de datos.
- Lenguajes de programación.
- Ingeniería de software.
- Comunicación humano-computador.

Se finaliza con el siguiente mapa conceptual:

Temario

(No necesariamente en el orden en que se verán las materias.)

Programación en el lenguaje Java:

Tipos de datos numéricos.
Representación de datos en el computador.
Estructuras de control.
Strings.
Arreglos.
Objetos.
Records.
Subprogramas.
Archivos.
Clases y subclases.

Algortimos:

Análisis de algoritmos.
Búsqueda.
Ordenamiento.
Estructuras de datos.

Otras áreas:

Procesamiento masivo de datos.
Computación científica y métodos numéricos.
Computación gráfica.
Interfaces humano-computador.

Metodología

Durante el curso se enseñará a resolver problemas computacionales mediante la programación en el lenguaje Java. Muchos de los problemas deberán ser programados en el computador. Para ello, la escuela ofrece unos 100 PCs (Pentium 166, 32 MB, 1GB HD, Windows'NT), pero se incentivará el uso de los PCs que los alumnos tengan en casa.

Durante la próxima semana se organizarán talleres de adiestramiento en el uso del computador.

¿Por qué Java?

Porque tiene amplia difusión y promete convertirse en los próximos años en el lenguaje de programación más usado.
Porque entre los lenguajes con amplia difusión es el que mejor permite enseñar los conceptos del curso (Visual Basic no lo permite).

¿Como estudiar eficientemente?

Ir a clases a aprender, no a escuchar.
Escribir los programas del pizarrón en el cuaderno, aún cuando las soluciones se encuentren en los apuntes o en el Web. Un programa que se lee y no se escribe, es un programa que no se ha comprendido.
Estudiar en grupos de no más de 3 o 4 alumnos. Evitar transformar el estudio en reunión social.
No quedarse con dudas acerca de la materia entre clase y clase. Preguntarle a los compañeros cuando no se entiende algo. Si los compañeros tampoco entienden, preguntarle al profesor.
Resolver las guías de estudio que se publicarán en el Web en el momento oportuno.
Hacer las tareas y proyectos. Discutir cómo resolver las tareas con otros compañeros. Escribir los programas personalmente. Cualquier trozo de código copiado literalmente del trabajo de otro alumno, es copia (obviamente, sí se pueden copiar trozos del cuaderno de cátedra o auxiliar).
Resolver problemas adicionales a las tareas antes de los controles (por ejemplo controles de años anteriores). Resolverlos hasta el final, no solo un bosquejo de solución. No empantanarse demasiado tiempo si no se encuentra la solución. Preguntarle a los compañeros cómo se resuelve. Resolver este tipo de problemas hasta ser capaces de resolver nuevos problemas sin ayuda de terceros.
Evitar a toda costa que los pille la máquina, lo que se puede lograr siguiendo las indicaciones anteriores. Una vez que los pilla la máquina es imposible seguir estas indicaciones.

Seguir estas indicaciones no significa dedicar más tiempo al estudio, si no que aprovechar mejor el tiempo dedicado al estudio.

Reglas del juego

Evaluación:

5 controles evaluados con nota entre 1 y 7.
2 controles recuperativos para reemplazar notas de controles. El primer recuperativo reemplaza la peor nota de los dos primeros controles. Cualquiera puede rendir este control. El segundo reemplaza la peor nota de los 3 últimos controles, pero sólo lo pueden rendir alumnos que justifiquen su inasistencia a alguno de los controles.
Un examen. El alumno puede rendir un examen de segunda fecha si la nota que obtuvo en el primer examen no le satisface (usualmente sólo los que reprueban). En este caso, el segundo examen reemplaza el primero.
Varias tareas (algunas de coeficiente doble).

Para aprobar el curso se requiere:

Examen >= 3.0
Promedio de controles * 0.7 + Examen *0.3 >= 4.0
Nota de tareas >= 4.0

Más detalles acerca de las reglas de evaluación se encuentran en el documento Guía del Estudiante distribuido por la Escuela a todos los alumnos (capítulo 1, la docencia de pregrado). Los alumnos deben preservar esta copia hasta fines de año en donde se hace más necesaria.

Observación: el grueso de los alumnos aprueba con nota entre 4 a 5 (más cerca de 4 que de 5) y por lo tanto la mayoría debe estar preocupado de estas reglas. Esto ocurre porque la mayoría de los alumnos no respeta las indicaciones acerca de como estudiar eficientemente.

Bibliografía

Apuntes del curso publicados en el Web en http://www.dcc.uchile.cl/~lmateu/CC10A por Luis Mateu. Estas páginas estarán siendo permanentemente corregidas y enriquecidas con nuevo material.
Apuntes de Java por Kurt Schwarze: Este documento se encuentra en preparación y se publicará por etapas en la biblioteca central de la facultad.
Java Developer's Resource por Elliote Rusty Harold. Este libro está disponible en la biblioteca central con el código 005.133JAV H23. Sólo se menciona como material de apoyo de las cátedras y los documentos previos. No es recomendable como medio para aprender a programar. Sí es un buen libro para aprender más sobre el lenguaje Java.

Conceptos Básicos

En este punto Juan Alvarez propone que los alumnos mencionan términos computacionales y clasificarlos en distintas casillas como:

Lenguaje de programación.
Sistema Operativo.
Aplicaciones y utilitarios.
Arquitectura de Procesador.
Hardware.

La idea es que se entregue una primera explicación para algunos términos muy empleados en Computación como:

Lenguajes: Pascal, Turing, Java, Visual Basic.
Sistemas Operativos: Windows'95, Windows'NT, Unix.
Aplicaciones y utilitarios: Office, Netscape, Explorador de Archivos, ventana de comandos de DOS.
Arquitecturas de Procesadores: PCs x86, Macintosh.
Hardware: memoria, byte, procesador, CPU, consola, terminal, pantalla, teclado, mouse, disco duro, diskettera, diskette.

Computación I Miércoles 10 de Marzo

Introducción a la programación

Objetivos: Mostrar a los alumnos un primer programa.

Temas:

Definiciones previas.
Jalisco.
Ejercicio.

Definiciones previas

Computador: Aparato electrónico que es capaz de ejecutar instrucciones en forma precisa y a altísimas velocidades. Cada instrucción que ejecuta el computador corresponde a una operación simple como: una suma, una multiplicación, una comparación de un número con otro, etc.
Programa: Secuencia de instrucciones que especifica en forma precisa la manera de realizar una operación no trivial. El programa debe estar escrito en un lenguaje entendible por el computador.
Lenguajes de programación: lenguaje preciso y no ambiguo que permite escribir programas (para computadoras). El computador es capaz de entender un lenguaje de programación, pero no un lenguaje hablado como el castellano o el inglés. Ejemplos de lenguajes de programación son Java, Visual Basic, Pascal, otros.
Programador: la persona que escribe un programa.
Usuario: la persona que usa un programa.

Jalisco

El programa que nunca pierde.

Este programa realiza un diálogo muy corto con el usuario.

           Por favor ingresa un número: 123
           Lo siento, te gano con el 124

Las etapas que debe realizar el computador para realizar este diálogo son:

Escribir en la pantalla la frase "Por favor ingresa un número: ".
Obtener (recuperar, leer) el número que ingresa el usuario.
Escribir una línea en la pantalla con la frase:
- "Lo siento, te gano con el "
- el número ingresado por el usuario más uno

Las instrucciones anteriores corresponden al algoritmo de Jalisco. Pero no constituyen un programa porque el computador no es capaz de entenderlo y ejecurlo. Un algoritmo es un conjunto de instrucciones para llevar a cabo alguna actividad, pero no necesariamente escrito en un lenguaje entendible por un computador.

El siguiente es un el programa Jalisco escrito en el lenguaje Java:

Explicaciones:

Comentario: cualquier texto que vaya antecedido de // es ignorado por el computador hasta el final la línea en donde aparece. El programador coloca estos comentarios para explicarle a otros programadores lo que está haciendo el programa. Facilitan la compresión de los programas.
Jalisco: es el nombre del programa.
print("___");
Es una instrucción que ordena al computador ejecutar la operación print. Esta operación despliega en pantalla los caracteres encerrados entre ".
Para ejecutar (invocar, llamar) una operación, se indica su nombre (ej. print) y en seguida los argumentos de la invocación entre paréntesis.
int n;
Instrucción de declaración de una variable. Una variable:
- Almacena un valor (por ejemplo un número).
- Tiene un nombre o identificador (letra seguida de otras letras o dígitos). Por ejemplo: n, total, y2000, etc.
- Puede contener un solo valor en un instante dado.
- Posee un tipo que indica el conjunto de valores que puede almacenar. Por ejemplo las variables int sólo pueden almacenar enteros.
- Representa una ubicación o celda en la memoria del computador.
n= readInt();
Instrucción de asignación. Se usa para modificar el valor de una variable (modificar su contenido o asignarle un nuevo valor).
En la variable n (lado izquierdo de =) se almacena el resultado de la expresión que aparece a la derecha de = (readInt()). El computador calcula este resultado ejecutado la operación (el método) readInt().
La operación readInt() lee del teclado un número entero, que se convierte en el resultado de la operación. Por ejemplo, cuando el usuario ingresa las teclas 1, 2, 3 y enter (ingresar), el resultado de la operación es el entero 123. La operación readInt no recibe argumentos (pero de todas formas se colocan los ()'s).
print(n+1);
Ordena desplegar el resultado de la expresión n+1 en pantalla. El resultado se calcula como la suma del valor contenido en la variable n y 1.
Todo el resto de lo programa (no contenido en una caja gris) será explicado más adelante en el curso. Por el momento, esto se copiará literalmente en cada programa que escriba.

Ejercicios Propuestos

Haga un programa que calcule el perímetro y el área de un círculo a partir de su radio. El diálogo entre el programa y el usuario debe ser el siguiente:
```
     Ingrese el radio: 4
     El perímetro es ...
     El área es ...
```
El valor ingresado por el usuario está en negritas. Todo el resto ha sido desplegado por el programa.
(Obs. a los profesores: en clases me sale más fácil subrayar. No puedo subrayar en Netscape, porque el subrayado no sale impreso.)
Diseñe el diálogo que debe establecer un programa con el usuario para calcular el puntaje de un alumno en la PAA de Matemáticas, dados el total de respuestas correctas e incorrectas. Escriba el programa.
Invente un problema, diseñe el diálogo y escriba el programa.

Computación I Lunes 15 de Marzo

Conceptos básicos

Objetivos: Que los alumnos sean capaces de escribir expresiones aritméticas enteras o reales y que puedan declarar variables.

Temas:

Expresiones aritméticas.
Tipo de una expresión.
Cálculo de porcentajes en un plebiscito.
Declaración de variables.
El operador %.

Expresiones aritméticas

Una expresión aritmética se escribe realizando operaciones aritméticas entre variables y constantes numéricas. Por ejemplo:

    2*PI*radio
    (dist1+dist2)/difTiempo
    5
    3.14159

(Obs. a los profesores: PI es una constante de la clase Program).

Los operadores más usados son:

+
-
* para la multiplicación
/ para la división

Obs. 1: Las expresiones se escriben en una sola línea.

Obs. 2: Existe una parentización implícita como en el álgebra matemática:

a+b*c es lo mismo que a+(b*c)
Los operadores * y / tienen prioridad sobre + y -.
a-b-c es lo mismo que (a-b)-c
Entre operadores de la misma prioridad (como + - o * /) las expresiones se asocian de izquierda a derecha.

Parentice explícitamente cuando la parentización implícita no es la adecuada o cuando tenga dudas:

    a-(b-c);

Tipo de una expresión

Una expresión puede ser entera (int en Java) o real (double). Por ejemplo, las siguientes son expresiones enteras:

   5
   5 + 2 * 20   // expresión compuesta
   5/2
   -2

Estas otras son reales:

   3.14
   3.14 * 8.5 / 2.0
   5.                 // 5.0
   1. + 1             // 2.0

Esto se puede resumir en:

Cualquier constante numérica que contenga un . es real. Si no tiene el . es entera.
Cuando a ambos lados de un operador hay subexpresiones enteras, el resultado de esa operación es entero.
Si una de las subexpresiones es real, el resultado es real.

Ejemplo:

    (4 - 1) * 5. / (5 / 2)
     |   |    |     |   |
    int int double int int
      \ /    /      \  /
      int   /        int
       \   /          /
       double        /
           \        /
            \      /
             \    /
             double


Propuesto: ¿Cuanto valen 1/2*2.0 y 2.0*1/2?



Ejercicio: Cálculo de porcentajes en un plebiscito


Se requiere un programa que establezca el siguiente diálogo:


    Votos SI ? 80
    Votos NO ? 120
    Total de votos= 200
    SI= 40.0 %
    NO= 60.0 %


(8 minutos para que los alumnos traten de hacerlo.)

Programa:

    println("Calculo de porcentajes de un plebiscito");
    print("Votos SI ? ");
    int si= readInt();
    print("Votos NO ? ");
    int no= readInt();
    print("Total de votos= "); println(si+no);
    print("SI= "); print(100.0*si/(si+no)); println(" %");
    print("NO= "); print(100.0*no/(si+no)); println(" %");


Observaciones:



Hay que agregar:

    class Plebiscito extends Program {
      void run() {
        El programa
      }
    }


En los ejercicios futuros nos ahorraremos esta parte que
es siempre igual.

println escribe en la consola y luego cambia de línea. print
no cambia de línea.

Se puede colocar más de una instrucción en una línea.

También se puede escribir:

    println("Total de votos= "+ (si+no));






Declaración de variables


Cuando una expresión se repite una y otra vez, su valor se
puede almacenar en una variable.  Por ejemplo:


    int total= si+no;
    println(100.0*si/total);
    println(100.0*no/total);


La primera instrucción es una declaración.  Introduce la variable
total.  Una declaración tiene la sintaxis:

`tipo' `identificador' = `expresión' ;

En donde `identificador' es el nombre de la variable y `expresión'
es el valor inicial que se le da a esa variable.


El `tipo' puede ser int o double.  Si es int, la variable sólo puede
almacenar un valor entero.  Si es double, solo puede almacenar un real
(Ej. 2.5, -1.2, 1.0).  Ejemplo:


  double perimetro= 2*PI*radio;


(Obs. a los profesores: por simplicidad no introduzcan el tipo float.
Hace que en muchos caso se necesite los horrendos casts.  En todo
caso, con double se puede hacer todo y mejor.)



El operador %


Calcula el residuo de la división entre enteros.  Por ejemplo:




7/3 es 2
7%3 es 1
8%3 es 2



En general se tiene la siguiente igualdad:

i % j <=> i - i/j*j <=> i - (i/j)*j

Tarea:




Haga un programa (con diálogo) que calcule el porcentaje de votos
de 3 candidatos a una elección.

Haga un programa que sume dos instantes de tiempo (en horas y
minutos).  El diálogo debe ser:

   Hora ? 8
   Minutos ? 35
   Hora ? 1
   Minutos ? 30
   Suma= 10 hrs. 5 min.










Computación I



Miércoles 17 de Marzo



Funciones y ejecución condicional



Objetivos: Introducir las funciones predefinidas y la instrucción if.

Temas:




Suma de horas con minutos.
Funciones predefinidas.
Ejecución condicional de instrucciones.
Agrupación de instrucciones.





Suma de horas con minutos


(ver enunciado en clase anterior.)


Obtener datos:


    print("Hora ? ");
    int horas1= readInt();
    print("Minutos ? ");
    int minutos1= readInt();
    print("Hora ? ");
    int horas2= readInt();
    print("Minutos ? ");
    int minutos2= readInt();


Sumar los tiempos: Alternativa 1

    // Sumar hora y minutos por separado
    int horas= horas1+horas2;
    int minutos= minutos1+minutos2;
    // Si minutos >= 60, pasarlos a las horas.
    print("Suma= "); print(horas+minutos/60);
    print(" hrs. "); print(minutos%60); print(" min.");


Sumar los tiempos: Alternativa 2

    // Sumar en minutos
    int minutos= horas1*60+minutos1 + horas2*60+minutos2;
    print("Suma= "); print(minutos/60); print(" hrs. ");
    print(minutos%60); print(" min. ");


Propuesto: Modificar el programa para que sea capaz de sumar horas,
minutos y segundos.



Funciones predefinidas


En el lenguaje Java se pueden calcular las funciones matemáticas
típicas que vienen en una calculadora.  Por ejemplo para calcular
el lado de un cuadrado a partir de su área se puede usar la función
que calcula la raíz cuadrada:


    double lado= sqrt(area);


En esta instrucción, sqrt(area) es una llamada a una
función.  Una llamada a función es una forma de expresión aritmética.
Su sintaxis general es:

``función''( ``argumentos'')

En donde ``argumentos'' son una o más expresiones separadas
por coma.  Una llamada a una función se puede colocar en cualquier parte
en donde sea válido colocar una expresión.


Una función puede ser por ejemplo:


(Obs. a los profesores: vean sólo algunas de estas funciones.  La
idea es mostrar la sintaxis.)




 Función  Significado  Ejemplo  Valor

 sqrt(x)  raíz cuadrada  sqrt(4.0)  2.0
 abs(x)  valor absoluto  abs(-3.0)  3.0
 pow(x,y)  x elevado a y  pow(2.0, 3.0)  8.0
 exp(x)  e a la x  exp(1.0)  2.71...
 log(x)  logaritmo natural  log(E)  1.0




O puede ser una función trigonométrica:




 Función  Significado
     Ejemplo  Valor

 sin(x)  seno  sin(PI/2)  1.0
 cos(x)  coseno  sin(PI)  -1.0
 tan(x)  tangente  tan(PI/4)  1.0
 asin(x)  arco seno  asin(1.0)  PI/2
 acos(x)  arco coseno  asin(-1.0)  PI
 atan(x)  arco tangente  atan(1.0)  PI/4




O puede ser una función de conversión:




 Función  Significado  Ejemplo  Valor

 round(x)  redondea  round(1.5)  2.0
                     round(1.4)  1.0
 floor(x)  piso  floor(3.9)  3.0
                 floor(-5.2)  -6.0
 ceil(x)   techo  ceil(3.9)  4.0
                  ceil(-5.2)  -5.0




O puede ser una función para calcular el máximo o mínimo:




 Función  Significado  Ejemplo  Valor

 max(x)  máximo  max(3.5, 5.2)  5.2
 min(x)  mínimo  min(3.5, 5.2)  3.5




Todas las funciones anteriores operan con números reales (double).
La siguiente función toma un número real y devuelve un entero:




 Función  Significado  Ejemplo  Valor

 trunc(x)  convierte  trunc(3.9)  3
           a entero   trunc(-5.2)  -5




Ejercicio: Calcular el máximo de 3 números.


    Primer número ? 2.1
    Segundo número ? 8.6
    Tercer número ? -2.0
    El máximo es : 8.6


Solución 1:

    // Leer datos
    print("Primer número ? ");
    double a= readDouble();
    print("Segundo número ? ");
    double b= readDouble();
    print("Tercer número ? ");
    double c= readDouble();
    // Calcular el máximo
    print("El máximo es : ");
    print(max(max(a,b),c);


Los argumentos de una llamada a una función pueden ser el resultado
de otra llamada a función.



Ejecución condicional de instrucciones


Motivación: Indicar si una ecuación de segundo grado tiene
raíces reales o complejas.


    Coeficiente a ? 1.
    Coeficiente b ? 4.
    Coeficiente c ? 7.
    La ecuación tiene raíces complejas


La idea es que si b*b >= 4*a*c, la ecuación tiene raíces reales, si no,
son complejas.  Por lo tanto, hay que desplegar mensajes distintos.
Hay que ejecutar instrucciones distintas.

    if (b*b >= 4*a*c)
      print("La ecuación tiene raíces reales");
    else
      print("La ecuación tiene raíces complejas");


Sintaxis de if:

    if (``condición'')
      ``instrucción 1''
    else
      ``instrucción 2''


Semántica de if:


Se evalúa la ``condición''.
Si resulta verdadera se ejecuta la ``instrucción 1'' y no
se ejecuta ``instrucción 2''.
Si resulta falsa se ejecuta la ``instrucción 2'' y no
se ejecuta ``instrucción 1''.


La condición sigue la siguiente sintaxis:


``expresión 1'' ``operador relacional''
``expresión 2''

En donde el operador relacional compara expresiones numéricas y puede ser:
>, <, >= (mayor o igual), <= (menor o igual), == (igual) o
!= (distinto).


Ejercicio: desplegar el máximo entre a y b sin usar max.


Solución incorrecta:


    if (a>b)
      print("El máximo es ");
      print(a);
    else
      print("El máximo es ");
      print(b);


¡Entre if (a>b) y el else solo puede haber una instrucción!



Agrupación de instrucciones


Se puede agrupar instrucciones usando { }:


    { print("El máximo es "); print(a); }


Encerradas entre { }, las dos instrucciones son ahora una sola instrucción
compuesta, que se puede colocar en cualquier lugar en donde sea válido
colocar una instrucción.  La forma general es:


    { ``instrucción 1'' ``instrucción 2'' ... ``instrucción n'' }


Por lo tanto, el máximo se puede escribir como:


    if (a>b) {
      print("El máximo es ");
      print(a);
    }
    else {
      print("El máximo es ");
      print(b);
    }


La cantidad de líneas que ocupe una instrucción es irrelevante.



Tarea:

Complete el programa que calcula las raíces de la ecuación de
segundo grado.  Cuando la ecuación tiene raíces reales, el diálogo
debe ser el siguiente:

Por ejemplo:


    Coef. a ? 1.
    Coef. b ? -3.
    Coef. c ? 2.
    Las raíces son 1.0 y 2.0








Computación I



Lunes 22 de Marzo



La asignación



Objetivos:

Temas:



Solución de la ecuación de 2do. grado.
La instrucción de asignación.
Declaración sin inicialización.
Ejecución condicional sin else.
Ejercicio: El programa confuso.





Solución de la ecuación de 2do. grado

    // Lectura de a, b y c (todos double)
    ...
    // Cálculo de las raíces
    double b24ac= b*b - 4*a*c;
    if (b24ac>=0) {
      print("Las raíces son ");
      print( (-b+sqrt(b24ac))/(2*a) );
      print( (-b-sqrt(b24ac))/(2*a) );
    } 
    else
      println("La ecuación tiene soluciones imaginarias");


Obs.: también se puede escribir:

      print( (-b+sqrt(b24ac))/2/a );


pero no:

      print( (-b+sqrt(b24ac))/2*a ); // Malo
      print( -b+sqrt(b24ac)/2/a );   // Malo




La instrucción de asignación


Motivación: desplegar el máximo entre a, b y c, sin usar max.


    print("El máximo es ");
    if (a>b)
      if (a>c)
        print(a);
      else
        print(c);
    else
      if (b>c)
        print(b);
      else
        print(c);


No es necesario colocar las { }, porque un if es una instrucción compuesta
(que se construye a partir de una o más instrucciones).

Problema: El programa que entrega el máximo de 4 o 5 números, podría
ser demasiado grande.


La asignación


Una variable se llama así porque se puede cambiar su valor,
de la misma forma que se puede cambiar el valor de una memoria
en una calculadora.  Por ejemplo:


    double x= 2*radio;
    println(x);
    x= radio*radio;
    println(x);


Cuando el valor de radio es 4.0, este programa despliega:

    8.0
    16.0


En el programa se usa una sola variable x.  La variable toma dos
valores distintos durante la ejecución del programa (primero 8. y
luego 16.).

Sintaxis de la asignación:


``variable'' = ``expresión'';

Se diferencia de una declaración en que ``variable'' ha sido
declarada previamente y en que no se indica nuevamente su tipo.


Semántica:


Primero se evalúa la ``expresión'', y luego, su resultado
se asigna a ``variable'', es decir se almacena en
la variable.


Obs.: no se puede declarar dos veces la misma variable:


    double x= 2*radio;
    double x= radio*radio; // ¡error!




Declaración sin inicialización

Al declarar una variable no es necesario darle un valor inicial.
El programa anterior se puede reescribir como:

    double x;
    x= 2*radio;
    println(x);
    ...


Obs.: en general no se puede usar una variable a la cual no se le
ha dado todavía un valor.

Ejercicio: calcular el máximo entre a y b y dejarlo en max, sin
usar la función max(..)


    // Las variables a y b han sido declaradas previamente
    int max;
    if (a>b)
      max= a;
    else
      max= b;
    println(max);


Al desplegar max, es seguro que tiene algún valor.

Obs.: el siguiente programa es inválido porque se declara dos
veces la variable max:


    if (a>b)
      int max= a;
    else
      int max= b;
    println(max);




Ejecución condicional sin else

En ocasiones, no hay nada que poner en la parte else.  Entonces
se puede suprimir.  El problema anterior se puede reescribir como:

    int max= b;
    if (a>max)
      max= a;
    println(max);


(Si lo que sobra es la parte verdadera, se da vuelta la condición.)

Ejercicio: calcular el máximo entre a, b y c.


    int max= a;
    if (b>max)
      max= b;
    if (c>max)
      max= c;
    println(max);


Propuesto: el máximo entre a, b, c, d y e.



Ejercicio: El programa confuso
(en clases)

Indique qué despliega el siguiente programa:


    int a = 4;
    int b = 10;
    int d = 7;

    d = b - 2;              println(d);
    a = d - (3 + b);        println(a);
    b = 1 + a*2-1;          println(b);
    a = d - b;              println(a);
    d= b - a;               println(d);
    int e = a+(d-b);        println(e);








Computación I



Miércoles 24 de Marzo



Más sobre ejecución condicional



Objetivos: Profundizar sobre la instrucción if e introducir
más ejemplos.

Temas:




Condición compuesta.
Diagramas de flujo.
Selección múltiple.






Condición compuesta

Determinar si una variable es positiva y menor que 10:

    if (a>=0. && a<10.0)
      println("en el rango [0,10[");


El símbolo && significa ``y-lógico''.  Se pueden combinar varias
condiciones utilizando operadores lógicos:



&& : y-lógico.
|| : o-lógico.



Ejemplos de condiciones compuestas que se pueden colocar en un if:

    a==0 || b==0 || c==0
    a!=0 && (b>0 || c==-1)




Diagramas de flujo de programas

El orden en que se ejecutan las instrucciones de un programa
se puede graficar mediante diagramas de flujo.  La siguiente
figura muestra al lado izquierdo cómo se dibujan las instrucciones que
se colocan en secuencia.  Al lado derecho muestra la ejecución
condicional mediante el if.



Por ejemplo, el programa que resuelve la ecuación de segundo
grado (de la clase pasada) puede graficarse como:






Ejercicio:


Se desea indicar si el valor de una variable entera x es positivo,
negativo o cero:


    if (x>0)
      println("positivo);
    else
      if (x<0)
        println("negativo");
      else
        println("cero");


Este programa tiene por diagrama:



Observe que el siguiente programa no entrega el resultado correcto:


    if (x>0)
      println("positivo);
    if (x<0)
      println("negativo");
    else
      println("cero");


El diagrama de este otro programa es completamente distinto,
ya que los dos if están puestos en secuencia:



Siga la ejecución de ambos programas cuando x vale 1 y cuando
x vale -2.




Selección múltiple

Aprovechando que los cambios de línea y espacios no alteran el
funcionamiento del programa, la versión correcta del ejercicio
anterior se puede reescribir como:

    if (x>0)
      println("positivo);
    else if (x<0)
      println("negativo");
    else
      println("cero");


Este formato se prefiere cuando hay selecciones múltiples.  En general
se escribe:

    if (``condición 1'')
      ``instrucción 1''
    else if (``condición 2'')
      ``instrucción 2''
    ...
    else if (``condición n-1'')
      ``instrucción n-1''
    else
      ``instrucción n''


Lo que se dibuja como:





Ejercicio: calificación una nota

Se desea calificar en palabras una nota, según el siguiente criterio:


1.0 a 3.9: reprobado.
4.0 a 4.9: aprobado.
5.0 a 5.9: aprobado con distinción.
6.0 a 7.0: aprobado con distinción máxima.


El siguiente programa entrega la calificación de una nota n:

    if (6.0<=n && n<=7.0)
      println("aprobado con distinción máxima");
    if (5.0<=n && n<=5.9)
      println("aprobado con distinción");
    if (4.0<=n && n<=4.9)
      println("aprobado");
    if (1.0<=n && n<=3.9)
      println("reprobado");


Indique qué despliega el siguiente programa cuando n es 5.5:

    if (n >= 6.0)
      println("__________");
    if (n >= 5.0)
      println("__________");
    if (n >= 4.0)
      println("__________");
    if (n >= 1.0)
      println("__________");


Complete el siguiente programa, de modo que califique correctamente
una nota:

    if (n ? ___)
      println("__________");
    else if (n ? ___)
      println("__________");
    else if (n ? ___)
      println("__________");
    else if (n ? ___)
      println("__________");




Tareas:



Haga un programa que determine si un año es bisiesto: si es divisible
por 4, pero no es divisible por 100 o si es divisible por 400:

    Año ? 1998       Año ? 1996
    no               si

    Año ? 1900       Año ? 2000
    no               si


Suma de fracciones.

Para sumar números racionales se usa la siguiente fórmula:

     a   c     ad + bd
     - + -  =  -------
     b   d       bd


Haga un programa que dialogue para obtener a, b, c y d, y luego calcule
la suma de las fracciones a/b y c/d.  Si la división no se puede realizar
porque el denominador es cero, despliega un mensaje que lo señale.  Si el
resultado es entero, despliega el valor entero.  Si el resultado es una
fracción, despliega la fracción (sin simplificarla).









Computación I



Lunes 29 de Marzo



Ciclos



Objetivos: Introducir la noción de repetición de instrucciones.

Temas:




Instrucción de repetición.
Ejecución paso a paso.





Ejercicio 1: ¿Qué despliega el siguiente programa?


    int x= 5;
    x= x+1;
    println(x);


Solución del ejercicio: el programa despliega 6.  Primero se evalúa
x+1, que es 5+1, es decir 6.  Luego se almacena el resultado 6 en
la variable x.

Moralejas:




Al evaluar el lado derecho de una asignación, las apariciones
de la misma variable que se está asignando deben ser reemplazadas
por el valor anterior de la variable.

El símbolo = no significa igualdad (aquí claramente x es distinto
de x+1), significa asignar un nuevo valor (almacenar un nuevo valor).
Es por esto que en otros lenguajes se opta por usar := para la
asignación (como en Pascal).





Ejercicio 2: hacer un programa que sume 3 valores ingresados por
el usuario.


Diálogo:


    ? 3
    Total= 3
    ? 10
    Total= 13
    ? 1
    Total= 14


Solución:

    int suma= 0;
    int num;
    print("? ");
    num= readInt(); suma= suma+num;
    print("Total= "); println(suma);
    print("? ");
    num= readInt(); suma= suma+num;
    print("Total= "); println(suma);
    print("? ");
    num= readInt(); suma= suma+num;
    print("Total= "); println(suma);


Es fácil modificar este programa para que ahora sume 20 números,
repitiendo las 3 últimas líneas tantas veces como sea necesario.
¿Pero qué pasa si se desconoce la cantidad de valores que desea
sumar el usuario?



Instrucción de repetición

Motivación: hacer un programa que sume los valores ingresados por
el usuario hasta que ingrese un 0.

    ? 3
    Total= 3
    ? 10
    Total= 13
    ? 1
    Total= 14
    ? 100
    Total= 114
    ? 0
    Fin!


Todos los lenguajes de programación tienen mecanismos para repetir
la ejecución de grupos de instrucciones una y otra vez, sin que sea
necesario reescribir tales instrucciones.  En Java, esto se
logra con la instrucción while:

    int suma= 0;
    int num;
    print("? ");
    num= readInt();
    while (num!=0) { 
      suma= suma+num;
      print("Total= "); println(suma);
      print("? ");
      num= readInt();
    }
    println("Fin!");


La instrucción while es una instrucción de control y repite la
ejecución de una o más instrucciones una y otra vez, mientras
la condición encerrada entre () sea verdadera.

Sintaxis:



while (``condición'') { ``instrucciones'' }


Semántica:




La instrucción while se ejecuta de la siguiente manera:




Se evalúa la condición.

Si la condición es falsa, se termina la ejecución de while, y se
prosigue con la instrucción que sigue al while (en este caso
println("Fin!")).

Si la condición es verdadera, se ejecutan secuencialmente las
instrucciones.

Se re-evalúa la condición.

Si la condición es falsa, se prosigue como en 2.-

Si la condición es verdadera, se prosigue como en 3.-

etc.



Obs.:



Más adelante veremos otras instrucciones que también sirven
para ejecutar un grupo de instrucciones en forma repetida.  A
este tipo instrucciones se les llama ciclos.

Una ejecución del grupo de instrucciones se denomina iteración.
Si se ejecuta 10 veces el grupo de instrucciones, se dice que
el ciclo tuvo 10 iteraciones.

No existe un límite al número de iteraciones que se pueden llevar
a cabo en un ciclo.





Ejecución paso a paso de un programa

Consiste en ejecutar una a una las instrucciones observando los
cambios que produce en las variables del programa.  Como ejemplo,
ejecutaremos paso a paso el programa anterior.  Por conveniencia
enumeramos las instrucciones:

(1)  int suma= 0;
(2)  int num;
(3)  print("? ");
(4)  num= readInt();
(5)  while (num!=0) {
(6)    suma= suma+num;
(7)    print("Total= "); println(suma);
(8)    print("? ");
(9)    num= readInt();
(10) }
(11) println("Fin!");


Ejecución paso a paso: junto con la traza de las instrucciones
que se van ejecutando, se debe ir indicando lo que aparece en pantalla
y el contenido de las variables.

(1) suma= 0           (5) verdadera
(2)                   (6) suma= 14
(3)                   (7) y (8)
(4) num= 3            (9) num= 100
(5) verdadera         (5) verdadera
(6) suma= 3           (6) suma= 114
(7) y (8)             (7) y (8)
(9) num= 10           (9) num= 0
(5) verdadera         (5) falsa
(6) suma= 13          (10)
(7) y (8)
(9) num= 1


Obs.:



Se indica el número de línea de la instrucción que se ejecuta.

Si la instrucción es una asignación, se indica el nuevo valor
para la variable asignada.

Si la instrucción es un while o un if, se indica si la condición
es verdadera o false.



Ejercicio: ejecute paso a paso el siguiente programa.

(1) int x= 15;
(2) int y= 24;
(3) while (x!=y) {
(4)   if (x>y)
(5)     x= x-y;
(6)   else
(7)     y= y-x;
(8) }
(9) println(x);


El diagrama de flujo es:



Solución:


(1) x= 15         (3) v
(2) y= 24         (4) f
(3) v             (7) y= 3
(4) f             (3) v
(7) y= 9          (4) v
(3) v             (5) x= 3
(4) v             (3) f
(5) x= 6          (9)




Tarea:

Ejecute paso a paso el siguiente programa:


    int n= 4;
    double f= 1.0;
    int i= 1;
    while (i<=n) {
      f= f*i;
      i= i+1;
    }
    println(f);








Computación I



Miércoles 31 de Marzo



Patrones de programación



Objetivos: Mostrar que en los programas existen patrones de instrucciones
que se repiten una y otra vez, y que son útiles para resolver
problemas típicos de codificación de los programas.

Temas:




Patrones de programación.
Patrón de acumulación.
Patrón de lectura de datos.
Patrón de recorrido de un intervalo de enteros.





Patrones de programación

Programar no significa colocar líneas al azar y ver si se obtienen
los resultados requeridos.  Tampoco significa concebir una solución
partiendo desde cero.  Siempre se reutilizan elementos de programas
conocidos.  Es así como al estudiar los programas se pueden 
observar patrones de organización de las instrucciones que se repiten
una y otra vez.  Estas instrucciones rara vez son idénticas, pero exhiben
ciertas similitudes, que denominaremos patrones de programación.

Es importante conocer estos patrones de programación porque son muy
útiles para concebir nuevos programas.  Ellos resuelven problemas
conocidos sin tener que re-inventar soluciones para esos problemas
una y otra vez.


Un ejemplo de estos patrones de programación es la acumulación.  Este
patrón se usa para realizar cálculos como la suma de varios valores
calculados en las iteraciones de un ciclo:



suma= val1 + val2 + val3 + ... + valn

producto= fac1 * fac2 * fac3 * ... * facn


La forma general de este patrón es:


    ``tipo'' ``variable'' = ``valor inicial'';
    ...
    while ( ... ) {
      ...
      ``variable'' = ``variable'' ``operador'' ``expresión'';
      ...
    }


Ejemplos:



Contar cuantos números ingresa el usuario, hasta que ingrese el 0:

    ? 4.0
    ? 5.0
    ? 6.0
    ? 0.0
    Contador= 3


Solución:

    int cont= 0;            double suma= 0.0;
    double nota; 
    print("? ");
    nota= readDouble();
    while (nota!=0.0) {
      cont= cont+1;         suma= suma + nota;
      print("? ");
      nota= readDouble();
    }
    print("Contador= ");    print("Suma= ");
    println(cont);          println(suma);


Observe la similitud de esta solución con la que calcula
la suma de las notas.

Calcular el promedio de notas:

    ? 4.0
    ? 5.0
    ? 6.0
    ? 0.0
    Promedio= 5.0


Solución: la idea es condensar ambos programas en uno solo.
El programa cuenta cuantas notas se han ingresado y suma las notas
que se han ingresado en cada iteración.

    double suma= 0;
    int cont= 0;
    double nota;
    print("? ");
    nota= readDouble();
    while (nota!=0.0) {
      suma= suma+nota;
      cont= cont+1;
      print("? ");
      nota= readDouble();
    }
    print("Promedio= ");
    println(suma/cont);


En este programa se presenta también el patrón de lectura de datos.  Su
forma general es:

    ``tipo'' ``variable'';
    ...
    ``variable''= read``tipo''();
    while ( ... ) {
      ...
      ``variable''= read``tipo''();
    }


Típicamente marcaremos el fin de los datos con un cero o -1.

Desplegar los números enteros de 1 a n:

    ? 4
    1
    2
    3
    4


Solución: nuevamente usamos el patrón de acumulación.

    print("? ");
    int n= readInt();
    int i= 1;
    while (i<=n) {
      println(i);
      i= i+1;
    }


Acá, el programa termina cuando la variable i excede en valor a n.
En realidad, estamos acá en presencia de otro patrón muy utilizado:
recorrido de un intervalo de enteros.  Su forma general es:

    int i= ``valor inicial'';
    while ( i <= ``valor final'' ) {
      ...
      i= i + 1;
    }


La variable i toma valores entre [``valor inicial'',``valor final''],
incrementándose en 1 en cada iteración.

Calcular el factorial de un número:

Definición matemática:



0! = 1

n! = (n-1)! cuando n>=1


O informalmente:



fact= 1 * 2 * 3 * ... * (n-1) * n


Solución: al programa anterior le agregamos el producto de los
valores sucesivos que toma la variable i en cada iteración.  Para
hacer el cálculo usamos el patrón acumulación con el operador *.


    print("? ");
    int n= readInt();
    double fact= 1.0;
    int i= 1;
    while (i<=n) {
      fact= fact*i;
      i= i+1;
    }
    print("El factorial es ");
    println(fact);




Ejercicio: ejecute paso a paso el programa anterior.  Suponga
que el usuario ingresa el número 3.



Ejercicio: Calcular exp(x) por medio de la siguiente aproximación.



exp(x)= 1 + x + x^2/2! + x^3/3! + ... + x^i/i! + ... + x^n/n!


El siguiente programa calcula i! al mismo tiempo que calcula x^i.


    double xi= 1.0;
    double facti= 1.0;
    int i= 1;
    while (i<=n) {
      xi= xi*x;
      facti= facti*i;
      i= i+1;
    }


Observe que en la i-ésima iteración, la variable xi es x^i
y facti es i!.

A este programa podemos agregarle una acumulación de xi/facti:


    double x= ...; // Obtener x y n
    int n= ...;
    double xi= 1.0;
    double facti= 1.0;
    double expx= 1.0;
    int i= 1;
    while (i<=n) {
      xi= xi*x;
      facti= facti*i;
      expx= expx + xi/facti;
      i= i+1;
    }


Ahora basta desplegar el resultado final con la instrucción:

    println(expx);




Tarea:


Haga un programa que lea varios números positivos (terminados con un -1)
e indique en qué rango se encontraban (exceptuando el -1).  El diálogo
debe ser:


    ? 5
    ? 3
    ? 20
    ? 10
    ? -1
    El rango es [3,20]

Función	Significado	Ejemplo	Valor
sqrt(x)	raíz cuadrada	sqrt(4.0)	2.0
abs(x)	valor absoluto	abs(-3.0)	3.0
pow(x,y)	x elevado a y	pow(2.0, 3.0)	8.0
exp(x)	e a la x	exp(1.0)	2.71...
log(x)	logaritmo natural	log(E)	1.0

Función	Significado	Ejemplo	Valor
sin(x)	seno	sin(PI/2)	1.0
cos(x)	coseno	sin(PI)	-1.0
tan(x)	tangente	tan(PI/4)	1.0
asin(x)	arco seno	asin(1.0)	PI/2
acos(x)	arco coseno	asin(-1.0)	PI
atan(x)	arco tangente	atan(1.0)	PI/4

Función	Significado	Ejemplo	Valor
round(x)	redondea	round(1.5)	2.0
		round(1.4)	1.0
floor(x)	piso	floor(3.9)	3.0
		floor(-5.2)	-6.0
ceil(x)	techo	ceil(3.9)	4.0
		ceil(-5.2)	-5.0