Ejercicio crear clase "Coordenada"

Crear la clase Coordenada que tendrá como atributos dos float para indicar la posición y un atributo estático que será la unidad de medida.

Además tendrá funciones para poder desplazarse, una función toString() y una función distancia, que recibe otro objeto Coordenada y devuelve la distancia entre las dos coordenadas.

public class Coordenada {
    public float x;
    public float y;
    public static String unidad;
    @Override
    public String toString() {
        return("("+x+" "+unidad+", "+y+" "+unidad+")");
    }
    public float distancia(){
        float dist;
        dist = (float)Math.sqrt((x*x)+(y*y));
        return(dist);
    }
    public void arr(){
        y = y+1;
    }
    public void abj(){
        y = y-1;
    }
    public void der(){
        x = x+1;
    }
    public void izq(){
        x = x-1;
    }
}

Ejercicio crear clase "Ficha"

Crear una clase llamada Ficha, con los siguientes atributos:

• HOMBRE. De tipo char, estático y constante (público).
• MUJER. De tipo char, estático y constante (público).
• nombre. De tipo String (público).
• edad. De tipo entero (público).
• sexo. De tipo char (público).
• dni. De tipo long (público).

public class Ficha {
    public static final char HOMBRE = 'H';
    public static final char MUJER = 'M';
    public String nombre;
    public int edad;
    public char sexo;
    public long dni; //sin letra
}

Realizar un programa para probar la clase anterior que pida los datos de varias fichas (utilizando una tabla de Ficha) al usuario. Además, el programa tendrá dos funciones estáticas:

1. ordenar(Ficha[] f). Recibe una tabla de objetos Ficha y la ordena por edad.
2. mostrar(Ficha f). Muestra los datos que contiene el objeto Ficha que recibe.

public class PruebaFicha {
    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        Ficha[] f = new Ficha[3];
        String aux;
        int pos;
        for (pos=0; pos<f.length; pos++){
            System.out.println("FICHA "+(pos+1));
            f[pos] = new Ficha();
            System.out.print("Nombre: ");
            f[pos].nombre = entrada.nextLine();
            System.out.print("Edad: ");
            f[pos].edad = entrada.nextInt();
            System.out.print("DNI: ");
            f[pos].dni = entrada.nextLong();
            entrada.nextLine();
            System.out.print("Sexo (H/M): ");
            aux = entrada.nextLine();
            if(aux.equals("H"))
                f[pos].sexo=Ficha.HOMBRE;
            else
                f[pos].sexo=Ficha.MUJER;
        }
        ordenar(f);
        System.out.println();
        for (pos=0; pos<f.length; pos++){
            mostrar(f[pos]);
        }
    }
    public static void ordenar(Ficha[] f) {
        int ini, fin, i;
        boolean intercambio;
        Ficha aux; //no hace falta iniciarlo
        ini=0;
        fin=f.length - 1;
        intercambio = true;
        while (ini<fin & intercambio){
            intercambio=false;
            for(i=ini; i<fin; i++){
                if (f[i].edad > f[i+1].edad){
                    aux = f[i];
                    f[i] = f[i+1];
                    f[i+1] = aux;
                    intercambio = true;
                }
            }
            fin--;
            if (intercambio){
                intercambio = false;
                for(i=fin-1; i>=ini; i--){
                    if (f[i].edad > f[i+1].edad){
                        aux = f[i];
                        f[i] = f[i+1];
                        f[i+1] = aux;
                        intercambio = true;
                    }
                }
            }
            i++;
        }
    }
    public static void mostrar(Ficha f1) {
        System.out.print("Nombre: "+f1.nombre);
        System.out.println();
        System.out.print("Edad: "+f1.edad);
        System.out.println();
        System.out.print("DNI: "+f1.dni);
        System.out.println();
        if (f1.sexo == Ficha.MUJER)
            System.out.print("Sexo: MUJER");
        else
            System.out.print("Sexo: HOMBRE");
        System.out.println();
        System.out.println();
    }
}

Ejercicio crear clase "TipoTexto"

Crear una nueva clase llamada TipoTexto, cuyos atributos serán:

• frase. Tipo String (Público).
• numLetras. Tipo entero (Público).

public class TipoTexto {
    public String frase;
    public int numLetras;

}

Realizar un programa que cree un objeto de la clase "TipoTexto" y que le asigne una frase cualquiera a su atributo "frase". El programa tendrá una función que contará las letras de la frase y guardará ese número en el atributo "numLetras".

public class PruebaTipoTexto {
    public static void main(String[] args) {
        TipoTexto t = new TipoTexto();
        t.frase = "Pepe vive en la ciudad de La Laguna...";
        cuentaLetras(t);
        System.out.println(t.numLetras);
    }
    public static void cuentaLetras(TipoTexto text) {
        int pos, contador=0;
        for (pos=0; pos<text.frase.length(); pos++){
            if (Character.isLetter(text.frase.charAt(pos)))
                contador++;
        }
        text.numLetras = contador;
    }
}

Ejercicio sustituir valores de tabla

Realizar una función que reciba 3 parámetros:

1. Tabla de enteros.
2. Número entero que estará en esa tabla (puede no estar).
3. Número por el que queremos sustituir el anterior en la tabla.

La función devolverá un número entero que indicará el número de sustituciones que se han realizado y lanzará IllegalArgumentException si la tabla está vacía.

Se añade el programa principal con el que se probó la función.

public class Sustituir {
    public static void main(String[] args) {
        int[] tabla={3, 6, 44, 3, 12, 3, 3, 3, 33, 51, 3};
        int numA=3, numB=13;
        int veces;
        veces = sustituir(tabla, numA, numB);
        System.out.println(veces + " sustituciones.");
    }
    public static int sustituir(int[] t, int a, int b) {
        int i, contador=0;
        if (t==null)
            throw new IllegalArgumentException("La tabla está vacía");
        for (i=0; i<t.length; i++){
            if (t[i] == a){
                t[i] = b;
                contador++;
            }
        }
        return contador;
    }
}

Ejercicio número en un rango

Dado un rango entre dos números enteros, realizar una función que reciba estos dos números y pida al usuario que introduzca un número del rango. el programa seguirá pidiendo el número hasta que el usuario introduzca un número válido.
Se añade el programa principal con el que se probó la función.

public class Rango {
    public static void main(String[] args) {
        int desde, hasta, resultado;
        desde = 1;
        hasta = 15;
        System.out.println("Numero entre "+desde+" y "+hasta);
        resultado = leerRango(desde, hasta);
    }
    public static int leerRango(int ini, int fin) {
        Scanner entrada = new Scanner(System.in);
        int numero=0;
        boolean valido;
        do{
            try{
                numero = entrada.nextInt();
                if (numero < ini | numero > fin)
                    valido = false;
                else
                    valido = true;
            }
            catch(InputMismatchException e){
                valido = false;
            }
            entrada.nextLine();
        }while (!valido);
        return numero;
    }
}

Ejercicio trocear tabla

Dada una tabla de números float, realizar una función que la trocee, es decir,  que cree una tabla de dos dimensiones que tenga en cada fila 3 datos de la primera tabla. En la última fila tendrá los datos que sobren.

Se añade el programa principal con el que se probó la función.

public class Trocear {
    public static void main(String[] args) {
        float[] numeros = {12.23F, 53.23F, 1.423F, 54.22F, 75.72F, 0.125F, 5.34F, 6.33F};
        float[][] resultado;
        int a, b;
        resultado = trocea(numeros);
        for (a=0; a<resultado.length; a++){
            for (b=0; b<resultado[a].length; b++)
                System.out.print(resultado[a][b]+"  ");
            System.out.println();
        }
    }
    public static float[][] trocea(float[] t) {
        float[][] tabla = new float[(t.length+2)/3][];
        int i, j, k=0, c = t.length;
        for (i=0; i<tabla.length; i++){
            tabla[i] = new float[(c>=3)?3:c];
            c = c-3;
            for (j=0; j<tabla[i].length; j++){
                tabla[i][j] = t[k];
                k++;
            }
        }
        return tabla;
    }
}

Varios ejercicios con funciones

Realizar una función que reciba un número entero y diga si es par o impar.

public class ParImpar {
    public static void par_o_impar(int numero) {
        if ((numero % 2) == 0)
            System.out.println("El número es par.");
        else
            System.out.println("El número es impar.");
    }
}

Realizar una función que reciba dos números (un double y un entero). Retornará como resultado lo que le dé al elevar el número double al entero.

Se añade el programa principal con el que se probó la función.

public class Exponente {
    public static void main(String[] args) {
        double num, res;
        int exponente;
        num=2.5;
        exponente=3;
        res = exp(num, exponente);
        System.out.println(num+" elevado a "+exponente+" es:" +res);
    }
    public static double exp(double n, int e) {
        double acumulador=1;
        int i=0;
        while (i<e){
            acumulador = acumulador * n;
            i++;
        }
        return acumulador;
    }
}

Ejercicio "mensaje oculto"

Inicializar una tabla bidimensional (4x4) de tipo char en la que se esconderá un mensaje que tiene que mostrar el programa.

Declarar otra tabla de 2 columnas de tipo int, que indicará:

• 1ª columna -> filas de la tabla 1
• 2ª columna -> columnas de la tabla 1

En la primera tabla buscará todas las letras que se encuentran en las direcciones de la segunda tabla.

public class MensajeOculto {
    public static void main(String[] args) {
        char[][] mensaje = {{'a', 'b', 'c', 'd'},
                            {'e', 'f', 'g', 'h'},
                            {'i', 'j', 'k', 'l'},
                            {'m', 'n', 'o', 'p'}};
        int[][] clave = {{0, 2},
                         {0, 0},
                         {3, 0},
                         {1, 0},
                         {2, 3},
                         {2, 3},
                         {3, 2}};
        int i;
        for (i=0; i<clave.length; i++){
            System.out.print(mensaje[clave[i][0]][clave[i][1]]);
        }
        System.out.println();
    }
}

Ejercicio de búsqueda en tablas

Partiremos de dos tablas de datos de igual tamaño.

• Una con datos de tipo float (con alturas).
• Otra con datos de tipo String (con nombres).

Supondremos que cada posición indica en dichas tabla la altura y el nombre de una misma persona.

Hacer un programa que inicialice dichas tablas con valores supuestos.

El programa pedirá por la entrada estandar una altura, buscando a continuación el nombre de la persona más alta que no sobrepase la altura introducida.

• Si no encuentra ninguna... lo indicará.
• Si encuentra varias... solo debe mostrar la primera.

public class BuscarAltura {
    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        float[] alturas = {1.55F, 1.48F, 1.76F, 1.59F, 1.70F, 1.63F, 1.82F};
        String[] nombres = {"Macarena", "Pablo", "María", "Noel", "Eduardo", "Manuel", "Julia"};
        int i, ini, fin;
        float alturaBuscada, auxAlt;
        String auxNom;
        boolean buscadaMayor = false, intercambio = true;
        System.out.print("Introduzca la altura a buscar: ");
        alturaBuscada = entrada.nextFloat();
        //Primero ordenamos la tabla:
        ini = 0;
        fin = alturas.length-1;
        while (ini<fin & intercambio){
            intercambio = false;
            for (i=ini; i<fin; i++){
                if (alturas[i] > alturas[i+1]){
                    auxAlt = alturas[i];
                    alturas[i] = alturas[i+1];
                    alturas[i+1] = auxAlt;
                    auxNom = nombres[i];
                    nombres[i] = nombres[i+1];
                    nombres[i+1] = auxNom;
                    intercambio = true;
                }
            }
            fin--;
            if (intercambio){
                intercambio = false;
                for (i=fin-1; i>=ini; i--){
                    if (alturas[i] > alturas[i+1]){
                        auxAlt = alturas[i];
                        alturas[i] = alturas[i+1];
                        alturas[i+1] = auxAlt;
                        auxNom = nombres[i];
                        nombres[i] = nombres[i+1];
                        nombres[i+1] = auxNom;
                        intercambio = true;
                    }
                }
            }
            ini++;
        }
        //Ahora buscamos AlturaBuscada:
        i=alturas.length-1;
        while (i>=0 & !buscadaMayor){
            if (alturaBuscada >= alturas[i])
                buscadaMayor = true;
            i--;
        }
        if (!buscadaMayor)
            System.out.println("No hay ninguna altura menor que la introducida.");
        else
            System.out.println("La persona más alta que no supera la altura introducida es: "+nombres[i+1]);
    }
}

Ejercicio ¿alguno igual que la media?

Realizar el diagrama Nassi-Shneiderman para un programa que lea 10 números, calcule su media y nos informe de si alguno de ellos coincide con su media. El programa sólo dirá:

• La media es **** y COINCIDE con uno de los números introducidos.

O bien:

• La media es **** y NO COINCIDE con uno de los números introducidos.

DIAGRAMA DE NASSI-SHNEIDERMAN

EJERCICIO EN JAVA

public class CoincideConMedia {
    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        int[] numeros;
        int i, suma=0;
        double media;
        boolean noCoincide = true;
        numeros = new int[10];
        System.out.println("Introduzca "+ numeros.length + " numeros enteros:");
        for (i=0; i<numeros.length; i++){
            numeros[i] = entrada.nextInt();
            suma = suma+numeros[i];
        }
        media = (double)suma / numeros.length;
        i=0;
        while (i<numeros.length & noCoincide){
            if (numeros[i] == media)
                noCoincide = false;
            i++;
        }
        System.out.println("La media es: "+media+ "...");
        if (noCoincide)
            System.out.println("y NO COINCIDE con uno de los números introducidos.");
        else
            System.out.println("y COINCIDE con uno de los números introducidos.");
    }
}

Ejercicios intercalar y concatenar tablas

Dadas dos tablas (arrays) de float, cuyos valores deben estar ordenados de menor a mayor, intercalarlas en una tabla resultante, de forma que contenga los números de ambas tablas ordenados de menor a mayor.

public class Intercalar {
    public static void main(String[] args) {
        int i=0, j=0, k=0;
        float [] tablaA, tablaB, tablaResultante;
        tablaA = new float[]{4.51F, 7.2F, 14.41F, 20.2F};
        tablaB = new float[]{2.25F, 3.0F, 19.5F, 33.33F};
        tablaResultante = new float[tablaA.length + tablaB.length];
        while (i < tablaA.length & j < tablaB.length){
            if (tablaA[i] <= tablaB[j]){
                tablaResultante[k] = tablaA[i];
                i++;
            }
            else{
                tablaResultante[k] = tablaB[j];
                j++;
            }
            k++;
        }
        while (i < tablaA.length){
            tablaResultante[k] = tablaA[i];
            i++;
            k++;
        }
        while (j < tablaB.length){
            tablaResultante[k] = tablaB[j];
            j++;
            k++;
        }
        System.out.print("Tabla A: ");
        for (i=0; i < tablaA.length; i++)
            System.out.print(tablaA[i]+ "  ");
        System.out.println();
        System.out.print("Tabla B: ");
        for (j=0; j < tablaB.length; j++)
            System.out.print(tablaB[j]+ "  ");
        System.out.println();
        System.out.print("Tabla Resultante: ");
        for (k=0; k < tablaResultante.length; k++)
            System.out.print(tablaResultante[k]+ "  ");
    }
}

Dadas dos tablas (arrays) de float, concatenarlas en una tabla resultante, de forma que contenga primero todos los valores de una tabla y después de la otra. 

public class Concatenar {
    public static void main(String[] args) {
         int i=0, j=0, k=0;
         float [] tablaA, tablaB, tablaResultante;
         tablaA = new float[]{4.51F, 7.2F, 14.41F, 20.2F};
         tablaB = new float[]{2.25F, 3.0F, 19.5F, 33.33F};
         tablaResultante = new float[tablaA.length + tablaB.length];
         while (i < tablaA.length){
             tablaResultante[k] = tablaA[i];
             i++;
             k++;
         }
         while (j < tablaB.length & k < tablaResultante.length){
             tablaResultante[k] = tablaB[j];
             j++;
             k++;
         }
         System.out.print("Tabla A: ");
         for (i=0; i < tablaA.length; i++)
             System.out.print(tablaA[i]+ "  ");
         System.out.println();
         System.out.print("Tabla B: ");
         for (j=0; j < tablaB.length; j++)
             System.out.print(tablaB[j]+ "  ");
         System.out.println();
         System.out.print("Tabla Resultante: ");
         for (k=0; k < tablaResultante.length; k++)
             System.out.print(tablaResultante[k]+ "  ");
    }
}

Ejercicio calcular media (tabla bidimensional)

Una tabla bidimensional contiene las notas de un alumno en cada fila. Calculas para cada alumno su nota media y mostrar el alumno, sus notas y la nota media previamente calculada.

public class CalcularMedia {
    public static void main(String[] args) {
        int alum, asig;
        float suma;
        float[][] notas = {{3.5F, 6.7F, 5.25F, 8.0F, 4.8F},
                           {6.5F, 8.0F, 7.5F, 4.75F, 2.0F},
                           {5.5F, 3.7F, 6.25F, 7.0F, 8.7F},
                           {5.9F, 0.5F, 6.75F, 5.0F, 5.7F}};
        float[] notasMedias;
        notasMedias = new float[notas.length];
        //Calcula la nota media para cada alumno (fila)
        for (alum=0; alum<notas.length; alum++){
            suma = 0;
            for (asig=0; asig<notas[alum].length; asig++){
                suma = suma + notas[alum][asig];
            }
            notasMedias[alum] = suma / (notas[alum].length);
        }
        //Muestra el alumno, todas sus notas y la media.
        for (alum=0; alum<notas.length; alum++){
            System.out.print("Alumno " + alum + ": ");
            for (asig=0; asig<notas[alum].length; asig++)
                System.out.print(notas[alum][asig] + "  ");
            System.out.println("Nota media: " + notasMedias[alum]);
        }
    }
}