Antes de empezar, repasar:

Funciones que toman arreglos como parametros

Cuando indicamos que una función toma un arreglo como parametro, no es necesario indicar el tamaño de ese último y se puede indicar de la forma siguiente: int a[] (si queremos llamar a el arreglo).

Además si queremos decirle al compilador que la función no debe modificar valores del arreglo, agregamos la palabra const. Por ejemplo void mostrar(const int a[]).

O si consideramos la funcion que, dada una lista, nos devuelve su máximo elemento:

#include <stdio.h>
#define MAX 6

int max_lista(const int a[]){
    int i=0;
    int m= a[0];
    for(i=1;i<MAX;i++){
        if (a[i] > m){ m = a[i]; }
    }
    return m;
}

int main(void){
    int a[MAX]= {45,6,2,36,6236,3};
    int m;
    m = max_lista(a);
    printf("%d\n", m);
    return 0;
}

Si queremos escribir funciones que toman arreglos como parámetros y los modifican, sacamos la palabra const para permitirlo.

Este cuatrimestre no vamos a escribir funciones que devuelven arreglos nuevos. Eso implicaría gestionar la memoria de manera dinámica.

En lugar de devolver un arreglo nuevo, vamos a pasar como parametro un arreglo vacío para que reciba el resultado de la función, y ponemos que el tipo de devolución de la función es void.

Por ejemplo, en la función siguiente consideramos que el arreglo b es el resultado del cálculo:

void mas_uno(const int a[], int b[]){
 int i;
 for(i=0; i<MAX; i=i+1){
  b[i] = a[i] + 1;
 }
}

¿Qué hace esta función?

En un programa arreglos.c definir una constante MAX para el tamaño de todos nuestros arreglos:

#define MAX 10

Definir las funciones siguientes:

En el main declarar un arreglo, llenarlo con llenar_random y mostrarlo con mostrar.

En arreglos.c implementar una función void invertir(const int a[], int b[]), que no modifique la lista a y que escribe en la lista b el inverso de a.

Usarla desde la funcion main:

...
int x[MAX];
int y[MAX];
...
llenar_random(x);
invertir(x,y);
mostrar(x);
mostrar(y);
...

¿Podríamos invertir una lista (disonible en lectura yescritura) sin usar otra lista?

Pensar en como hacer un algoritmo para eso.

Implementar la función void invertir2(int a[]):

...
int z[MAX];
...
llenar_random(z);
mostrar(z);
invertir2(z);
mostrar(z);
...

Suma en paralelo

Implementar void suma_paralela(const int a[], const int b[], int c[]) que modifica el arreglo c de manera que para todo indice i, c[i] == a[i] + b[i].

Probarla desde el main:

...
int sumax[MAX];
int sumay[MAX];
int sumaz[MAX];
...
llenar_random(sumax);
llenar_random(sumay);
suma_paralela(sumax,sumay,sumaz);
mostrar(sumax);
mostrar(sumay);
mostrar(sumaz);
...

Algoritmo de búsqueda, uso de la sentencia return

Primero, leer los apuntes siguientes:

Ahora, consideramos el problema siguiente. Tenemos:

Queremos encontrar:

En otros términos, queremos devolver la posición de un elemento dado dentro de una lista dada. Si ese elemento no pertenece a la lista, devolvemos un valor que no es una posición sino un código de error. Vamos a usar -1: siendo un número negativo, no hay ambigüedad, no se puede interpretar como una posición.

En arreglos.c, definir un macro ERROR para el valor -1:

#define ERROR -1

Implementar la función int buscar(const int a[], const int b), que realiza la búsqueda lineal de un elemento en un arreglo, devolviendo el valor ERROR cuando el elemento buscado no es parte del arreglo.

"Búsqueda lineal" significa que el algoritmo busca desde el indice 0 hasta el máximo indice de la lista.

Probar esta función desde el main sobre un arreglo nuevo definido manualmente (porque con un arreglo aleatorio es probable que la búsqueda falle):

...
int buscable[MAX] = {10,20,30,40,50,60,70,80,90,100};
...
/* unos assert para probar que la funcion buscar anda */
assert( buscar(buscable, 10) == 0 );
assert( buscar(buscable, 100) == 9 );
assert( buscar(buscable, 44) == ERROR );
...

Entrega

Mandar arreglos.c.

Consignas antes de entregar su trabajo: