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

OPERACIONES CON ARREGLOS DE UNA DIMENSION (JAVA)

Utilizar un arreglo para hacer operaciones con el, en la mayoría de las veces implica el uso de la instrucción for, pues para poder tomar o actualizar cada elemento del arreglo, es necesario utilizar índice, y es por esto que el for es la instrucción ideal.

Por ejemplo, como se vio en arreglos de una dimensión, para inicializar un arreglo ya una vez definido podemos utilizar:

int arreglo[] = new int [10];
     for (int i=0; i<10; i++) {
          arreglo [i] = i;
     }

Pero también podemos utilizar la variable length, la cual es definida para todo arreglo en Java, y esta representa el número máximo de posiciones en el arreglo, es decir para el ejemplo anterior quedaría como:

int arreglo[] = new int [10];
     for (int i=0; i < arreglo.length; i++) { 
          arreglo [i] = i; 
     } 

Al hacer operaciones con arreglos es muy común que utilicemos también una constante para definir el máximo valor a utilizar en el arreglo, es decir para el ejemplo anterior quedaría como: 

int final MAX = 10; 
int arreglo[] = new int [MAX]; 
     for (int i=0; i < MAX; i++) { 
          arreglo [i] = i; 
     } 

Donde MAX es una constante (definida así al usar la cláusula final) que valdrá 10 durante la ejecución del método, clase o parte donde se encuentre definida. 

Sacando el mayor de un arreglo 

Cuando deseamos obtener el valor mayor de todos los valores definidos en un arreglo, debemos recorrer todo el arreglo y utilizar una variable que nos ayude en esta comparación. La mejor manera de inicializar esta variable es utilizar el primer valor del arreglo, por ejemplo: 

int mayor = arreglo[0]; // se toma el primer valor como el mayor 
// se revisa cada elemento en el arreglo empezando por el segundo 
     for (int i=1; i < arreglo.length; i++) { 
          // si el elemento del arreglo es mayor 
          if (arreglo[i] > mayor) {
               mayor = arreglo[i]; // cambiamos el valor del mayor
          }
     }
     System.out.println(“El valor mayor es “ + mayor);


Tomando el índice en el que se encuentra

Para hacer esto definimos otra variable, la cual debe empezar con 1 y si el valor del arreglo es mayor, además de hacer el cambio de mayor, actualizamos la posición de donde se encontró el mayor, el ejemplo quedaría como:

int posición = 0;
int mayor = arreglo[0]; // se toma el primer valor como el mayor
// se revisa cada elemento en el arreglo desde el segundo
     for (int i=1; i < arreglo.length; i++) { 
          // si el elemento del arreglo es mayor 
          if (arreglo[i] > mayor) {
               mayor = arreglo[i]; // cambiamos el valor del mayor
               posicion = i; // se actualiza la posicion
          }
     }
     System.out.println(“El valor mayor es “ + mayor);
     System.out.println(“Y esta en la posicion “ + (posición+1));

Si queremos saber en que posición se encontró el mayor valor, entonces debemos utilizar un índice, el cual empieza en 0 (si es que tomamos como referencia inicial el primer valor) y después al detectar que el valor del arreglo es mayor, se hace el cambio con mayor y se actualiza la posición, al desplegar la posición le añadimos uno mas, ya que empieza desde cero.

Sacando el menor de un arreglo y su posición

Para obtener el valor menor, solo se cambia la comparación y en lugar de comparar contra mayor, solo se compara contra menor, el ejemplo lo vemos como sigue:

int posición = 0;
int menor = arreglo[0]; // se toma el primer valor como el menor
// se revisa cada elemento en el arreglo desde el segundo
     for (int i=1; i < arreglo.length; i++) {
          // si el elemento del arreglo es menor
          if (arreglo[i] < menor) {
               menor = arreglo[i]; // cambiamos el valor del menor
               posicion = i; // se actualiza la posicion
          }
     }
     System.out.println(“El valor menor es “ + menor);
     System.out.println(“Y esta en la posicion “ + posicion);


Obteniendo el promedio del arreglo

Para obtener el promedio de un arreglo, se debe de sumar los elementos y dividir entre cuantos sean, el ejemplo lo vemos como sigue:

double promedio;
double suma = 0; // se inicializa la suma en cero
// se tomara cada elemento para sumarlo
     for (int i=0; i < arreglo.length; i++) {
          suma += arreglo[i];
     }
     promedio = suma / arreglo.length;
     System.out.println(“El promedio es “ + promedio);

Read More

EJEMPLO_1 ARREGLOS (APPLET JAVA)

Es muy sencillo tomar datos y agregarlos a un arreglo, como lo puede mostrar la siguiente aplicación, este applet, tomará un dato de texto y lo añadirá en un arreglo de números, además desplegará lo que tiene el arreglo en memoria, para ser desplegado en el texto de área.

import java.awt.*;

import java.applet.*;

import java.awt.event.*;

// <applet width="400" height="200" code="AppletArreglos1"></applet>

public class AppletArreglos1 extends Applet implements ActionListener{

                Label l1, l2;

                Button b1, b2,b3,b4;     

                TextField t1;

                TextArea ta1;

                int arreglo[];

                int conta;

             public AppletArreglos1() {

                                     l1 = new Label("Dato a Añadir");

                                     l2 = new Label("Texto para ver Arreglo");

                                     t1 = new TextField();

                                     ta1 = new TextArea(10,12);

                                     b1 = new Button("Añade");

                                     b2 = new Button("Muestra Vector");

                                     b3 = new Button("Limpia Vector");

                                     b4 = new Button("Limpia Campos");

                                     add(l1);

                                     add(t1);

                                     add(l2);

                                     add(ta1);

                                     add(b1);

                                     add(b2);

                                    add(b3);

                                     add(b4);

                                     b1.addActionListener(this);

                                     b2.addActionListener(this);

                                     b3.addActionListener(this);

                                     b4.addActionListener(this);

                                     arreglo = new int[100];

                                     conta=0;

                }

                public void actionPerformed(ActionEvent ae) {

                    if (ae.getSource() == b1) {

                        if (conta > arreglo.length) {

                            ta1.setText("No se puede añadir otro elemento");

                        }

                        else {

                            arreglo[conta++] = Integer.parseInt(t1.getText());

                            t1.setText("");   

                        }

                     }

                     if (ae.getSource() == b2) {

                           ta1.setText("");

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

                               ta1.append("" + arreglo[i] + "\n");

                           }

                     }

                     if (ae.getSource() == b3) {

                           conta = 0;

                           arreglo = new int[100];

                     }

                     if (ae.getSource() == b4) {

                           t1.setText("");

                           ta1.setText("");

                     }

                }

}


La cual se visualiza asi:

 

De la aplicación anterior podemos se observar que aunque length es el número de elementos en el arreglo, solo se utiliza conta en el ciclo para desplegar, ya que esta variable nos dice cuantos elementos se han introducido al arreglo.

Read More