Inicializacion de vectores

Los vectores pueden inicializarse, en la linea de declaración o aparte, de las siguientes formas.

Caso Vector entero:

Forma 1: Declarar vector entero e inicializarlo en la misma linea.

Para inicializar se coloca el simbolo = seguido de un par de llaves, entre las llaves va el valor de cada posición del vector separados por comas.

Codigo:

//*********************************************************************
#include <stdio.h>
int main(){
    int i;
    int vec[5]={96,85,34,32,1};
    for(i=0;i<5;i++)
        printf(" %d ",vec[i]);
}
//*********************************************************************

Forma 2: Declarar vector entero e inicializarlo después.

Se declara el vector y luego se inicializa cada posición del vector colocando el nombre del vector con el número de índice entre corchetes seguido del símbolo = y el valor que se le va a asignar.

Codigo:

//*********************************************************************
#include <stdio.h>
int main(){
    int i;
    int vec[5];
    vec[0]=96;
    vec[1]=85;
    vec[2]=34;
    vec[3]=32;
    vec[4]=1;
    for(i=0;i<5;i++)
        printf(" %d ",vec[i]);
    return 0;
}
//*********************************************************************
Salida para los dos codigos:

Caso Vector Real:

Forma 1: Declarar vector real e inicializarlo en la misma linea.

Igual que para los enteros, los reales se inicializan colocando el símbolo = seguido de un par de llaves y entre ellas los valores de cada posición del vector separados por comas.

Codigo:

//*********************************************************************
#include <stdio.h>
int main(){
    int j;
    float vec[5]={2.34,6.01,5.33,6.32,7.98};
    for(j=0;j<5;j++)
        printf(" %.2f ",vec[j]);
    return 0;
}
//*********************************************************************

Forma 2: Declarar vector real e inicializarlo después.

Se declara el vector y en otra linea se inicializa cada posición escribiendo el nombre del vector con su respectivo índice entre corchetes, seguido del símbolo = y el valor que se le va a asignar.

Codigo:

//*********************************************************************
#include <stdio.h>
int main(){
    int j;
    float vec[5];
    vec[0]=2.34;
    vec[1]=6.01;
    vec[2]=5.33;
    vec[3]=6.32;
    vec[4]=7.98;
    for(j=0;j<5;j++)
        printf(" %.2f ",vec[j]);
    return 0;
}
//*********************************************************************
Salida para los dos codigos:

Caso Vector de Caracteres:

Forma 1: Declarar vector de caracteres e inicializarlo en la misma linea.

Es muy parecida a los casos anteriores, solo que esta vez los caracteres que se van a asignar deben ir entre comillas simples.

Codigo:

//*********************************************************************
#include <stdio.h>
int main(){
    int t;
    char vec[5]={'h','e','i','d','y'};
    for(t=0;t<5;t++)
        printf(" %c ",vec[t]);
    return 0;
}
//*********************************************************************

Forma 2: Declarar vector de caracteres e inicializarlo en la misma linea.

Codigo:

//*********************************************************************
#include <stdio.h>
int main(){
    int t;
    char vec[6]="heidy";
    for(t=0;t<5;t++)
        printf(" %c ",vec[t]);
    return 0;
}
//*********************************************************************

Forma 3: Declarar vector de caracteres e inicializarlo después.

Se declara el vector y aparte se inicializa cada posición, la única diferencia respecto a los casos anteriores es que el caracter asignado debe ir entre comillas simples.

Codigo:

//*********************************************************************
#include <stdio.h>
int main(){
    int t;
    char vec[6];
    vec[0]='h';
    vec[1]='e';
    vec[2]='i';
    vec[3]='d';
    vec[4]='y';
    for(t=0;t<5;t++)
        printf(" %c ",vec[t]);
    return 0;
}
//*********************************************************************
Salida para los tres codigos:

Caso Vector de Caracteres:

Forma 1: Declarar vector de cadena de caracteres e inicializarlo en la misma linea.

Es igual a los casos anteriores, pero ahora como se van a asignar cadenas, deben ir entre comillas dobles.

Codigo:

//*********************************************************************
#include <stdio.h>
int main(){
    int u;
    char vec[5][10]={"merida","tachira","trujillo","barinas","zulia"};
    for(u=0;u<5;u++)
        printf(" %s ",vec[u]);
    return 0;
}
//*********************************************************************

Forma 2: Declarar vector de caracteres e inicializarlo después.

Para este caso no se puede realizar de la misma manera que se trabajo anteriormente.

Esta expresión no es correcta: vec[0]="hola";

Para este caso se debe utilizar una de las funciones de la libreria string.h, llamada strcpy cuyo trabajo es copiar una cadena o variable, en otra variable.

Codigo:

//*********************************************************************
#include <stdio.h>
#include <string.h>
int main(){
    int u;
    char vec[5][10];
    strcpy(vec[0],"merida");
    strcpy(vec[1],"tachira");
    strcpy(vec[2],"trujillo");
    strcpy(vec[3],"barinas");
    strcpy(vec[4],"zulia");
    for(u=0;u<5;u++)
        printf(" %s ",vec[u]);
    return 0;
}
//*********************************************************************
Salida para los dos codigos:

 

Matrices

Son arreglos que tienen dos dimensiones. De igual manera que los vectores, son estáticos, se les indica el tamaño para cada dimensión y lo mantienen hasta el fin de la ejecución del programa.

Las matrices pueden visualizarse como una tabla, sus dimensiones son el número de filas y número de columnas.

La sintaxis es:
tipo_dato MATRIZ[filas][columnas];

Matriz Entera: Es un grupo de variables de tipo entero.
Ejemplo:

//*******************************************************************
#include <stdio.h>
int main(){
    int matriz[2][3],q,w;
    for(q=0;q<2;q++){
        for(w=0;w<3;w++){
            printf("matriz[%d][%d]= ",q,w);

            scanf("%d",&matriz[q][w]);
        }
    }
    for(q=0;q<2;q++){
        printf("\n");

        for(w=0;w<3;w++){
            printf(" %d ",matriz[q][w]);
        }
    }
    return 0;
}
//*******************************************************************
Salida:

Matriz Real: Es un grupo de variables de tipo real.

Ejemplo:

//*******************************************************************
#include <stdio.h>
int main(){
    float matriz[3][2];
    int q,w;
    for(q=0;q<3;q++){
        for(w=0;w<2;w++){
            printf("\nMatriz[%d][%d]= ",q,w);
            scanf("%f",&matriz[q][w]);
        }
    }
    for(q=0;q<3;q++){
        printf("\n");
        for(w=0;w<2;w++){
            printf(" %.1f ",matriz[q][w]);
        }
    }
    return 0;
}
//*******************************************************************
Salida:

Matriz de caracteres: Es un grupo de variables de tipo caracter.

Ejemplo:

//*******************************************************************
#include <stdio.h>
int main(){
    char matriz[3][2];
    int i,j;
    for(i=0;i<3;i++){
        for(j=0;j<2;j++){
            printf("Matriz[%d][%d]: ",i,j);
            fflush(stdin);
            scanf("%c",&matriz[i][j]);
        }
    }
    for(i=0;i<3;i++){
        printf("\n");
        for(j=0;j<2;j++){
            printf(" %c ",matriz[i][j]);
        }
    }
    return 0;
}
//*******************************************************************
Salida:

Matriz de cadena de caracteres: Es un grupo de vectores de tipo caracter. Es similar a un arreglo de caracteres de tres dimensiones.

Ejemplo:

//*******************************************************************
#include <stdio.h>
int main(){
    char matriz[3][2][10];
    int i,j;
    for(i=0;i<3;i++){
        for(j=0;j<2;j++){
            printf("Matriz[%d][%d]: ",i,j);
            fflush(stdin);
            scanf("%s",&matriz[i][j]);
        }
    }
    for(i=0;i<3;i++){
        printf("\n");
        for(j=0;j<2;j++){
            printf(" %s ",matriz[i][j]);
        }
    }
    return 0;
}
//*******************************************************************
Salida:

 

Ejemplo logaritmo

Usando la libreria math.h podemos calcular el logaritmo de base 10 y el logaritmo neperiano (de base e).

Ejemplo 1: Logaritmo de base 10
Codigo:
//*******************************************************************
#include <stdio.h>
#include <math.h>
int main(){
    float num,l;
    puts("\t\tLogaritmo de base 10.");

    puts("\n\tNumero: ");
    scanf("%f",&num);
    l=log10(num);
    printf("\n\tEl resultado es: %.2f",l);
    return 0;
}
//*******************************************************************
Salida:

Ejemplo 2: Logaritmo neperiano
Codigo:
//*******************************************************************
#include <stdio.h>
#include <math.h>
int main(){
    float num,l;
    puts("\t\tLogaritmo Neperiano.");
    puts("\n\tNumero: ");
    scanf("%f",&num);
    l=log(num);

    printf("\n\tEl resultado es: %.2f",l);
    return 0;
}
//*******************************************************************
Salida:

Ejemplo Raiz de indice n

Enunciado: Codificar un programa en C que calcule la raiz de un índice n para un número ingresado por el usuario.
Una forma de hacerlo puede ser la siguiente.

Codigo 1:
//*******************************************************************
#include <stdio.h>
int main(){
    float cantidad,base=0.001,resultado=0,indice;
    int cantidad_entera,resultado_entero,band=0;
    puts("\t\tRaices.");
    puts("\n\tIndice de raiz: ");
    scanf("%f",&indice);
    puts("\n\tNumero: ");
    scanf("%f",&cantidad);
    cantidad_entera=(int)cantidad;
    resultado=pow(base,indice);
    resultado_entero=(int)resultado;
    if(cantidad_entera==resultado_entero)
        band=1;
    while(band==0){
        base+=0.001;
        resultado=pow(base,indice);
        resultado_entero=(int)resultado;
        if(cantidad_entera==resultado_entero)
            band=1;
    }
    printf("\nLa raiz de indice %.0f para %.0f es %.3f",indice,cantidad,base);
    return 0;
}
//*******************************************************************
Salida:

Otra opción puede ser:
Codigo 2:
//*******************************************************************
#include <stdio.h>
#include <math.h>
int main(){
    float num,indice,exp;
    float res;
    puts("\t\tRaices.");
    puts("\n\tIndice de raiz: ");
    scanf("%f",&indice);
    puts("\n\tCantidad subradical: ");
    scanf("%f",&num);
    exp=1.0/indice;
    res=pow(num,exp);
    printf("La raiz de indice %.0f para %.0f es %f",indice,num,res);
    return 0;
}
//*******************************************************************
Salida:

 

Ejemplos de math.h

A continuación algunos ejemplos usando funciones de la libreria math.h

Pow: se utiliza para calcular una potencia. La sintaxis es:

pow(base,exponente);

Ejemplo 1: Calcular una potencia.

Codigo:
//*******************************************************************
#include <stdio.h>
#include <math.h>
int main(){
    int e,b,p;
    puts("\t\tPotenciacion: ");
    do{
        puts("\n\tIngrese la base: ");
        scanf("%d",&b);
        puts("\n\tIngrese el exponente: ");
        scanf("%d",&e);   
    }while(b==0);
    if(e==0)
        p=1;
    else
        p=pow(b,e);
    printf("\nPotencia= %d",p);
    return 0;
}
//*******************************************************************

Salida:

  

Sqrt: se utiliza para calcular una raíz cuadrada. La sintaxis es:

sqrt(numero);

Ejemplo 2: Calcular una raíz cuadrada.

Codigo:

 //*******************************************************************
#include <stdio.h>
#include <math.h>
int main(){
    float num;
    puts("\t\tRaiz Cuadrada");
    puts("\n\tIngrese un numero: ");
    scanf("%f",&num);
    num=sqrt(num);
    printf("\n\tRaiz cuadrada: %.2f",num);
    return 0;
}
//*******************************************************************
Salida:

 

Sin: se utiliza para calcular el seno de un número y devuelve el resultado en radianes. La sintaxis es:
sin(numero);

Ejemplo 3: Calcular el seno de un número.
Codigo:
//*******************************************************************
#include <stdio.h>
#include <math.h>
int main(){
    float n,s;
    puts("\t\tSeno de un numero.");
    puts("\n\tIngrese un numero: ");
    scanf("%f",&n);
    s=sin(n);
    printf("Seno es %.3f",s);
    return 0;
}
//*******************************************************************
Salida:

Cos: se utiliza para calcular el coseno de un número y devuelve el resultado en radianes. La sintaxis es:  cos(numero);

Ejemplo 4: Calcular el coseno de un número.
Codigo:
//*******************************************************************
#include <stdio.h>
#include <math.h>
int main(){
    float n,c;
    puts("\t\tCoseno de un numero: ");
    puts("\tNumero: ");
    scanf("%f",&n);
    c=cos(n);
    printf("\n\tCoseno es %.3f",c);
    return 0;
}
//*******************************************************************
Salida:

Tan: Se utiliza para calcular la tangente de un número y devuelve el resultado en radianes. La sintaxis es:  tan(numero);

Ejemplo 5: Calcular la tangente de un numero.

Codigo:

//*******************************************************************
#include <stdio.h>
#include <math.h>
int main(){
    float n,t;
    puts("\t\tTangente de un numero: ");
    puts("\tNumero: ");
    scanf("%f",&n);
    t=tan(n);
    printf("\n\tTangente es %.3f",t);
    return 0;
}
//*******************************************************************
Salida:

 

Libreria math.h

math.h es una libreria que contiene un grupo de funciones para realizar operaciones matemáticas basicas.
Nota: todas las funciones en las que participan ángulos (sen,cos..) ingresan y devuelven radianes.

Tenemos:

acos                      arcocoseno

asin                       arcoseno

atan                      arcotangente

atan2                    arcotangente de dos parámetros

floor                    función suelo

cos                         coseno

cosh                      coseno hiperbólico

exp(double x)    función exponencial, computa ex

fabs                      valor entero

ceil                       menor entero no menor que el parámetro

fmod                    residuo de la división de flotantes

frexp                    fracciona y eleva al cuadrado.

ldexp                    tamaño del exponente de un valor en punto flotante

log                         logaritmo natural

log10                     logaritmo en base 10

modf                   obtiene un valor en punto flotante íntegro y en partes

pow(x,y)               eleva un valor dado a un exponente, xy

sin                          seno

sinh                      seno hiperbólico

sqrt                      raíz cuadrada

tan                       tangente

tanh                     tangente hiperbólica

Ejercicio switch

Enunciado:

Diseñe un Algoritmo que le permita a un usuario seleccionar de un menú, una de las siguientes opciones:
- Traducir Kilogramos a libras.
- Convertir grados Kelvin a grados Centígrados.
- Traducir Km/min a cm/s.

Codigo:
//*******************************************************************
#include <stdio.h>
int main(){
    int opc;
    float cant;
    do{
        system("cls");
        puts("\t\tMenu.");
        puts("\n\t1. Traducir Kilogramos a libras.");
        puts("\n\t2. Convertir grados Kelvin a grados Centigrados.");
        puts("\n\t3. Traducir km/min a cm/s.");
        puts("\n\t4. Salir.");
        puts("\n\n\tSeleccione una opcion (1,2,3 o 4): ");
        scanf("%d",&opc);
    }while(!(opc==1 || opc==2 || opc==3 || opc==4));
    system("cls");
    switch(opc){
        case 1:
            puts("\n\tTraducir Kilogramos a libras.");
            puts("\n\nIngrese la cantidad de kilogramos: ");
            scanf("%f",&cant);
            cant*=2.20462;
            printf("\n\t Son %.2f libras",cant);
            break;
        case 2:
            puts("\n\tConvertir grados Kelvin a grados Centigrados.");
            puts("\n\nIngrese la cantidad en grados Kelvin: ");
            scanf("%f",&cant);
            cant-=273.15;
            printf("\n\tSon %.2f grados Centigrados.");
            break;
        case 3:
            puts("\n\tTraducir km/min a cm/s.");
            puts("\n\nIngrese la cantidad de km/min: ");
            scanf("%f",&cant);
            cant*=1.66666;
            printf("Son %.2f cm/s.",cant);
            break;
        default:
            puts("Fin de la ejecucion");
    }
    return 0;
}
//*******************************************************************
Salida:

-Menu:

 

-Opción 1:

 

-Opción 2:

 

-Opción 3:

 

Vectores

Son arreglos de una dimensión. Los vectores son estáticos, se indica el tamaño y lo mantienen hasta el fin de la ejecución.

Vector Entero: Es un grupo de variables de tipo entero. En la declaración se indica la cantidad de variables que se van a almacenar.

Ejemplo:

//*******************************************************************
#include <stdio.h>
int main(){
    int vector[4],q;
    for(q=0;q<4;q++){
        printf("\nIngrese un numero para la variable vector[%d]: ",q);
        scanf("%d",&vector[q]);
    }
    puts("Guardaste: ");
    for(q=0;q<4;q++)
        printf("\nVector[%d]= %d",q,vector[q]);
    return 0;
}
//*******************************************************************
Salida:

Vector Real: Es un grupo de variables de tipo real. En la declaración se indica la cantidad de variables que se van a almacenar.

Ejemplo:

//*******************************************************************
#include <stdio.h>
int main(){
    float vector[4];
    int q;
    for(q=0;q<4;q++){
        printf("\nIngrese un numero para la variable vector[%d]: ",q);
        scanf("%f",&vector[q]);
    }
    puts("Guardaste: ");
    for(q=0;q<4;q++)
        printf("\nVector[%d]= %.2f",q,vector[q]);
    return 0;
}
//*******************************************************************
Salida:

Vector de carateres: Es un grupo de caracteres, el vector de caracteres es lo mismo que la cadena de caracteres, se declara igual.

Ejemplo:

//*******************************************************************
#include <stdio.h>
int main(){
    char vector[4];
    int q;
    for(q=0;q<4;q++){
        printf("\nIngrese un caracter para la variable vector[%d]: ",q);
        fflush(stdin);
        scanf("%c",&vector[q]);
    }
    puts("Guardaste: ");
    for(q=0;q<4;q++)
        printf("\nVector[%d]= %c",q,vector[q]);
    return 0;
}
//*******************************************************************
Salida:

Vector de cadenas de caracter: Su forma es mas parecida al vector de dos dimensiones porque inicialmente la cadena es un vector, y un vector de cadenas agregaria otra dimension

Ejemplo:

//*******************************************************************
#include <stdio.h>
int main(){
    char vector[4][10];
    int q;
    fflush(stdin);
    for(q=0;q<4;q++){
        printf("\nIngrese un caracter para la variable vector[%d]: ",q);
        scanf("%s",&vector[q]);
    }
    puts("Guardaste: ");
    for(q=0;q<4;q++)
        printf("\nVector[%d]= %s",q,vector[q]);
    return 0;
}
//*******************************************************************
Salida: