Mostrar Valores de la columna impar y filas pares de dos matrices en java

import java.util.Scanner;
public class algoritmo_10_matriz {
    Scanner leer= new Scanner (System.in);
   
 
    public static void main(String[] args){
       algoritmo_10_matriz menu= new algoritmo_10_matriz();
       menu.menuGeneral();
    }
 
 
   public int menuGeneral(){
   int opcion;
   do{
       System.out.println("");
       System.out.println("===================================================");
       System.out.println("================= MENU DE OPCIONES ================");
       System.out.println("===== 1.SUMA DE MATRICES                       ====");
       System.out.println("===== 2.MULTIPLICACION DE MATRICES             ====");
       System.out.println("===== 3.TRANSPUESTA MATRIZ A^B                 ====");
       System.out.println("===== 4.SUMA DIAGONAL PRINCIPAL MATRIZ A^B     ====");
       System.out.println("===== 5.MAXIMO Y MINIMO MATRIZ A ^ B           ====");
       System.out.println("===== 6.COLUMNA IMPAR ^ FILAS PARES MATRIZ A^B ====");
       System.out.println("===== 7.SALIR                                  ====");
       System.out.println("===================================================");
       System.out.print("Ingrese una opcion: ");
       opcion=leer.nextInt();
 
       switch(opcion){
           case 1: SumadeMatriz(); break;
           case 2: MultiplicacionMatriz();break;
           case 3: TranspuestaMatriz();break;
           case 4: DiagonalPrincipalMatrices();break;
           case 5: MaximoMinimoMatriz();break;
           case 6: ColumnaImparFilaPar();break;
           case 7: System.out.println("................Saliendo del menu ..............");
               System.exit(0); break;
           default: System.out.println("Ingrese una opcion valida.......!!"); break;

       }
     
     
     
   }while(opcion != 8);
   return 0;
   }


public void ColumnaImparFilaPar(){

        int n, m, i, j;
        int A[][] = new int[10][10];
        int B[][] = new int[10][10];
     
        System.out.print("Ingrese dimension n: ");
        n = leer.nextInt();
        System.out.print("Ingrese dimension m: ");
        m = leer.nextInt();

        System.out.println("INGRESE VALORES MATRIZ A");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("A[" + (i) + "," + (j) + "]= ");
                A[i][j] = leer.nextInt();
            }
        }

        System.out.println("INGRESE VALORES MATRIZ B");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("B[" + (i) + "," + (j) + "]= ");
                B[i][j] = leer.nextInt();
            }
        }

        //IMPRIMIENDO MATRICES A Y B
        System.out.println("======== MATRIZ A =========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + A[i][j]);
            }
            System.out.println();
        }

        System.out.println("====== MATRIZ B ========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + B[i][j]);
            }
            System.out.println();
        }
     
        System.out.println(" MATRIZ A --->>> (COLUMNAS IMPARES ^ FILAS PARES)");
        //columnas impares
         for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                if(j%2==1){
                    System.out.print("\t"+A[i][j]);
                }
            }
        }
         //filas pares
         System.out.println("");
         for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                if(i%2==0){
                  System.out.print("\t"+A[i][j]);
                }
            }
        }
       
         System.out.println("");
         System.out.println(" MATRIZ B --->>> (COLUMNAS IMPARES ^ FILAS PARES)");
            //columnas impares
         for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                if(j%2==1){
                    System.out.print("\t"+B[i][j]);
                }
            }
        }
         //filas pares
         System.out.println("");
         for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                if(i%2==0){
                  System.out.print("\t"+B[i][j]);
                }
            }
        }

LEER MÁS

Máximo y Mínimo de dos Matrices en java

import java.util.Scanner;
public class algoritmo_10_matriz {
    Scanner leer= new Scanner (System.in);
   
 
    public static void main(String[] args){
       algoritmo_10_matriz menu= new algoritmo_10_matriz();
       menu.menuGeneral();
    }
 
   public int menuGeneral(){
   int opcion;
   do{
       System.out.println("");
       System.out.println("===================================================");
       System.out.println("================= MENU DE OPCIONES ================");
       System.out.println("===== 1.SUMA DE MATRICES                       ====");
       System.out.println("===== 2.MULTIPLICACION DE MATRICES             ====");
       System.out.println("===== 3.TRANSPUESTA MATRIZ A^B                 ====");
       System.out.println("===== 4.SUMA DIAGONAL PRINCIPAL MATRIZ A^B     ====");
       System.out.println("===== 5.MAXIMO Y MINIMO MATRIZ A ^ B           ====");
       System.out.println("===== 6.COLUMNA IMPAR ^ FILAS PARES MATRIZ A^B ====");
       System.out.println("===== 7.SALIR                                  ====");
       System.out.println("===================================================");
       System.out.print("Ingrese una opcion: ");
       opcion=leer.nextInt();
 
       switch(opcion){
           case 1: SumadeMatriz(); break;
           case 2: MultiplicacionMatriz();break;
           case 3: TranspuestaMatriz();break;
           case 4: DiagonalPrincipalMatrices();break;
           case 5: MaximoMinimoMatriz();break;
           case 6: ColumnaImparFilaPar();break;
           case 7: System.out.println("................Saliendo del menu ..............");
               System.exit(0); break;
           default: System.out.println("Ingrese una opcion valida.......!!"); break;

       }
     
     
     
   }while(opcion != 8);
   return 0;
   }

public void MaximoMinimoMatriz(){

        int n, m, i, j;
        int A[][] = new int[10][10];
        int B[][] = new int[10][10];
     
        System.out.print("Ingrese dimension n: ");
        n = leer.nextInt();
        System.out.print("Ingrese dimension m: ");
        m = leer.nextInt();

        System.out.println("INGRESE VALORES MATRIZ A");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("A[" + (i) + "," + (j) + "]= ");
                A[i][j] = leer.nextInt();
            }
        }

        System.out.println("INGRESE VALORES MATRIZ B");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("B[" + (i) + "," + (j) + "]= ");
                B[i][j] = leer.nextInt();
            }
        }

        //IMPRIMIENDO MATRICES A Y B
        System.out.println("======== MATRIZ A =========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + A[i][j]);
            }
            System.out.println();
        }

        System.out.println("====== MATRIZ B ========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + B[i][j]);
            }
            System.out.println();
        }
     
       int menorA=A[1][1],mayorA=A[1][1],menorB=B[1][1],mayorB=B[1][1];
     
        System.out.println("*********************  MATRIZ A (MAXIMO Y MINIMO) ***************");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                //calculo del MENOR valor de la matriz
                if(i!=1 && j!=1){
                 if(A[i][j]>mayorA){
                    mayorA=A[i][j];
                }
                //calculo del MAYOR valor de la matriz
                if(A[i][j]<menorA){
                    menorA=A[i][j];
                }
                }
            }
        }
     
        System.out.println("NUMERO MENOR DE MATRIZ : "+menorA);
        System.out.println("NUMERO MAYOR DE MATRIZ : "+mayorA);
     
        System.out.println("*********************  MATRIZ B (MAXIMO Y MINIMO) ****************");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                //calculo del mayor valor de la matriz
                if(i!=1 && j!=1){
                 if(B[i][j]>mayorB){
                    mayorB=B[i][j];
                }
                //calculo del menor valor de la matriz
                if(B[i][j]<menorB){
                    menorB=B[i][j];
                }
                }
            }
        }

        System.out.println("NUMERO MENOR DE MATRIZ : "+menorB);
        System.out.println("NUMERO MENOR DE MATRIZ :"+mayorB);

}

}

LEER MÁS

Sumar Diagonal Principal de dos matrices en java

import java.util.Scanner;
public class algoritmo_10_matriz {
    Scanner leer= new Scanner (System.in);
   
 
    public static void main(String[] args){
       algoritmo_10_matriz menu= new algoritmo_10_matriz();
       menu.menuGeneral();
    }
 
 
   public int menuGeneral(){
   int opcion;
   do{
       System.out.println("");
       System.out.println("===================================================");
       System.out.println("================= MENU DE OPCIONES ================");
       System.out.println("===== 1.SUMA DE MATRICES                       ====");
       System.out.println("===== 2.MULTIPLICACION DE MATRICES             ====");
       System.out.println("===== 3.TRANSPUESTA MATRIZ A^B                 ====");
       System.out.println("===== 4.SUMA DIAGONAL PRINCIPAL MATRIZ A^B     ====");
       System.out.println("===== 5.MAXIMO Y MINIMO MATRIZ A ^ B           ====");
       System.out.println("===== 6.COLUMNA IMPAR ^ FILAS PARES MATRIZ A^B ====");
       System.out.println("===================================================");
       System.out.print("Ingrese una opcion: ");
       opcion=leer.nextInt();
 
       switch(opcion){
           case 1: SumadeMatriz(); break;
           case 2: MultiplicacionMatriz();break;
           case 3: TranspuestaMatriz();break;
           case 4: DiagonalPrincipalMatrices();break;
           case 5: MaximoMinimoMatriz();break;
           case 6: ColumnaImparFilaPar();break;
           case 7: System.out.println("................Saliendo del menu ..............");
               System.exit(0); break;
           default: System.out.println("Ingrese una opcion valida.......!!"); break;

       }
     
   }while(opcion != 8);
   return 0;
   }


public void DiagonalPrincipalMatrices(){

        int n, m, i, j;
        int A[][] = new int[10][10];
        int B[][] = new int[10][10];
     
        System.out.print("Ingrese dimension n: ");
        n = leer.nextInt();
        System.out.print("Ingrese dimension m: ");
        m = leer.nextInt();

        System.out.println("INGRESE VALORES MATRIZ A");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("A[" + (i) + "," + (j) + "]= ");
                A[i][j] = leer.nextInt();
            }
        }

        System.out.println("INGRESE VALORES MATRIZ B");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("B[" + (i) + "," + (j) + "]= ");
                B[i][j] = leer.nextInt();
            }
        }

        //IMPRIMIENDO MATRICES A Y B
        System.out.println("======== MATRIZ A =========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + A[i][j]);
            }
            System.out.println();
        }

        System.out.println("====== MATRIZ B ========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + B[i][j]);
            }
            System.out.println();
        }
     
        //IMPRIMIENDO DIAGONAL PRINCIPAL MATRIZ A  Y B
        int DA = 0,suma=0, DB = 0;
        System.out.println("===========DIAGONAL PRINCIPAL MATRIZ A  Y B =============");
         for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
               if(i==j){
                    System.out.print("\t"+A[i][j]);
                    DA=DA+A[i][j];
               
               }
            }
        }
         System.out.println(" ---->> DA: "+DA);
       
         for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                if(i==j){
                    System.out.print("\t"+B[i][j]);
                    DB=DB+B[i][j];
             
               }
            }
        }
      System.out.println(" ---->> DB: "+DB);
   
      suma=DA+DB;
      System.out.println("la suma es :"+suma);
       
 }
}

LEER MÁS

Transpuesta de dos Matrices en java

import java.util.Scanner;
public class algoritmo_10_matriz {
    Scanner leer= new Scanner (System.in);
   
    public static void main(String[] args){
       algoritmo_10_matriz menu= new algoritmo_10_matriz();
       menu.menuGeneral();
    }
 
   public int menuGeneral(){
   int opcion;
   do{
       System.out.println("");
       System.out.println("===================================================");
       System.out.println("================= MENU DE OPCIONES ================");
       System.out.println("===== 1.SUMA DE MATRICES                       ====");
       System.out.println("===== 2.MULTIPLICACION DE MATRICES             ====");
       System.out.println("===== 3.TRANSPUESTA MATRIZ A^B                 ====");
       System.out.println("===== 4.SUMA DIAGONAL PRINCIPAL MATRIZ A^B     ====");
       System.out.println("===== 5.MAXIMO Y MINIMO MATRIZ A ^ B           ====");
       System.out.println("===== 6.COLUMNA IMPAR ^ FILAS PARES MATRIZ A^B ====");
       System.out.println("===== 7.SALIR                                  ====");
       System.out.println("===================================================");
       System.out.print("Ingrese una opcion: ");
       opcion=leer.nextInt();
 
       switch(opcion){
           case 1: SumadeMatriz(); break;
           case 2: MultiplicacionMatriz();break;
           case 3: TranspuestaMatriz();break;
           case 4: DiagonalPrincipalMatrices();break;
           case 5: MaximoMinimoMatriz();break;
           case 6: ColumnaImparFilaPar();break;
           case 7: System.out.println("................Saliendo del menu ..............");
               System.exit(0); break;
           default: System.out.println("Ingrese una opcion valida.......!!"); break;

       }
     
     
     
   }while(opcion != 8);
   return 0;
   }


public void TranspuestaMatriz(){

 int n, m, i, j;
        int A[][] = new int[10][10];
        int B[][] = new int[10][10];
     
        System.out.print("Ingrese dimension n: ");
        n = leer.nextInt();
        System.out.print("Ingrese dimension m: ");
        m = leer.nextInt();

        System.out.println("INGRESE VALORES MATRIZ A");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("A[" + (i) + "," + (j) + "]= ");
                A[i][j] = leer.nextInt();
            }
        }

        System.out.println("INGRESE VALORES MATRIZ B");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("B[" + (i) + "," + (j) + "]= ");
                B[i][j] = leer.nextInt();
            }
        }

        //IMPRIMIENDO MATRICES A Y B
        System.out.println("======== MATRIZ A =========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + A[i][j]);
            }
            System.out.println();
        }

        System.out.println("====== MATRIZ B ========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + B[i][j]);
            }
            System.out.println();
        }
     
        //IMPRIMIENDO TRANSPUESTA DE MATRICES
     
        System.out.println("===========TRANSUESTA MATRIZ A =============");
         for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + A[j][i]);
            }
            System.out.println();
        }

         System.out.println("===========TRANSUESTA MATRIZ B =============");
         for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + B[j][i]);
            }
            System.out.println();
        }

}

}

LEER MÁS

Multiplicación de matrices en java

import java.util.Scanner;
public class algoritmo_10_matriz {
    Scanner leer= new Scanner (System.in);
   
 
    public static void main(String[] args){
       algoritmo_10_matriz menu= new algoritmo_10_matriz();
       menu.menuGeneral();
    }
 
   public int menuGeneral(){
   int opcion;
   do{
       System.out.println("");
       System.out.println("===================================================");
       System.out.println("================= MENU DE OPCIONES ================");
       System.out.println("===== 1.SUMA DE MATRICES                       ====");
       System.out.println("===== 2.MULTIPLICACION DE MATRICES             ====");
       System.out.println("===== 3.TRANSPUESTA MATRIZ A^B                 ====");
       System.out.println("===== 4.SUMA DIAGONAL PRINCIPAL MATRIZ A^B     ====");
       System.out.println("===== 5.MAXIMO Y MINIMO MATRIZ A ^ B           ====");
       System.out.println("===== 6.COLUMNA IMPAR ^ FILAS PARES MATRIZ A^B ====");
       System.out.println("===== 7.SALIR                                  ====");
       System.out.println("===================================================");
       System.out.print("Ingrese una opcion: ");
       opcion=leer.nextInt();
 
       switch(opcion){
           case 1: SumadeMatriz(); break;
           case 2: MultiplicacionMatriz();break;
           case 3: TranspuestaMatriz();break;
           case 4: DiagonalPrincipalMatrices();break;
           case 5: MaximoMinimoMatriz();break;
           case 6: ColumnaImparFilaPar();break;
           case 7: System.out.println("................Saliendo del menu ..............");
               System.exit(0); break;
           default: System.out.println("Ingrese una opcion valida.......!!"); break;

       }
     
     
     
   }while(opcion != 8);
   return 0;
   }


public void MultiplicacionMatriz(){

    int n, m, i, j,k;
        int A[][] = new int[10][10];
        int B[][] = new int[10][10];
        int C[][] = new int[10][10];
        System.out.print("Ingrese dimension n: ");
        n = leer.nextInt();
        System.out.print("Ingrese dimension m: ");
        m = leer.nextInt();

        System.out.println("INGRESE VALORES MATRIZ A");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("A[" + (i) + "," + (j) + "]= ");
                A[i][j] = leer.nextInt();
            }
        }

        System.out.println("INGRESE VALORES MATRIZ B");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("B[" + (i) + "," + (j) + "]= ");
                B[i][j] = leer.nextInt();
            }
        }

        //IMPRIMIENDO MATRICES A Y B
        System.out.println("======== MATRIZ A =========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + A[i][j]);
            }
            System.out.println();
        }

        System.out.println("====== MATRIZ B ========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + B[i][j]);
            }
            System.out.println();
        }

        //MULTIPLICANDO LAS MATRICES A*B=C
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                for(i=1;i<=n;i++){
for(j=1;j<=n;j++){
C[i][j]=0;
for(k=1;k<=n;k++){
C[i][j]=(C[i][j]+(A[i][k]*B[k][j]));
}
}
}
            }
        }
        System.out.println("=========== MATRIZ MULTIPLICADA ==========");
        System.out.println("==== IMPRIMIENDO LA MATRIZ C =====");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + C[i][j]);
            }
            System.out.println();
        }


}

LEER MÁS

Suma de Matrices en Java

import java.util.Scanner;
public class algoritmo_10_matriz {
    Scanner leer= new Scanner (System.in);
   
 
    public static void main(String[] args){
       algoritmo_10_matriz menu= new algoritmo_10_matriz();
       menu.menuGeneral();
    }
 
 
   public int menuGeneral(){
   int opcion;
   do{
       System.out.println("");
       System.out.println("===================================================");
       System.out.println("================= MENU DE OPCIONES ================");
       System.out.println("===== 1.SUMA DE MATRICES                       ====");
       System.out.println("===== 2.MULTIPLICACION DE MATRICES             ====");
       System.out.println("===== 3.TRANSPUESTA MATRIZ A^B                 ====");
       System.out.println("===== 4.SUMA DIAGONAL PRINCIPAL MATRIZ A^B     ====");
       System.out.println("===== 5.MAXIMO Y MINIMO MATRIZ A ^ B           ====");
       System.out.println("===== 6.COLUMNA IMPAR ^ FILAS PARES MATRIZ A^B ====");
       System.out.println("===== 7.SALIR                                  ====");
       System.out.println("===================================================");
       System.out.print("Ingrese una opcion: ");
       opcion=leer.nextInt();
 
       switch(opcion){
           case 1: SumadeMatriz(); break;
           case 2: MultiplicacionMatriz();break;
           case 3: TranspuestaMatriz();break;
           case 4: DiagonalPrincipalMatrices();break;
           case 5: MaximoMinimoMatriz();break;
           case 6: ColumnaImparFilaPar();break;
           case 7: System.out.println("................Saliendo del menu ..............");
               System.exit(0); break;
           default: System.out.println("Ingrese una opcion valida.......!!"); break;

       }
     
     
     
   }while(opcion != 8);
   return 0;
   }
 
 
   public void SumadeMatriz(){
        int n, m, i, j;
        int A[][] = new int[10][10];
        int B[][] = new int[10][10];
        int C[][] = new int[10][10];
        System.out.print("Ingrese dimension n: ");
        n = leer.nextInt();
        System.out.print("Ingrese dimension m: ");
        m = leer.nextInt();

        System.out.println("INGRESE VALORES MATRIZ A");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("A[" + (i) + "," + (j) + "]= ");
                A[i][j] = leer.nextInt();
            }
        }

        System.out.println("INGRESE VALORES MATRIZ B");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("B[" + (i) + "," + (j) + "]= ");
                B[i][j] = leer.nextInt();
            }
        }

        //IMPRIMIENDO MATRICES A Y B
        System.out.println("======== MATRIZ A =========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + A[i][j]);
            }
            System.out.println();
        }

        System.out.println("====== MATRIZ B ========");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + B[i][j]);
            }
            System.out.println();
        }

        //SUMANDO LA MATRIZ C=A+B
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                C[i][j] = A[i][j] + B[i][j];
            }
        }
        System.out.println("=========== MATRIZ SUMA ==========");
        System.out.println("==== IMPRIMIENDO LA MATRIZ C =====");
        for (i = 1; i <= n; i++) {
            for (j = 1; j <= m; j++) {
                System.out.print("\t" + C[i][j]);
            }
            System.out.println();
        }
     
    }

LEER MÁS

Libro básico de Arduino: electrónica y programación

Libro básico de Arduino: electrónica y programación

Contenido:

Conocer el funcionamiento de las cosas es algo que el hombre se ha planteado desde el inicio de los tiempos; hoy en día nos enfrentamos a una realidad donde abundan la automatización, la domótica, la interacción de las personas con las máquinas, la electrónica, la mecánica y la programación.

Casi cualquier proceso que nos podamos imaginar tiene un porcentaje de dependencia de estas máquinas, por ejemplo: Tu despertador sonó a las 6am para que vinieras a la escuela o fueras al trabajo, esa máquina, reloj, trabajó durante toda la noche para al final avisarte que era hora de despertar.

El propósito de este libro es abordar el concepto de computación física que es la capacidad de interacción y comunicación de una máquina con los humanos, usando sensores y actuadores. Las decisiones de esto las va a tomar un microcontrolador que se encuentra ubicado en la placa Arduino. La tarjeta Arduino es el corazón del presente libro.

Libro básico de Arduino: electrónica y programación

Descargar | MEGA 

LEER MÁS

ARDUINO: Curso práctico de formación – Óscar Torrente Artero

ARDUINO: Curso práctico de formación – Óscar Torrente Artero

PDF| Español |7.5 MB

Contenido:

Introducción

Capítulo 1. Electrónica básica

Capítulo 2. Hardware Arduino

Capítulo 3. Software Arduino

Capítulo 4. Lenguaje Arduino

Capítulo 5. Librerías Arduino

Capítulo 6. Entradas y salidas

Capítulo 7. Sensores

Capítulo 8. Comunicación en red

ARDUINO: Curso práctico de formación – Óscar Torrente Artero

Descargar |  MEGA

LEER MÁS

En un arreglo se tiene -2, 5, 8, -9, 10, 15 y 4. calcule, independientemente, la suma de los elementos positivos y negativos en C++

//11. Escribir un programa que tras asignar los números, -2, 5, 8, -9, 10, 15 y 4 a un array calcule,
//independientemente, la suma de los elementos positivos y negativos.
#include <iostream>
using namespace std;

int main(int argc, char *argv[]) {
int A[10],n,i;
int suma=0;
int su=0;
cout<<"Ingrese N° de elementos al arreglo"<<endl;
cin>>n;
for(i=1;i<=n;i++){
cout<<"A["<<i<<"]= ";
cin>>A[i];
}
cout<<"\n\n";
cout<<"Mostrando el arreglo"<<endl;
      for(i=1;i<=n;i++){
 cout<<"\t"<<A[i];
 }
 cout<<"\n\n";

 for(i=1;i<=n;i++){

 if(A[i]>0){
 suma=suma+A[i];
 }else{
 su=su+A[i];
 }
}
 cout<<"la suma de los numeros positivos : "<<suma<<endl;
 cout<<"la suma de los numeros negativos : "<<su<<endl;


return 0;
}

LEER MÁS

Dado un arreglo lineal de números, sumar separadamente los números pares y los números impares en C++

#include <iostream>
using namespace std;

int main(int argc, char *argv[]) {
int A[10],n,i;
int suma=0,su=0;
cout<<"Ingrese N° de elementos al arreglo"<<endl;
cin>>n;

for(i=1;i<=n;i++){
cout<<"A["<<i<<"]=";
cin>>A[i];
}

cout<<"\n\n";
cout<<"Mostrando el arreglo"<<endl;
for(i=1;i<=n;i++){
cout<<"\t"<<A[i];
}
cout<<"\n\n";
for(i=1;i<=n;i++){
if(A[i]%2==0){
suma=suma+A[i];
}

if(A[i]%2==1){
su=su+A[i];
}
}

cout<<"la sumatoria de numeros pares es : "<<suma<<endl;
cout<<"la sumatoria de numeros impares es : "<<su<<endl;
return 0;
}

LEER MÁS

Algoritmo Recursivo que calcule el Máximo común divisor de dos números en C++

#include<iostream>
using namespace std;

int MCD(int a,int b){
if(a>=b && a%b==0){
return b;
}
    else{
return MCD(b,a%b);
}
}


int main(){

int n1,n2;
cout<<"Ingrese el primer numero :"<<endl;
cin>>n1;
cout<<"Ingrese el segundo numero :"<<endl;
cin>>n2;
cout<<endl<<"El Maximo Comun Divisor es :"<<MCD(n1,n2)<<endl;
return 0;

}

LEER MÁS

Algoritmo Recursivo que permita hacer una multiplicación, utilizando el método Ruso

#include <iostream>
using namespace std;
int mult_rusa(int A, int B);

int main(int argc, char *argv[]) {
int a,b;
cout<<"ingrese A"<<endl;
cin>>a;
cout<<"ingrese B"<<endl;
cin>>b;

cout<<"el resultado es:"<<mult_rusa(a,b)<<endl;
return 0;
}

int mult_rusa(int A, int B) {
if(A==1){
return (B);
}
if(A%2!=0){
return (B+mult_rusa( A/2 , B*2));
}
else{
return(mult_rusa( A/2 , B*2));
}                    
}

LEER MÁS

Algoritmo Recursivo invertir un numero en C++

#include <iostream>
#include <conio.h>
#include <math.h>
#include <stdlib.h>

using namespace std;

int menu(){
int op;
cout<<endl<<endl;
cout<<"========== MENU ==="<<endl;
cout<<" 1. Invertir Numero"<<endl;
cout<<"==================="<<endl;
cout<<"Ingrese una opcion : "<<endl;
cin>>op;

return op;
}


int invertirnumero(long int a, long int b=0){
if(a==0) return 0;
else{
b=a % 10;
a=a / 10;
cout<<b;
return invertirnumero(a,b);
}
}


int main(){

int x;
long int numero, resultado, b=0;

for(;;){

int op=menu();

switch(op){
case 1:
cout<<"Ingrese numero:"<<endl;
cin>>numero;
cout<<"el numero invertido es:"<<endl;
resultado=invertirnumero(numero,b);

break;

default: cout<<"la opcion ingresada no es valida";getch();
}
getch();
}
}

LEER MÁS

Algoritmo Recursivo Serie de Fibonacci en C++

#include <iostream>
using namespace std;
int fibonacci(int n);

int main(int argc, char *argv[]) {
int n;
cout<<"ingrese numero"<<endl;
cin>>n;

cout<<"el resultado es:"<<fibonacci(n)<<endl;
return 0;
}


int fibonacci(int a){
if((a==1 || a==2)){
return 1;
}
else{
return(fibonacci(a-1)+fibonacci(a-2));
}
}

LEER MÁS

Algoritmo Recursivo división por restas sucesivas en C++

#include <iostream>
using namespace std;
int division(int a, int b);

int main(int argc, char *argv[]) {
int n1,n2;
cout<<"ingrese N1"<<endl;
cin>>n1;
cout<<"ingrese N2"<<endl;
cin>>n2;

cout<<"el resultado es:"<<division(n1,n2)<<endl;
return 0;
}

int division (int a, int b) {
if(b > a) {
return 0;
}
else {
return division(a-b, b) + 1;
}
}

LEER MÁS

Método de ordenamiento Shell Sort en java

import java.util.Scanner;

/**
 *
 * @author johnel
 */
public class ShellSort {
   public static void main(String[] args){
    Scanner teclado = new Scanner(System.in);
    int Arreglo[]=new int [20];
        int numero,i,j,k,incremento,aux;
        System.out.print("Ingrese dimension del arreglo: ");
        numero=teclado.nextInt();
     
        for(i=1;i<=numero;i++){
            System.out.print("A["+i+"]= ");
            Arreglo[i]=teclado.nextInt();
        }
     
     
        incremento=numero/2;

while(incremento>0){
for(i=incremento+1;i<=numero;i++){
j=i-incremento;
while(j>0){
if(Arreglo[j]>=Arreglo[j+incremento]){
aux = Arreglo[j];
Arreglo[j] = Arreglo[j+incremento];
Arreglo[j+incremento] = aux;
}
else{
j=0;
}
j=j-incremento;
}
}
incremento=incremento/2;
}
     
     
     System.out.println("EL ARREGLO ORDENADO");
        for(i=1;i<=numero;i++){
            System.out.print(" "+Arreglo[i]);
         
        }
 
 
 
 
}
}

LEER MÁS

Método de Ordenamiento Selection Sort en java

import java.util.Scanner;

/**
 *
 * @author Johnel
 */
public class SelectionSort {
    public static void main(String[] args){
    Scanner teclado = new Scanner(System.in);
    int A[] = new int [20];
        int menor,indice,n,i,j;
        System.out.print("Ingrese dimension del arreglo: ");
        n=teclado.nextInt();
     
        for(i=1;i<=n;i++){
            System.out.print("A["+i+"]= ");
            A[i]=teclado.nextInt();
        }
     
        for(i=1;i<=n-1;i++){
menor=A[i];
indice=i;

for(j=i+1;j<=n;j++){
if(menor>A[j]){
menor=A[j];
indice=j;
}
}

A[indice]=A[i];
A[i]=menor;

}
     
        System.out.println("EL ARREGLO ORDENADO");
        for(i=1;i<=n;i++){
            System.out.print(" "+A[i]);
         
        }  
 
}

}

LEER MÁS

Método de Ordenamiento Insertion Sort en java

import java.util.Scanner;
public class InsertionSort {
    public static void main(String[] args){
    Scanner teclado = new Scanner(System.in);
    int B[]= new int [20];
    int i,j,aux;
     System.out.print("Ingrese dimension del arreglo: ");
     int numero=teclado.nextInt();
   
     for(i=1 ; i<=numero; i++){
         System.out.print("A["+i+"]= ");
         B[i]=teclado.nextInt();
     }
   
     for(i=2;i<=numero;i++){
aux=B[i];
j=i-1;
        while((j>=1) && (aux<B[j])){
          B[j+1]=B[j];
          j=j-1;
           }

B[j+1]=aux;
}
 
     System.out.println("EL ARREGLO ORDENADO");
     for(i=1 ; i<=numero; i++){
         System.out.print("\t"+B[i]);
        }
 
 
    }
}

LEER MÁS

Método de ordenamiento Shaker Sort en java

import java.util.Scanner;
public class ShakerSort {
    public static void main(String[] args){
      Scanner teclado = new Scanner(System.in);
        int  A[]=new int [20];
        int i, k, Der, Izq, Aux, N;
     
        System.out.print("Ingrese dimension del arreglo: ");
        N=teclado.nextInt();
                k=N;
Izq=2;
Der=N;
             
        for(i=1;i<=N;i++){
            System.out.print("A["+i+"]= ");
            A[i]=teclado.nextInt();
        }
     
        do{//inicio del ordenamiento
for(i=Der;i>=Izq;i--){//derecha a izquierda
if(A[i-1]>A[i]){
Aux=A[i-1];
A[i-1]=A[i];
A[i]=Aux;
k=i;
}
}
Izq=k+1;
for(i=Izq;i<=Der;i++)//izquierda a derecha
if(A[i-1]>A[i]){
Aux=A[i-1];
A[i-1]=A[i];
A[i]=Aux;
k=i;
}
Der=k-1;
}while(Izq<Der);//Fin del ordenamiento
     
        System.out.println("EL ARREGLO ORDENADO");
         for(i=1;i<=N;i++){
            System.out.print("\t"+A[i]);
         
        }
 
}
}

LEER MÁS

Ecuación de segundo grado en java

import java.util.Scanner;
public class EcuacionSegundoGrado
{
    public static void main(String[]args){
        Scanner leer = new Scanner(System.in); //se crea objeto tipo scanner
        System.out.println("Ingrese valores ax,bx,c separados por ',': ");
        String valores = leer.nextLine(); //obtiene los valores a,b,c separados por ','
        String [] numeros = valores.split(","); //separa los numeros
        int a = Integer.parseInt(numeros[0]); //variable a almacenada es trasformada a int
        int b = Integer.parseInt(numeros[1]); //variable b almacenada es trasformada a int
        int c = Integer.parseInt(numeros[2]); //variable v almacenada es trasformada a int
        //Obtien los valores x1,x2 de la ecuacion
        double x1 = (-b + Math.sqrt((b*b)-(4*a*c)))/(2*a);
        double x2 = (-b - Math.sqrt((b*b)-(4*a*c)))/(2*a);
        //imprime los valores
        System.out.println("La solucion de x1: "+x1);
        System.out.println("La solucion de x2: "+x2);
    }
}

LEER MÁS

Calcular el área de las figuras geométricas con funciones en java

import java.util.Scanner;
import java.lang.Math;

public class Geometricas {
    static int areacuadrado (int n1){
    return n1*n1;
    }
    static double areaCirculo(int r){
double PI=3.1416;
return  PI * Math.pow(r,2);
}
    static int areatriangulo(int a, int b){
    return (a*b)/2;
    }
    static int arearectangulo(int b , int h){
    return b*h ;
    }
    static int areapentagono(int p, int a){
    return (p*a) / 2;
    }
    static int arearombo(int D,int d){
         return (D*d)/2 ;
    }
    static int arearomboide(int b,int h){
    return b*h ;
    }
   static int areatrapecio (int B , int b , int h){

return ((B+b)/2)*h;
}

public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
int opcion=0;
do{
System.out.println();
System.out.println();
System.out.println(" ======== MENU DE OPCIONES ========= ");
System.out.println(" ___________________________________ ");
System.out.println(" ======== 1. Cuadrado      ========= ");
System.out.println(" ======== 2. Circulo       ========= ");
System.out.println(" ======== 3. Triangulo     ========= ");
System.out.println(" ======== 4. Rectangulo    ========= ");
System.out.println(" ======== 5. Pentagono     ========= ");
System.out.println(" ======== 6. Rombo         ========= ");
System.out.println(" ======== 7. Romboide      ========= ");
System.out.println(" ======== 8. Trapecio      ========= ");
System.out.println(" ___________________________________ ");
System.out.println(" Ingrese una opcion ");
opcion = teclado.nextInt();
switch (opcion){
case 1:
System.out.println("Ingrese el lado ");
int lado = teclado.nextInt();
   System.out.println(" EL AREA DEL CUADRADO ES :"+ areacuadrado(lado));
break;
        case 2:
        System.out.println("Ingrese el radio ");
       int radio = teclado.nextInt();
         System.out.println(" EL AREA DEL CIRCULO ES :"+ areaCirculo(radio));
break;
        case 3:
        System.out.println(" Ingrese la base ");
        int base = teclado.nextInt();
        System.out.println(" Ingrese la altura ");
        int altura = teclado.nextInt();
       
        System.out.println(" EL AREA DEL TRIANGULO ES :"+areatriangulo(base,altura));
break;
        case 4:
        System.out.println(" Ingrese la BASE ");
        int base_rec = teclado.nextInt();
        System.out.println(" Ingrese la ALTURA ");
        int altura_rec = teclado.nextInt();
        System.out.println(" EL AREA DEL RECTANGULO ES :"+arearectangulo(base_rec,altura_rec));
        break;
        case 5:
        System.out.println(" Ingrese el perimetro");
        int perimetro = teclado.nextInt();
        System.out.println("Ingrese el Apotema");
        int apotema= teclado.nextInt();
        System.out.println(" EL AREA DEL PENTAGONO ES :"+areapentagono(perimetro,apotema));
        break;
        case 6:
        System.out.println("Ingrese el Diagonal Mayor");
        int Diagonal_Ma=teclado.nextInt();
        System.out.println("Ingrese el Diagonal Menor");
        int Diagonal_Me=teclado.nextInt();
        System.out.println(" EL AREA DEL ROMBO ES :"+arearombo(Diagonal_Ma,Diagonal_Me));
        break;
        case 7:
        System.out.println("Ingrese la base");
        int base_r =teclado.nextInt();
        System.out.println("Ingrese la Altura");
        int altura_r =teclado.nextInt();
        System.out.println(" EL AREA DEL ROMBOIDE ES :"+arearomboide(base_r,altura_r));
break;
        case 8:
        System.out.println("INGRESE LA BASE MAYOR");
        int base_ma=teclado.nextInt();
        System.out.println("INGRESE LA BASE MENOR");
        int base_me=teclado.nextInt();
        System.out.println("INGRESE LA ALTURA");
        int altura_t=teclado.nextInt();
        System.out.println(" EL AREA DEL TRAPECIO ES :"+areatrapecio(base_ma,base_me,altura_t));
break;

}

}while(opcion!=9);
}

}

LEER MÁS

Método de ordenamiento burbuja en java

/*Ordene 4 números usando el método de ordenación por intercambio (burbuja)*/

import java.util.Scanner;
public class algoritmo_7_metodo_ordenamiento_burbuja {
    public static void main(String [] args){
     Scanner teclado= new Scanner(System.in);

     System.out.print("Ingrese dimension del arreglo: ");
     int tam=teclado.nextInt();
     int arreglo[]= new int [tam];
   
     //Ingresando Valores al arreglo
     for(int i=0 ; i<arreglo.length; i++){
         System.out.print("A["+i+"]= ");
         arreglo[i]=teclado.nextInt();
     }
   
     Burbuja(arreglo);

     //Mostrando el arreglo Ordenado
     System.out.println("===== ARREGLO ORDENADO ====");
     for(int i =0; i<arreglo.length;i++){
         System.out.print("\t"+arreglo[i]);
     }
   
    }
 
    //Metodo de ordenamiento burbuja
     static void Burbuja(int arreglo[]){
     int i,j,aux;
     for(i=0;i<arreglo.length;i++){
for(j=i+1;j<arreglo.length;j++){
if(arreglo[i]>arreglo[j]){
aux=arreglo[i];
arreglo[i]=arreglo[j];
arreglo[j]=aux;
}
}
}

     }
   
}
   

LEER MÁS