Scribd
Cargar
928 vistas16 páginas

Arrays en Java: Ejemplos y Técnicas

El documento presenta una serie de programas en Java que implementan diversas técnicas de programación, incluyendo la manipulación de arreglos, cálculo de factoriales, separación de números pares e impares, y eliminación de elementos repetidos. Cada programa incluye métodos para llenar, imprimir y procesar arreglos, así como la implementación de algoritmos de ordenamiento. Se destacan ejemplos prácticos que ilustran conceptos fundamentales de programación en Java.

Cargado por

Beastieux Zeroo
Derechos de autor
© Attribution Non-Commercial (BY-NC)
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd
928 vistas16 páginas

Arrays en Java: Ejemplos y Técnicas

El documento presenta una serie de programas en Java que implementan diversas técnicas de programación, incluyendo la manipulación de arreglos, cálculo de factoriales, separación de números pares e impares, y eliminación de elementos repetidos. Cada programa incluye métodos para llenar, imprimir y procesar arreglos, así como la implementación de algoritmos de ordenamiento. Se destacan ejemplos prácticos que ilustran conceptos fundamentales de programación en Java.

Cargado por

Beastieux Zeroo
Derechos de autor
© Attribution Non-Commercial (BY-NC)
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como PDF, TXT o lee en línea desde Scribd

TECNICAS DE PROGRAMACIÓN II

Ed. 03
JAVA
Codificado por sAfOrAs

Compilado con javac (jdk) y gcj(Sobre Linux)


1)
public class SyGSucesiones
{
sstatic int a[] = new int[100];

static void llenarArreglo()


{

for(int i=0;i<[Link];i++)
{
a[i]=(i+1);
}
}

static void arregloSucesivo()


{
int b=0;
for(int i=0;i<[Link];i++)
{
a[i]=b+a[i];
b=a[i];
}
}

static void imprimirArreglo()


{
for(int i=0;i<[Link];i++)
[Link](a[i]+" ");
S

[Link]("");
}

public static void main(String[] args)


{
llenarArreglo();
arregloSucesivo();
imprimirArreglo();
}
}
2)
public class SyGArrayDeFactorial{
static double arreglo[] = new double[25];

static void llenaArreglo(){

for(int i=0;i<[Link];i++){
arreglo[i]=factorial(i);
}
}

static double factorial(int num){


double factorial=0;

if(num==0)
factorial=1;
else if(num<0)
[Link]("no existe");
else if(num>0)
for(factorial=num;num>1;num--)
factorial*=(num-1);
return factorial;
}

static void imprimeArreglo(){


for(int i=0;i<[Link];i++)
[Link](arreglo[i]+" ");
[Link]("");
}

public static void main(String[] args){


llenaArreglo();
imprimeArreglo();
}
}
3)
public class SyGMoverParesImpares
{
static int MAX=100;
static int A[]=new int[MAX];
static int B[]=new int[MAX];
static int C[]=new int[MAX];
sstatic int x=0,y=0;

static void llenaArreglo()


{
for(int i=0;i<[Link];i++)
{
A[i]=(int)([Link]()*100+1);
separa(A[i]);
}
}

static void imprimeArreglo()


{
for(int i=0;i<[Link];i++)
{
[Link]("\t Todos ["+i+"] : "+A[i]);
[Link]("");
}
S
[Link]("\n----------------------------------------------\n");

for(int i=0;i<x;i++)
{
[Link]("\t Par ["+i+"] : "+B[i]);
[Link]("");
}
S
[Link]("\n----------------------------------------------\n");

for(int i=0;i<y;i++)
{
[Link]("\t Impar ["+i+"] : "+C[i]);
[Link]("");
}
}

static void separa(int n)


{
if(n%2==0)
{
B[x]=n; x++; ordenar(n,x);
}
else
{
C[y]=n;
y++;
ordenar(n,y);
}
}

static void ordenar(int n,int tam)


{
int temp=0;
if(tam>=2)
{
if(n%2==0)
{
for(int i=1;i<tam;i++)
{
for(int j=0;j<tam-i;j++)
{
if(B[j]>B[j+1])
{
temp=B[j];
B[j]=B[j+1];
B[j+1]=temp;
}
}
}
}
else
{
for(int i=1;i<tam;i++)
{
for(int j=0;j<tam-i;j++)
{
if(C[j]>C[j+1])
{
temp=C[j];
C[j]=C[j+1];
C[j+1]=temp;
}
}
}
}
}
}

public static void main(String[] args)


{
llenaArreglo();
imprimeArreglo();
}
}
4)
public class SyGSumaArray
{
static int f = 4;
static int c = 5;
static int [][]arreglo=new int[f][c];
static int positiv=0;
static int negativ=0;
static void llenaArreglo(){
for(int i=0;i<[Link];i++)
for(int j=0;j<[Link];j++)
arreglo[i][j]=(int)([Link]()*-50+1);
}

sstatic void sumaDeElementos(){

for(int i=0;i<f;i++){
ffor(int j=0;j<c;j++){
if(arreglo[i][j]>=0)
positiv++;
else
negativ++;
}
}
}

static void imprime(){


for(int i=0;i<f;i++){
for(int j=0;j<c;j++){
[Link]("["+i+"]["+j+"] : "+arreglo[i][j]);
[Link]("");
}
}
}

static void mostrarElementos(){


[Link]("Positivos: "+positiv);
[Link]("Negativos: "+negativ);
[Link]("Total: "+(negativ+positiv));
}

public static void main(String[] args){


llenaArreglo();
imprime();
sumaDeElementos();
mostrarElementos();
}

}
5)
public class SyGRellenaArray5
{

static int a1[][]=new int[10][10];


static int a=1;
static void rellenaraleatorios()
{
for(int i=0;i<[Link];i++)
{
ffor(int j=0;j<[Link];j++)
{
a1[i][j]=a;
a++;
}
}
}

static void imprimir()


{
for(int i=0;i<[Link];i++)
{
ffor(int j=0;j<[Link];j++)
{
[Link](a1[i][j]+"\t");
if(a1[i][j]%10==0 && a1[i][j]!=0)
[Link]("");
}
}
}

public static void main(String[] args)


{
rellenaraleatorios();
imprimir();
[Link]("");
}
}
6)
public class SyGRellenaArray6
{

static int a1[][]=new int[10][10];


static int a=0,j=0,b=1;
static void rellenaraleatorios()
{
for(int i=0;i<[Link];i++)
{
f
for(j=0;j<[Link];j++)
{
a1[i][j]=a+b;
a=a+b;
}
b++;
a=0;
}
}

static void imprimir()


{
for(int i=0;i<[Link];i++)
{
ffor(int j=0;j<[Link];j++)
{
[Link](a1[i][j]+"\t");
if(j!=0 && j%9==0)
[Link](" ");
S
}
}
}

public static void main(String[] args)


{
rellenaraleatorios();
imprimir();
[Link]("");
}
}
7)
public class SyGOrdenaArrayParImpar
{
sstatic int [][]arreglo=new int[2][5];

static int x=0,y=0,z=0;


static void llenaArreglo()
{
for(int i=0;i<[Link];i++)
{
for(int j=0;j<arreglo[i].length;j++)
{
z=(int)([Link]()*100+1);
if(z%2==0)
{
arreglo[0][j]=z;
x++;
}
else
{
arreglo[1][j]=z;
y++;
}
}
}
}

static void imprime()


{
[Link]("Superior - Pares");
for(int i=0;i<[Link];i++)
{
for(int j=0;j<arreglo[i].length;j++)
{
[Link]("Arreglo["+i+"]["+j+"] : "+arreglo[i][j]);
[Link]("");
}
i
if(i<[Link]-1)
[Link]("Inferior - Impares");
S
}

public static void main(String[] args)


{
llenaArreglo();
imprime();
}

}
8)
public class SyGContarElementosRepetidos{
static int A=10;
static int B=20;
static int vectorA[]=new int[A];
static int vectorB[]=new int[B];
sstatic int elemA=0;
static int elemB=0;
static int z=0;
static void llenaArreglo(){
for(int i=0;i<[Link];i++){
vectorA[i]=(int)([Link]()*100+1);
}

for(int i=0;i<[Link];i++){
vectorB[i]=(int)([Link]()*100+1);
}

static void compara(){


for(int i=0;i<[Link];i++){
for(int j=0;j<[Link];j++){
if(vectorA[i]==vectorB[j])
elemA++;
}
[Link]("El elemento "+vectorA[i]+" se presenta
"+elemA+" veces en B");
elemA=0;
}
}

static void imprimir(){


for(int i=0;i<[Link];i++){
[Link]("A"+"["+i+"]= "+vectorA[i]+"\n");
}
for(int i=0;i<[Link];i++){
[Link]("B"+"["+i+"]="+vectorB[i]+"\n");
}
}

public static void main(String[] args){


llenaArreglo();
imprimir();
compara();
}

}
9)
public class SyGVoltearArray
{

static int arreglo[]=new int[25];


static void rellenar(int x[])
{
ffor(int i=0;i<[Link];i++)
{
x[i]=(int)([Link]()*100+1);
}
}

static void imprimir(int x[])


{
for(int i=0;i<[Link];i++)
{
S
[Link]("A"+"["+i+"]="+x[i]+"\t");

}
S
[Link](">>>>>>>>>>>>>>>");

static void invertir(int arreglo[])


{
int ar1=0,ar2=0;
for(int i=0;i<[Link]/2;i++){
ar1=arreglo[i];ar2=arreglo[[Link]-1-i];
arreglo[[Link]-i-1]=ar1;arreglo[i]=ar2;
}
}

public static void main(String[] datos)


{
rellenar(arreglo);
imprimir(arreglo);
invertir(arreglo);
imprimir(arreglo);
}
}
10)
import [Link];

public class SyGELiminaCaracteresNulos{

static void eliminaEspacio(String sTexto, String sCadenaSinBlancos){

for (int x=0; x < [Link](); x++) {


if ([Link](x) != ' ')
sCadenaSinBlancos += [Link](x);
}

sCadenaSinBlancos = "";

StringTokenizer stTexto = new StringTokenizer(sTexto);

while ([Link]())
sCadenaSinBlancos += [Link]();

[Link](sCadenaSinBlancos);
}

public static void main(String[] args){

String sTexto = "1 2 3 4 5 6 7 8 9 10";


[Link](sTexto);
String sCadenaSinBlancos = "";

eliminaEspacio(sTexto,sCadenaSinBlancos);
}

}
11)
public class SyGEliminaElementosRepetidos{
public static void main(String[] args)
{
SyGELiminaCaracteresNulos cadena= new SyGELiminaCaracteresNulos();
char[] arraycar={'p','a','j','a','r','r','a','c','o'};
String sCadenaSinBlancos="";
[Link](arraycar);

for(int i=0;i<[Link];i++){
for(int j=0;j<[Link]-1;j++){
if(i!=j){
if(arraycar[i]==arraycar[j]){
arraycar[j]=' ';
}
}
}
}

String s = new String(arraycar);


[Link](s,sCadenaSinBlancos);
}

}
12)
public class SyGFusionarVectores
{
static int MAX=20;
static int MAX2=MAX*2;
static int A[]=new int[MAX];
static int B[]=new int[MAX];
static int C[]=new int[MAX2];

static void llenaArreglo(int arreglo[])


{
for(int i=0;i<[Link];i++)
{
int ban;
do{
arreglo[i]=(int)([Link]()*100+1);
ban=noDuplicar(arreglo,arreglo[i],i);
}while(ban==1);
}
}

static int noDuplicar(int arreglo[], int numero, int longitud)


{
int ban=0;
for(int i=0;i<longitud;i++)
{
if(numero==arreglo[i])
{ban=1;break;}
else
ban=0;
}
return ban;
}

static void ordenar(int arreglo[])


{
int temp=0;
for(int i=1;i<[Link];i++)
{
for(int j=0;j<[Link]-i;j++)
{
if(arreglo[j]>arreglo[j+1])
{
temp=arreglo[j];
arreglo[j]=arreglo[j+1];
arreglo[j+1]=temp;
}
}
}
}

static void juntarArreglos()


{

int j=0,ban=0,cant=0,k=0,m=0,v=1;
for(int i=0;i<[Link];i++)
{
C[i]=A[j];
ban=noDuplicar(C, C[i], i);
C[i+1]=B[j];
ban=noDuplicar(C, C[i+1], (i+1));

i++;
j++;
}
ordenar(C);
cant=([Link]);
for(int i=0;i<cant-1;i++)
{
if(C[i]==C[i+1])
{ k=i; m++;}

for(int l=k;l<cant-1;l++)
{
C[l]=C[l+1];
}
}

while(C[cant-v]==C[cant-v-1])
{
C[MAX2-v]=0;
v++;
}
}

static void mostrar(int arreglo[],String n)


{
for(int i=0;i<[Link];i++)
{
[Link](n+"["+i+"] : "+arreglo[i]);
[Link]("");
}
[Link]("\n");
}

public static void main(String[] args)


{

llenaArreglo(A);
llenaArreglo(B);
ordenar(A);
ordenar(B);
mostrar(A,"A");
mostrar(B,"B");
juntarArreglos();
mostrar(C,"C");
}
}

También podría gustarte