1. Realizar un programa que reciba un arreglo de enteros e imprima la suma de sus elementos.

public class SumaArreglos {

public void Suma(int[] arreglo){

int suma = 0;

for (int i=0;i<arreglo.length;i++){

suma += arreglo[i];

System.out.println(suma);

public static void main(String[] args) {

int array[] = {10,1,23,4};

SumaArreglos i = new SumaArreglos();

i.Suma(array);

2. Realizar un programa que imprima un arreglo de enteros de forma invertida.

public class ImprimirArregloInvertido {

public void Inversion(int arreglo[]){

int i;

for(i = arreglo.length-1; i>=0; i--){

System.out.println(arreglo[i]);

public static void main(String[] args) {

ImprimirArregloInvertido o = new ImprimirArregloInvertido();

int array[] = {10,1,23,4};

o.Inversion(array);
 }

3. Realizar un programa que imprima una matriz de enteros de forma invertida.

public class ImprimirMatrizInvertida {

public void matriz(int matriz[][]){

int i,a;

for ( i = matriz.length-1; i >= 0;i--){

for (a = matriz.length-1; a >= 0;a--){

System.out.print(matriz[i][a]+" ");

System.out.println();

public static void main(String[] args) {

ImprimirMatrizInvertida obj = new ImprimirMatrizInvertida();

int m[][] = {{1,2,3},{4,5,6},{7,8,9}};

obj.matriz(m);

4. Realizar un programa que tome dos arreglos de enteros, los unifique e imprima los valores
ordenados. (Investigar método de ordenación Bubble Sort).

public class ArreglosUnificados {

public void Unificacion(int PrimerArreglo[],int SegundoArreglo[]){

int SumaArreglo[] = new int[PrimerArreglo.length + SegundoArreglo.length];

int a = 0;

for (int i = 0;i<PrimerArreglo.length;i++){

SumaArreglo[a] = PrimerArreglo[i];

a++;
 }

for (int i = 0;i<SegundoArreglo.length;i++){

SumaArreglo[a] = SegundoArreglo[i];

a++;

for (int v1 = 0;v1<(PrimerArreglo.length + SegundoArreglo.length)-1;v1++){

for(int v2 = 0;v2<(PrimerArreglo.length + SegundoArreglo.length)-1;v2++){

if (SumaArreglo[v2]>SumaArreglo[v2+1]){

int auxiliar;

auxiliar = SumaArreglo[v2];

SumaArreglo[v2] = SumaArreglo[v2 + 1];

SumaArreglo[v2 + 1] = auxiliar;

for (int i =0;i <(PrimerArreglo.length + SegundoArreglo.length);i++){

System.out.print(SumaArreglo[i]+" ");

public static void main(String[] args) {

ArreglosUnificados obj = new ArreglosUnificados();

int PrimerArreglo [] = {80,10,70};

int SegundoArreglo [] = {20,60,30,70,40};

obj.Unificacion(PrimerArreglo, SegundoArreglo);

}
5. Realizar un programa con un método que reciba un arreglo de enteros y lo llene con valores
aleatorios. Un método que reciba un arreglo y ordene el arreglo de manera descendente y otro
método que lo ordene de manera ascendente utilizando Quick Sort.(Investigar el método de
ordenación Quick Sort).

public class QuickSort {

public int[] Ascendente(int[]array){

return Ascendente(array, 0, array.length-1);

public int[] Descendente(int[]array){

return Descendente(array,0, array.length-1);

public int[] Ascendente(int[] array,int primero,int ultimo){

if(primero>=ultimo){

return array;

int i=primero, j= ultimo;

if(primero!=ultimo){

int pivote,aux;

pivote = primero;

while(primero!=ultimo){

String imp= "";

for(int ite= 0;ite<array.length;ite++){

if(ite!=array.length-1){

imp += array[ite]+",";

}else

imp += array[ite]+"";
 }

System.out.println(imp);

while(array[ultimo]>=array[pivote] && primero<ultimo){

ultimo--;

while(array[primero]<array[pivote] && primero<ultimo){

primero++;

if(ultimo!=primero){

aux = array[ultimo];

array[ultimo] = array[primero];

array[primero] = aux;

if(ultimo==primero){

Ascendente(array,i,primero-1);

Ascendente(array,primero+1,j);

else

return array;

return array;

public int[] Descendente(int[] array,int primero,int ultimo){

if(primero>=ultimo){

return array;
}

int i=primero, j= ultimo;

if(primero!=ultimo){

int pivote,aux;

pivote = primero;

while(primero!=ultimo){

String imp= "";

for(int ite=array.length-1;ite>=0;ite--){

if(ite!=array.length-1){

imp += array[ite]+" ";

}else

imp += array[ite]+" ";

System.out.println(imp);

while(array[ultimo]>=array[pivote] && primero<ultimo){

ultimo--;

while(array[primero]<array[pivote] && primero<ultimo){

primero++;

if(primero!=primero){

aux = array[ultimo];

array[ultimo] = array[primero];

array[primero] = aux;

if(primero==ultimo){

Descendente(array,i,primero-1);

Descendente(array,primero+1,j);
 }

else

return array;

return array;

public static void main(String[] args) {

QuickSort i = new QuickSort();

QuickSort a = new QuickSort();

int n1,n2,n3,n4,n5;

n1 = (int)(Math.random()*50);

n2 = (int)(Math.random()*40);

n3 = (int)(Math.random()*100);

n4 = (int)(Math.random()*60);

n5 = (int)(Math.random()*20);

int arreglo[]= {n1,n2,n3,n4,n5};

System.out.println("Organizado de manera Ascendente");

a.Ascendente(arreglo);

System.out.println("Organizado de manera Descendente");

i.Descendente(arreglo);

6.Realizar un programa que tenga un método que reciba dos matrices cuadradas y que retorne
la matriz resultante de la suma de ambas.
public class MatrizRaiz {

public int SumaMatriz(int [][] matriz1, int[][] matriz2){

int a,b,aux1 = 0,aux2 = 0;

for(a = 0;a < matriz1.length;a++){

for(b = 0;b <matriz1[0].length;b++){

aux1 += matriz1[a][b];

for(a = 0;a < matriz2.length;a++){

for(b = 0;b <matriz2[0].length;b++){

aux2 += matriz2[a][b];

return aux1 + aux2;

public static void main(String[] args) {

MatrizRaiz objeto = new MatrizRaiz();

int[][] matriz1 = {{48,9},{20,69}};

int matriz2[][] = {{16,70,58},{47,3,25},{153,24,86}};

System.out.print(objeto.SumaMatriz(matriz1, matriz2));