Lab 1 3° Semestre

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Escriba el código para la función suma, la cual recibe 3 parámetros enteros (a,b y c) y almacena en c el valor de la suma de a más b. El main del programa es el siguiente:

int main() {
  int c;
  suma(5,10,&c);
  printf(“%d”, c); //debería imprimir 15
  return 0;
}
_______________________________________________________________________________________________________________________________________
int suma(int num1, int num2, int *c){
    *c += num1+num2;
    return 0;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Considere el siguiente código:
int sumaN(int a[], int N){
    int i; int tot=0;
    for(i=0; i<N; i++)
      tot+=a[i];
    return tot;
}

int main() {
    int b[10];

    int i;
    for(i=0; i<10; i++)
       b[i]=i;

    ... //su respuesta va aquí

    printf("%d",c);
    return 0;
}
Inicialice la variable c con la suma de los últimos 5 elementos del arreglo b.
Para ello sólo puede usar la función int sumaN(int a[], int N), que retorna la suma de un arreglo a[] de tamaño N.
(Hint: Recuerde la relación que existe entre arreglos y punteros).
_______________________________________________________________________________________________________________________________________
int c;
    c = sumaN(b,10)-sumaN(b,5);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Considere el tipo de dato Persona:

typedef struct{
  char nombre[30];
  char rut[11];
  int edad;
} Persona;

Escriba la función Persona* CreaPersona(char nombre[], char rut[], int edad), la cual crea una nueva persona con los datos correspondientes y retorna un puntero al dato recién creado.

(Hint: debe reservar memoria para el nuevo dato usando malloc)
(Hint2: recuerde usar strcpy para copiar strings)
_______________________________________________________________________________________________________________________________________
Persona* CreaPersona(char nombre[], char rut[], int edad){
    Persona *cadena;
    //Se asigna la memoria para cadena
    cadena = (Persona*) malloc (sizeof(Persona));

    //Transpasan los datos
    strcpy(cadena->nombre, nombre);
    strcpy(cadena->rut, rut);
    cadena->edad = edad;

    //Se retorna la cadena con los valores
    return cadena;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Considere el tipo de dato Vector:

typedef struct{
   int* datos; //arreglo dinámico
   int dim; //dimensión del vector
} Vector;

Escriba la función Vector* creaVector(int n), la cual crea un vector con dimensión n y reserva la memoria correspondiente para el arreglo con n datos inicializados en 0. Luego retorna el vector creado.
_______________________________________________________________________________________________________________________________________
Vector* creaVector(int n){
    Vector *cadena;

    cadena = (Vector*) calloc (n,sizeof(Vector));
    cadena->datos= (int*) calloc(n,sizeof(int));
    cadena->dim = n;
    return cadena;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Considere el tipo de dato Vector:
typedef struct{
  int* datos; //arreglo dinámico
  int dim; //dim
} Vector;

Implementa la función int obtieneDato(Vector* v, int pos), la cual retorna el dato en la posición pos del vector v.
_______________________________________________________________________________________________________________________________________
int obtieneDato(Vector* v, int pos){

    return v->datos[pos];

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Considere el tipo de dato Vector:

typedef struct{
  int* datos; //arreglo dinámico
  int dim; //dim
} Vector;

Escriba la función void suma(Vector* a, Vector* b, Vector *c), la cual suma los vectores a y b y el resultado lo almacena en el vector c.
_______________________________________________________________________________________________________________________________________
void suma(Vector* a, Vector* b, Vector *c){

    for(int i = 0; i < a->dim; i++){
        c->datos[i] = a->datos[i]+b->datos[i];
    }

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Considere el tipo de dato Vector:

typedef struct{
  int* datos; //arreglo dinámico
  int dim; //dim
} Vector;

y las operaciones:

Vector* creaVector(int n);
int obtieneDato(Vector* v, int pos);
void guardaDato(Vector* v, int pos, int dato);
void suma(Vector* a, Vector* b, Vector *c);
void resta(Vector* a, Vector* b, Vector *c);

Usando las operaciones, traduzca el siguiente algoritmo a lenguaje C (mantenga los nombres de las variables):

a = (2 4 5)
b = (1 1 1)
c = (0 8 0)
d = a+b-c
print a
_______________________________________________________________________________________________________________________________________
Vector *a= creaVector(3);
Vector *b= creaVector(3);
Vector *c= creaVector(3);
Vector *d= creaVector(3);

guardaDato(a,0,2);
guardaDato(a,1,4);
guardaDato(a,2,5);
guardaDato(b,0,1);
guardaDato(b,1,1);
guardaDato(b,2,1);
guardaDato(c,0,0);
guardaDato(c,1,8);
guardaDato(c,2,0);

suma(a, b, d);
resta( d, c, d);

        printf("(%d %d %d)",a->datos[0],a->datos[1],a->datos[2]);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////