Asignaciones introductorias de Ciencias de la Computación

Question

Estaré impartiendo mi primer curso de informática de nivel universitario este verano, y actualmente estoy trabajando en crear ideas para tareas divertidas que los alumnos completarán. El curso es el segundo en el programa, que abarca el análisis de algoritmos y estructuras de datos básicos, como pilas, colas, listas, árboles, etc.

Tengo una serie de ideas con las que puedo correr (crear música con cadenas de Markov , Cliente de Twitter, etc.), pero siempre estoy buscando nuevas ideas que sean interesantes/divertidas para los estudiantes; después de todo, es más fácil convertirse/seguir participando en el material del curso cuando uno se está divirtiendo. Estoy buscando ideas sobre asignaciones interesantes de primer nivel que usted u otros puedan haber completado en el pasado.

Antes de que nadie lo sugiera, sí sé sobre las asignaciones de Nifty, y lo he comprobado. Solo solicitando cualquier otra idea que pueda tener. Todos recordamos ciertas asignaciones de la universidad que fueron particularmente divertidas para trabajar. Estas son las experiencias que idealmente estoy buscando.

Answer 1

SICP tiene algunas asignaciones muy agradables.

Answer 2

El problema con las asignaciones "divertidas" es que a menudo resultan ser más trabajo para los estudiantes de lo que usted pensaba. Especialmente estudiantes con inglés pobre y estudiantes que dejan las tareas hasta el último minuto. [Y luego aparece el SO con las preguntas "por favor haz mi tarea".] Muchos de ellos tendrán dificultades con cualquier tarea que establezcas, pero no necesitas el agravamiento de un grupo de estudiantes quejándose de que los ejercicios son demasiado difícil, o no está cubierto en sus notas de la conferencia.

Mi consejo (por experiencia) es tratar de mantener bajos los conocimientos básicos y el "desafío" de las asignaciones de programación marcadas.

Establecer problemas interesantes para ejercicios opcionales es una idea razonable, aunque es importante advertir a los estudiantes que NO pasen tiempo con ellos a expensas de otro trabajo más importante.

Answer 3

He estado usando las siguientes páginas como una inspiración:

• Nifty Assignments
• Creative Programming Assignments - hay varias (sub) secciones (Introducción a CS, introducción a la programación

Usted. también puede usar las tareas de los concursos (example), pero es probable que esto requiera un poco de trabajo de su parte, para asegurar la imparcialidad en la distribución de las tareas (algunas pueden ser complicadas y no enfocadas en el ngs que has mencionado).

Answer 4

Una cosa a considerar, tal vez no para el primer curso de programación que hacen los estudiantes, pero más tarde, es devolverles el código de asignaciones anteriores (propias o ajenas) para corregir. Esto funciona mejor si elige envíos incorrectos, idealmente con defectos sutiles.

Una idea similar es tener una secuencia de laboratorios, utilizando el código (completado con éxito) del laboratorio anterior como punto de partida. Cuando hice el curso introductorio de programación (PINK - programación en sistemas incrementales) en LiU, hace tantos años, había un segmento del trabajo de laboratorio que (esencialmente) se reducía a la implementación de un calendario, usando tipos abstractos y accesorios, luego cambiando la implementación del tipo abstracto después.Bastante valioso para ilustrar la necesidad de proporcionar una buena interfaz, no necesitas dar un paso al costado, si nada más (desde la memoria, terminé pasando uno o dos días reflexionando sobre la "implementación del cambio", luego 15-20 minutos realmente cambiando mis tipos de datos abstractos, ya que había hecho el trabajo duro por adelantado y solo necesitaba convencerme de esto).

Answer 5

Cerdo latino.

Haga que sus alumnos escriban un código que traduzca una secuencia de texto del inglés al latín pig. The rules son bastante simples, pero requerirán algunos casos especiales interesantes, especialmente cuando se trata de puntuación y uso de mayúsculas, lo que requiere que escriban un escáner/tokenizador básico.

con una frase típica de esta manera:

Quietly, Anne walked into the forest. 

Usted debe conseguir esto:

ietly-quay, Anne-ay alked-way into-ay e-thay orest-fay. 

pero es probable que obtenga: puntuacion

uietly,-Qay Anne-ay alked-way into-ay e-thay orest.-fay 

que ha perdido, mal colocado Qu y mayúsculas incorrectas.

Answer 6

Un par de ideas que he encontrado para resonar con los estudiantes:.

1. arte fractal - una excelente manera de enseñar a la recursividad porque los estudiantes pueden visualizar el proceso (por ejemplo, el triángulo de Sierpinski, L-systems para los estudiantes ambiciosos) Puede ver algunos gráficos bastante impresionantes generados con gramáticas libres de contexto en context free art.
2. Manipulación de imágenes: enseñe la programación funcional asignando funciones de manipulación de píxeles a través de una imagen (por ejemplo, canales de color de intercambio, desenfoque gaussiano, manipulación del matiz); esto es algo más simple que las asignaciones típicas syntax tree-based generative art.

La parte más difícil de la enseñanza de las clases de informática de nivel introductorio es la disparidad en la capacidad de programación en la clase típica. Por lo tanto, si puede crear tareas que pueden ser lo suficientemente simples para los estudiantes menos capaces y ampliarse fácilmente (a través de crédito adicional, por ejemplo) a problemas más complejos para estudiantes avanzados, entonces eso es ideal en mi opinión.

Answer 7

package assignment01;/* Asegúrese de que esta clase esté en la asignación del paquete01. */

import java.util.ArrayList; import java.util.Arrays;

/** * Esta clase es una colección de métodos que realizan diversas funciones matemáticas. Los métodos son todos estáticos. Esta clase * es parte de la asignación n. ° 1. * * @author .......... * junio @version 15 2010 */public class MathLibrary {

/** 
* Computes and returns the mean (average) of the numbers in the list. 
* 
* If the input list is empty, the returned mean is 0.0. If the list contains illegal values, the behavior of this 
* method is undefined. 
* 
* @param list 
*   an ArrayList of double values 
* @return the mean of the values in the list 
*/ 
public static double mean (ArrayList<Double> list) 
{ 
    // Variables 

    Double sum = 0.0; 
    int arraySize = 0; 

    // Check for empty list 

    if (list.size()== 0) 
     return 0.0; 

    // Take sum 

    arraySize = list.size(); 
    for(int i = 0; i < arraySize; i++) 
    { 

     // Check for null Double 

     if(list.get(i) == null) 
     { 
      System.out.println("Mean Function: Array has null element at index: " + i + "."); 
      return -1.0; 
     } 

     // Add element 

     sum += list.get(i); 
    } 

    // Return average of results 

    return (sum/arraySize); 
    } 

/** 
* Computes and returns the median value of the numbers in the list. If the list has an odd number of elements, the 
* exact median value is returned. If the list has an even number of elements, the average of the middle two 
* elements is returned. 
* 
* If the input list is empty, the returned mean is 0.0. If the list contains illegal values, the behavior of this 
* method is undefined. 
* 
* The order of the elements in the input array may be changed by this method. 
* 
* @param arr 
*   an array of double values 
* @return the median of the values in the list 
*/ 
public static double median (double[] arr) 
{ 
    // Variables 

    double arraySize = 0; 
    double arrayMedian = 0.0; 
    double temp = 0.0; 
    boolean unsorted = true; 

    // Check for empty array 

    arraySize = arr.length; 
    if (arraySize == 0.0) 
     return 0.0; 

    // Sort array 

    while(unsorted) 
    { 
     unsorted = false; 
     for(int i=0; i < arraySize - 1; i++) 
     { 
      if(arr[i] > arr[i+1]) 
      { 
       unsorted = true; 
       temp = arr[i + 1]; 
       arr[i+1] = arr[i]; 
       arr[i] = temp; 
      } 
     } 
    } 

    // Find median 

    if((arraySize % 2) == 0) 
    { 
     // Take average of two middle array indicies 

     arrayMedian = (arr[(int) (arraySize/2.0 - 0.5)] + arr[(int) (arraySize/2.0 + 0.5)])/2.0; 
    } else { 
     arrayMedian = arr[(int) (arraySize/2.0)]; 
    } 


    return arrayMedian; 
    } 

/** 
* Computes and returns the largest integer that divides (without remainder) both of the input integers (the 
* greatest common divisor). 
* 
* If either of the input integers is not positive, this method returns -1. 
* 
* @param a 
*   any positive integer 
* @param b 
*   any positive integer 
* @return the greatest common divisor of a and b 
*/ 
public static int gcd (int a, int b) 
{ 
    int gcd = 1; 
    int minimum; 

    // Check for (a || b) < 0 

    if ((a < 0) || (b < 0)) 
     return -1; 
    if ((a == 0) || (b == 0)) 
     return 0; 

    // Compute half the minimum(a,b) 

    minimum = Math.min(a,b); 

    // For each number below half the minimum of the two check for divisibility 

    for(int i = 1; i <= minimum; i++) // zero case is already accounted for 
    { 
     // Check for divisibility 

     if(((a % i) == 0) && ((b % i) == 0)) 
     { 
     gcd = i; 
     } 
    } 

    return gcd; 
} 

/** 
* Computes and returns the smallest integer that can be divided by (without remainder) both of the input integers 
* (the least common multiple). 
* 
* 
* If either of the input integers is not positive, this method returns -1. If the least common multiple exceeds the 
* maximum possible integer value, the behavior of this method is undefined. 
* 
* @param a 
*   any positive integer 
* @param b 
*   any positive integer 
* @return the least common multiple of a and b 
*/ 
public static int lcm (int a, int b) 
{ 
    // Variables 

    int lcm = 0; 

    // Check for negative numbers 

    if((a < 0) || (b < 0)) 
     return -1; 

    // Use gcd to get lcm 

    lcm = (a * b)/gcd(a,b); 

    return lcm; 
    } 

/** 
* Given a number n, this method computes and returns the smallest prime number larger than n. 
* 
* If the input integer is not positive, this method returns 2. If the next prime number exceeds the maximum 
* possible integer value, the behavior of this method is undefined. 
* 
* @param n 
*   an integer 
* @return the smallest prime number larger than n 
*/ 
private static boolean isPrime(int n) 

{ 

if(n == 2 || n == 3) 
{ 
    return true; 
} 

if(n == 1 || n % 2 == 0) 
{ 
    return false; 
} 
for(int i = 3; i * i <= n; i += 2) 

if(n % i == 0) 
{ 
    return false; 
} 


return true; 

} 

public static int nextPrime(int n) 
{ 
    if (n<0) 
{ 
    return 2; //if n is not positive. 
} 
    int value = n; 
    if (n == 2) 
    value = 3; //finds the next prime number. 
    else 
    { 
    do 
    { 
     value += 1; 
    } while (!isPrime(value)); 
    } 
    return value; //displays the next prime number. 
} 

}

Answer 8

Una de las tareas que recuerdo con cariño cuando Creo que mis primeros días en la universidad fueron una tarea diseñada para enseñarnos sobre las GUI. Nos pidieron que implementaramos un navegador web.

La visualización real del contenido de la web no era particularmente importante - nos animaron a utilizar una vista oscilación web - era más sobre la funcionalidad que apoyó esto:

• una barra de URL
• historia
establecer
• adelante y atrás
• una página de inicio
• mantenimiento de marcadores/favoritos
• browsi pestañas ng
• etc

La misión que le dio vía libre para elegir cualquier combinación de éstos, a condición de que usted hizo por lo menos un número determinado. Esto permitió que las personas realmente entusiastas implementaran absolutamente todas las características si querían, y permitió que cualquiera que se apresurara más simplemente implementara el mínimo.

Hubo algunas tareas más que se estructuraron de manera similar a lo largo de los años y siempre les fue bien. Te sorprenderá la frecuencia con la que los estudiantes harán un esfuerzo adicional y harán más de lo necesario.

---

Como regla general, las cosas por mí mismo y mis coursemates parecía encontrar el más atractivo eran más visual: OpenGL, interfaces gráficas de usuario, sitios web, etc. Todos los programas basados ​​en la línea de comandos no eran tan divertido.

Tal vez debido a que se está centrando en algoritmos, podría ser una buena idea hacer que los estudiantes visualicen los algoritmos de clasificación/búsqueda. Además de enseñarles sobre un marco de gráficos, ayudaría a visualizar el algoritmo y consolidar su comprensión del mismo. Podría hacer algo similar con implementaciones personalizadas de estructuras de datos.

La clave para esto sería encontrar un marco de gráficos que sea razonablemente intuitivo, bien documentado, bien utilizado y bien respaldado. No había nada más frustrante que las tareas que nos obligaban a usar tecnologías que nadie en el mundo real realmente usa. No desea que el aprendizaje de esta tecnología sea la parte más difícil de la tarea.

No creo que sea necesariamente algo malo que les enseñe a utilizar un marco que puede considerarse fuera del alcance del módulo: aprender a usar nuevos marcos y bibliotecas es una habilidad en sí misma que necesita ser desarrollado si quieres ser un desarrollador de software efectivo y las universidades no parecen enseñar esto explícitamente.