CRIBA DE ERATOSTENES

La criba de Eratóstenes es un algoritmo que permite hallar todos los números primos menores que un número natural dado N. Se forma una tabla con todos los números naturales comprendidos entre 2 y N y se van tachando los números que no son primos de la siguiente manera: Cuando se encuentra un número entero que no ha sido tachado, ese número es declarado primo, y se procede a tachar todos sus múltiplos. El proceso termina cuando el cuadrado del mayor número confirmado como primo es mayor que N.

Fuente: http://es.wikipedia.org/wiki/Criba_de_Erat%C3%B3stenes

Read More

INICIALIZAR MATRIZ EN LA DECLARACION (JAVA)

Inicializar matriz en la declaración

En Java es posible inicializar una matriz al declararla, tal y como sucede con los arreglos; esto se hace sin definir el número de renglones y columnas, colocando un operador de asignación y después entre llaves la lista de valores para cada renglón del arreglo, el arreglo separando con llaves para cada valor por columna, separado por comas, veamos los siguientes ejemplos:

double arreglo[][] = { {3.5, 5.4, -2.3 }, {22.3, 78.5, -9.4}};
char cadena[][] = {{‘a’, ‘g’, ‘u’, ‘a’}, {‘r’, ‘o’, ‘j’, ‘a’}} ;

En Java es posible saber el número de renglones de una matriz, solo escribiendo el nombre de la matriz un punto y la palabra length, también se puede saber el número de elementos de un renglón, dando el nombre del arreglo , el renglón entre corchetes y un punto y la palabra length, como se muestra en el siguiente ejemplo:



public class AplicacionMatrices2 {
    
    public static void main(String[] args) {
        int arreglo[][] = {{1,2,3}, {4,5,6}, {7,8,9}};
        
        for (int i=0; i<arreglo.length; i++) {
        for (int j=0; j<arreglo[0].length; j++) {
            System.out.print(" " + arreglo[i][j]  + " ");
        }
        System.out.println();
        }
    }
 }

El cual al ejecutar mostrará lo siguiente:

Es importante observar como se escriben los renglones por columna, recordando que se utiliza el print() para desplegar el valor, esto permitirá no cambiar de renglón, pero tampoco saldrá a la pantalla hasta encontrar un println(), el cual se hace después del ciclo de adentro que despliega todos los renglones de una columna.

Read More

ARREGLOS DE DOS DIMENSIONES I (JAVA)

¿Que es un arreglo de dos dimensiones?

Un arreglo de dos dimensiones es una colección de datos para una misma variable en dos dimensiones comúnmente llamados renglones y columnas.

Arreglo

12	-4	0	28	-3
-3	-5	2	189	-2
1	0	9	-4	12

Para poder guardar un valor u obtener alguno del arreglo de dos dimensiones (también llamado matriz) es ahora necesario utilizar dos dimensiones, el renglón y la columna.

Declaración de arreglos de dos dimensiones

Para declarar un arreglo de dos dimensiones se utiliza el siguiente formato:

tipo nombre_arreglo [][] = new tipo[ numero renglones][ numero columnas];

Donde tipo es el tipo de los datos que almacenará el arreglo de dos dimensiones. Es importante recordar que se pueden declarar arreglos de los tipos primitivos de Java (int, double, char, etc) o bien de tipos definidos por el usuario (Cuenta, Alumno, etc).

Tamaño representa la cantidad de casillas que se reservan para el arreglo. En Java todos los arreglos empiezan en el subíndice 0 y llegan al subíndice tamaño-1.

Por ejemplo:
int arr[][] = new int[5] [6]; // arreglo de 5 renglones y 6 columnas enteros
char cad[][] = new char[10] [5]; /* arreglo de 10 renglones por 5 columnas tipo                                                                               carácter*/

Uso e inicialización de los elementos del arreglo de dos dimensiones

Para usar los elementos individuales de un arreglo se usa el siguiente formato:

arreglo[subíndice-renglon] [subíndice-columna]

Como un elemento de un arreglo de dos dimensiones es también un dato, se puede usar como cualquier variable de ese tipo, debemos recordar que tanto el índice de renglón como el índice de columna toman como base el primer elemento cero:

int arr[][] = new int [2][5];
arr[3][4] = 12;
arr[1][0]= Integer.parseInt(t1.getText());
t2.setText("" + arr[0][1]);
arr[0][0] = arr[0][1] + arr[0][2];
int k = 2;


int l = 3
arr[k+1][l] = 20;


Ejemplo:

En este siguiente ejemplo, tenemos una aplicación que define un arreglo de enteros de dos dimensiones, con 3 renglones y 5 columnas, y los inicializa con el valor de 1 a 15, de acuerdo a cada renglón, empezando por 1 en el renglón 1, luego por 6 en el renglón 2 y 11 en el renglón 3. Después de inicializar la matriz, la despliega, desplegando los valores de un mismo renglón en la misma línea, como lo muestra la figura:

(/En construcción)

La aplicación es como se muestra a continuación:

public class AplicacionMatrices1 {

    public static void main(String[] args) {

        int arreglo[][] = new int [3][5];

        for (int i=0; i<3; i++) {

            for (int j=0; j<5; j++) {

                        arreglo [i][j] = i*5+j+1;                            

            }

        }

        for (int i=0; i<3; i++) {

            for (int j=0; j<5; j++) {

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

            }

            System.out.println();

        }

    }

 }

Read More

PALINDROMO EJERCICIO_1 (C++)

Bueno compañeros. Acá les dejo un algoritmo con su respectiva documentación que nos dice si un número es palindromo o no.

#include <iostream>
#include <conio.h>
#include <Math.h>
using namespace::std;
int num,cnum1,cnum2,i=0,j=1,k,cifraa,cifrab;
bool sw=true;
//ALGORITMO QUE DICE SI UN NUMERO ES PALINDROMO O NO
void main(){
//Se lee el numero
cout<<"Digite un numero entero: ";
cin>>num;
//Se saca el valor absoluto del numero ya que el signo es despreciable
cnum1=abs(num);
//Se saca el numero de cifras del numero
        while(cnum1>0){
                i++;
                cnum1=cnum1/10;
        }
//Volvemos a asignar la copia al numero original ya que se ha modificado debido al calculo de las cifras
cnum1=num;
//Comparamos hasta la mitad del numero y mientras que las cifras a comparar sean iguales
        while(j<=i/2 && sw==true){
                cnum2=num;
//Se saca la cifra mas a la derecha
                cifraa=cnum1%10;
//Un contador k para sacar la cifra mas a la izquierda
                 k=0;
//La formula i-j nos dice hasta donde se debe seguir reduciendo el numero para sacar la cifra mas a la izquierda
                         while(k<=i-j){
                                 cifrab=cnum2%10;
                                 cnum2=cnum2/10;
                                 k++;
                         }
//Ya teniendo las cifras, se comparan. Si son diferentes se cambia el switch a falso
                         if(cifraa!=cifrab){
                                 sw=false;
                         }
                cnum1=cnum1/10;
                j++;
        }
/*Si el switch es verdadero es porque el numero es palindromo o capicúa
Si es falso es porque no es palindromo o capicúa*/
        if (sw==true){
                cout<<"El numero "<<num<<" es palindromo.";
        }
        else{
                cout<<"El numero "<<num<<" no es palindromo.";
        }
    _getch();
}

Read More

APLICACIONES CON ARREGLOS (JAVA)

Supongamos que queremos utilizar una aplicación para poder tomar un arreglo y voltearlo en otro, es decir, supongamos que tenemos un arreglo con los números 1, 15, 17, 22 y 34 y los queremos cambiar al revés como 34, 22, 17, 15 y 1. La siguiente aplicación nos puede ayudar a comprender esto:

public class AplicacionArreglo3 {
public static void main(String[] args) {
int arreglo1[] = { 1, 15, 17, 22, 34 };
int arreglo2[] = new int[arreglo1.length];
for (int i = 0; i < arreglo1.length; i++) {
        arreglo2[arreglo1.length - i - 1] = arreglo1 [i];
}
System.out.println("Arreglo Inicial");
for (int i = 0; i < arreglo1.length; i++) {
        System.out.println("Elemento " + (i+1) + " = " + arreglo1[i]);
}
System.out.println("Arreglo Final");
for (int i = 0; i < arreglo2.length; i++) {
        System.out.println("Elemento " + (i+1) + " = " + arreglo2[i]);
}
}
}
Dicha aplicación muestra la siguiente salida:

Vemos como la clave de la asignación de cada elemento del arreglo 2 esta en hacer un poco de matemáticas, con la instrucción:

arreglo2[arreglo1.length - i - 1] = arreglo1 [i];

En esta instrucción al último índice de la posición le quitamos el valor de i que es nuestra variable índice que avanza hasta llegar al último, pero si hacemos un poco de sustitución y decimos arreglo1 tiene 5 elementos, cuando la i es cero, entonces arreglo.length – i – 1 nos da 4 que es realmente la última posición, ya que iría de 0 a 4. Si sustituimos ahora con i en 1, tendríamos 5 – 1 – 1 que sería 3 y así sucesivamente.

Contando las veces que se repite un número en un arreglo

Esto nos puede servir para cuando trabajamos con números, supongamos que tenemos la siguiente aplicación, en la cual tenemos un arreglo y buscamos dos números en el, tenemos que utilizar un ciclo para la búsqueda y si queremos contar las veces que se encuentra el número podemos utilizar un contador para cada uno, veamos la aplicación:

public class AplicacionArreglo4 {


public static void main(String[] args) {
int arreglo[] = { 1, 15, 17, 22, 34 , -5, 15, 22, 1};


int busca1 = 30; // numero 1 a buscar
int conta1 = 0; // contar cuantas veces aparece
int busca2 = 22; // numero 2 a buscar
int conta2 = 0; // contar cuantas veces aparece
for (int i = 0; i < arreglo.length; i++) {
if (busca1 == arreglo[i]) {
        conta1++;
}
if (busca2 == arreglo[i]) {
        conta2++;
}
}
System.out.println("Arreglo");
for (int i = 0; i < arreglo.length; i++) {
        System.out.println("Elemento " + (i+1) + " = " + arreglo[i]);
}
System.out.println("El numero " + busca1 + " aparece " + conta1 + " veces");
System.out.println("El numero " + busca2 + " aparece " + conta2 + " veces");
}
}


Dicha aplicación muestra el siguiente desplegado:

Observamos que el conta1 solo se incrementa si el valor buscado busca1 aparece en el arreglo, de la misma manera con el valor busca2, se utiliza conta2.

Juguemos ahora un poco con letras utilizando arreglos de caracteres, cambiando la aplicación quedaría como:

public class AplicacionArreglo5 {


public static void main(String[] args) {
char arreglo[] = { 'a', 't', 'e', 'n', 'i' , 'd', 'a', 's'};


char busca1 = 's'; // caracter 1 a buscar
int conta1 = 0; // contar cuantas veces aparece
char busca2 = 'a'; // caracter 2 a buscar
int conta2 = 0; // contar cuantas veces aparece
for (int i = 0; i < arreglo.length; i++) {
if (busca1 == arreglo[i]) {
        conta1++;
}
if (busca2 == arreglo[i]) {
        conta2++;
}
}
System.out.println("Arreglo");
for (int i = 0; i < arreglo.length; i++) {
        System.out.println("Elemento " + (i+1) + " = " + arreglo[i]);
}
System.out.println("El caracter " + busca1 + " aparece " + conta1 + " veces");
System.out.println("El caracter " + busca2 + " aparece " + conta2 + " veces");
}
}


Esta aplicación mostraría el siguiente desplegado:

Observamos entonces como un arreglo de caracteres puede ser manejado como un arreglo de números.

Utilizando los caracteres y usando el ejemplo de invertir los números de un arreglo a otro, podemos observar como se puede invertir un arreglo de caracteres en otro, veamos la siguiente aplicación:

public class AplicacionArreglo6 {


public static void main(String[] args) {
char arreglo1[] = { 'a', 't', 'e', 'n', 'i' , 'd', 'a', 's'};
char arreglo2[] = new char[arreglo1.length];


for (int i = 0; i < arreglo1.length; i++) {
        arreglo2[arreglo1.length - i - 1] = arreglo1 [i];
}
System.out.println("Palabra Inicial");
for (int i = 0; i < arreglo1.length; i++) {
        System.out.println("Caracter " + (i+1) + " = " + arreglo1[i]);
}
System.out.println();
System.out.println("Palabra Final");
for (int i = 0; i < arreglo2.length; i++) {
        System.out.println("Caracter " + (i+1) + " = " + arreglo2[i]);
}
}
}


Observando el desplegado de esta aplicación quedaría:

Read More