Información para estudiantes del IRFA

Buenas noches apreciados estudiantes, aquí encontraran información de la asignatura matemática. Para ello seleccionen la opción Matemática en la lista de paginas y escojan su año de estudio.
En caso de que tengan dudas me escriben.

2018

Hola hola!! Tras más de un año de ausencia (debido a la carencia de computadora :( ). Regrese, en los próximos días estaré publicando más entradas con temas de programación, matemáticas y más.

Merlis Andreina Guerrero

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: