viernes, 31 de enero de 2014

Ejercicios preparación examen 1er trimestre 3

Pedir 20 valores por teclado y:
a.- Calcular la media de los 10 primeros
b.- calcular mayor y menor de los 20 primeros....

....vamos usando "a veces" try catch...

package preparandoexamen3;
import java.util.Scanner;
/**
*
* @author juan
*/
public class PreparandoExamen3 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int numero, mayor, menor,suma=0;
        Scanner leo = new Scanner(System.in);
     
        numero=leo.nextInt();
        mayor=menor=suma=numero;
  

Ejercicios preparación examen 1er trimestre 2

Dado un número (p.e. 57621) escribirlo a l revés: (12675)

En esta entrada van tres maneras de hacerlo

package preparandoexamen2;
import java.util.Scanner;

/**
*
* @author juan
*/
public class PreparandoExamen2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner leo = new Scanner(System.in);
        String cadena = new String();
        String subCadena;
        StringBuilder otra;
      
      
        int numero,reves,temp;
      
      
        System.out.println("Introduzca el número");
        cadena = leo.nextLine();
        try{
            numero = Integer.parseInt(cadena);
            while (numero>10) {
                numero=numero/10;
                System.out.print(numero%10);
            }
            System.out.print(numero);
        }catch(Exception e){
           System.out.println("la cadena introducida no tiene formato numérico");
        }
        System.out.println();
    

Ejercicio Preparación examen 1er trimestre 1

Salida y traza de variables para:

public class Preparandoexamen1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        boolean b=true;
        int j= 10;
        while (b) {
            if (j%2==0) {
                b=true;
               
            }
            for (int i = 1; i < 10; i+=2) {
                System.out.printf("%n %d - %d", i, i+j);
            }
        }
    }
}

Unidad 2 Ejercicio 81: teléfonos y tiempos

81. Programar una clase de nombre TarjetaPrepago que permita interactuar con la información de una tarjeta de telefonía móvil de prepago. Esta clase tendrá las siguientes propiedades, métodos y constructores:

Propiedades privadas:

- numeroTeléfono, nif de tipo String.
- saldo de tipo double (en euros).
- consumo de tipo Tiempo. Tiempo es una clase que hay que declarar, y que solamente tendrá 2 propiedades de tipo int con los nombres minutos y segundos.


Constructores:

miércoles, 29 de enero de 2014

Courier y Postfix con autenticación Pam y en Maildir

En primer lugar seguimos los pasos de instalación 1 y 2 del enlace con las siguientes modificaciones:

Nos aseguramos de configurar correctamente /etc/postfix/main.cf (ojo con el parámetro mynetworks si lo coinfiguramos como en el ejemplo sólo atenderá peticiones del equipo, se pueden añadir redes separándolas con comas:)
# See /usr/share/postfix/main.cf.dist for a commented, more complete version

# Debian specific:  Specifying a file name will cause the first
# line of that file to be used as the name.  The Debian default
# is /etc/mailname.
#myorigin = /etc/mailname
smtpd_banner = $myhostname ESMTP $mail_name (Ubuntu)
biff = no
# appending .domain is the MUA's job.
append_dot_mydomain = no
# Uncomment the next line to generate "delayed mail" warnings
#delay_warning_time = 4h
readme_directory = no

lunes, 27 de enero de 2014

Unidad 2 Ejercicio 80: Clase cuenta corriente, paso de enteros a cadenas y empezando con excepciones

80. A Programar una clase de nombre CuentaCorriente que permita almacenar e interactuar con la cuenta bancaria de un cliente. Esta clase tendrá las siguientes propiedades, métodos y constructores:

Propiedades privadas:

- nombre, apellidos, dirección, teléfono, NIF de tipo String.
- saldo de tipo double.

Constructores:

- Constructor por defecto que no haga nada
- Constructor al que se le pasen como argumentos todas las propiedades que tiene la clase

Métodos públicos:

- sacarDinero: le resta al saldo una cantidad de dinero pasada como argumento.
- ingresarDinero: le añade al saldo una cantidad de dinero.
- consultarSaldo, consultarNombre……. devolverá cada uno de ellos el valor de su propiedad.
- establecerSaldo, establecerNombre….. asignará cada uno de ellos el valor de su propiedad.
- consultarCuenta: visualizará todos los datos de la cuenta.
- saldoNegativo: devolverá un valor lógico indicando si la cuenta está o no ennúmeros rojos.

Unidad 2 Ejercicio 79: Clase llamada (con clase hora)

79.- Programar una clase de nombre Llamada que guardará la información relativa a una llamada telefónica. Tendrá las siguientes propiedades y métodos:

Propiedades: (todas ellas privadas)
String numeroTelefono;
Hora comienzoLlamada;
Hora finLlamada;

Métodos de la clase (públicos):

- Método constructor por defecto que no haga nada.
- Método constructor que reciba tres argumentos de tipo (String, Hora, Hora) y se los asigne a las propiedades de la clase.
- Método de nombre escribeHoraComienzo que visualice el valor de la propiedad comienzoLLamada con  el formato: 13:25:13.
- Método de nombre escribeHoraFin que visualice el valor de la propiedad finLLamada con  el mismo formato que el método anterior.
- Método de nombre duraciónLlamada que devuelva en segundos la duración de la llamada. Si la hora de finalización es inferior a la hora de comienzo de la llamada el método devolverá -1.
- Métodos set y get para todas las propiedades.



package unidad2ejercicio79;

/**
*
* @author Juan
*/
public class Unidad2Ejercicio79 {

viernes, 24 de enero de 2014

Unidad 2 Ejercicio 79: Clase Hora

package unidad2ejercicio79;

/**
*
* @author Juan
*/
public class Hora {
    private int horas;
    private int minutos;
    private int segundos;

    public Hora(int horas, int minutos, int segundos) {
        if ( horas>=0 && horas<=24 && minutos>=1 && minutos<=60 && segundos >=1 && segundos<=60)
        {   this.horas = horas;
            this.minutos = minutos;
            this.segundos = segundos;
        }
        else{
            this.horas = 0;
            this.minutos = 0;
            this.segundos = 0;
        }
    }

Unidad 2 Ejercicio 78: Fechas

80. Programar una clase de nombre Fecha que guarde una fecha  como tres enteros privados  de nombres dia, mes y anyo. Serían las propiedades de la clase.

Métodos de la clase:

- constructor que reciba 3 datos de tipo entero y se los asigne a los propiedades  dia mes y anyo.

- constructor por defecto,  que asigne la fecha: 1-1-2013.

- asignate(int,int,int): método que asigna valores a un objeto fecha. Se le pasan tres enteros que serán  almacenados en las propiedades dia, mes y anyo.

- Métodos set y get para las propiedades de la clase.

- incrementate(int d): incrementa en d días la fecha.

- imprimete(): escribe la fecha en el formato: 5-Febrero-1010 (para los valores 5-2-2010)

- imprimete(int): método sobrecargado al que se le pasa como argumento un valor entero. En este caso el método escribirá la fecha con el formato: 5-02-2010.

Unidad 2 Ejercicio 77

77. Una ecuación de segundo grado tiene el formato ax2+bx+c=0, donde a, b y c pueden ser cualquier número real (para que la ecuación sea de segundo grado a no puede valer 0). Hay dos valores de x (x1, x2) que hacen que la ecuación sea igual a 0. Estas dos soluciones de la ecuación se obtienen aplicando las fórmulas:

X1 = (-b + sqrt(b2-4*a*c))/(2*a)
X2 = (-b - sqrt(b2-4*a*c))/(2*a) 

Diseñar una  clase de nombre EcuacionSegundoGrado que nos permita representar y manipular ecuaciones de segundo grado. Dicha clase tendrá tres propiedades de ámbito privado que guardaran los valores de  a, b y c, así como dos constructores y los siguientes métodos públicos:

a) Constructor al que se le pasen 3 valores numéricos y se los asigne a los coeficientes.

b) Constructor por defecto que no haga nada.

c) Método de nombre setCoeficientes() al que se le pasen tres valores numéricos y los asigne respectivamente a las propiedades a, b y c.

d) Tres métodos de nombre getA(), getB() y getC(), que cada uno de ellos devuelva respectivamente el contenido de las propiedades a,b y c.

e) Tres métodos de nombre setA(), setB() y setC(), que permitan asignar un valor a cada uno de los coeficientes de la ecuación.

f) Método de nombre averigua que devuelva true si la ecuación tiene solución y false si no la tiene. Una ecuación de segundo grado no tiene solución si a es igual a 0, o el valor de b2-4*a*c es negativo.

g) Método de nombre obtenerSolución1() que devuelva la primera de las soluciones de la ecuación de segundo grado.

h) Método de nombre obtenerSolución2() que devuelva la segunda de las soluciones de la ecuación de segundo grado.

Comprobar el funcionamiento de la clase, creando objetos de la clase con diferentes valores para los coeficientes.

Ejemplos:

x2 - 5x + 6 = 0 tiene como soluciones 3 y 2
x2 + x + 1 = 0 no tiene solución (raíz cuadrada negativa)




package unidad3ejercicio77;

/**
*
* @author Juan
*/
public class Unidad3Ejercicio77 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 

jueves, 23 de enero de 2014

Servidor de correo postfix, courir, spamassassin, clamav, mySQL

Os dejo un documento elaborado por Lorena Fernández a.k.a. Loretahur sobre la explicación e instalación completa del servidor enlace al documento ...

lunes, 20 de enero de 2014

Unidad 2 Ejercicios 74 y 75: Clase rectángulo con constructores y pruebas

74. Programar una clase de nombre Rectangulo que describa y de soporte a esta figura geométrica. La clase tendrá dos propiedades privadas de nombres largo y alto, y  los métodos:
- set y get que permitan asignar y ver el contenido de las propiedades de la clase.
- superficie, que devolverá la superficie del rectángulo.
- perímetro, que devolverá el perímetro del rectángulo
- visualiza, que visualizará información del rectángulo con el formato:
largo: xxxx
alto: xxxxx
superficie: xxxx
perímetro: xxxx

75. incluir dos constructores (uno por defecto) en la clase Rectángulo.



package ejercicio74unidad2;

/**
*
* @author Juan
*/
public class Ejercicio74Unidad2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Rectangulo uno=new Rectangulo();
        Rectangulo dos = new Rectangulo();
        Rectangulo tres = new Rectangulo(13,24);
   
        uno.setAlto(10);
        uno.setLargo(20);
        dos.setAlto(3);
        dos.setLargo(45);
        uno.visualiza();
        dos.visualiza();
       
        tres.visualiza();
   
    }
}

Ejercicio 73 Unidad 2: Objeto animal, introducción a objetos

73. Dada la siguiente declaración de una clase de nombre animal:
class Animal{
    private int edad;
    private String nombre;

    public void nace(){
        System.out.println("Hola mundo");
    }
    public void getNombre(){
        System.out.println(nombre);
    }
    public void getEdad(){
        System.out.println(edad);
    }
}


a. Hacer un programa de nombre Animalito en el que se declaren 2 objetos que pertenezcan a la clase Animal. Invocar al método nace() con el primer objeto y a los métodos getEdad () y getNombre desde el segundo objeto.
b. Añadirle a la clase los métodos setNombre y setEdad que permitan asignarle valores a las propiedades de la clase.
c. Probar estos métodos desde los objetos creados en el apartado

viernes, 17 de enero de 2014

Unidad 2 Ejercicio 66: Acertar un número al azar


/*
* 66. Hacer un programa que genere un numero al azar comprendido entre 0 y un número N leído por teclado y que luego permita que un jugador introduzca números hasta que acierte el numero secreto, después de cada numero que introduzca el jugador el programa le informará diciéndole si el número secreto es más grande o más pequeño que el generado por la máquina. Cuando el jugador acierte, el programa escribirá un mensaje de felicitación y escribirá el número de intentos que realizó.
*/
package unidad2ejerc66;
import java.util.*;
/**
*
* @author Juan
*/
public class Unidad2Ejerc66 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int num, intentos=0, aleatorio;
        Random azar = new Random();
        Scanner leo = new Scanner(System.in);
       
       do {   
             System.out.println("Introduzca el número máximo a buscar (mayor que cero)");
             num=leo.nextInt();
        } while (num<0);
      
     
        aleatorio= azar.nextInt(num);

Unidad 2 Ejercicio 65: Primitiva

package unidad2ejerc65;
import java.util.*;
import java.security.*;

/**
*
* @author Juan
*/
public class Unidad2Ejerc65 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int num, intentos=0, aleatorio;
        int n1,n2,n3,n4,n5,n6,n7;
      
        Random azar = new Random();
        Scanner leo = new Scanner(System.in);
      
    

Ejercicio 53: palíndromas

Creando un par de métodos en nuestro objeto.....
  public boolean palindroma(){
         String temp;
         StringBuilder inversa;
        
         temp = miCadena.toLowerCase().replaceAll(" ", "");
         inversa = new StringBuilder(temp).reverse();
         return (temp.equals(inversa.toString()));
        
        
     }
    
     public boolean palindroma2()
     {
         boolean sigue=true;
         int pos=0, fin;
         String temp;
        
         temp= (miCadena.toLowerCase().replaceAll(" ", ""));
         fin = temp.length()-1;
        
        
         while (sigue==true && pos<fin) {
             if (temp.charAt(fin)==temp.charAt(pos)) {
                 pos++;
                 fin--;
             }
             else
                 sigue=false;
            
         }
              
         return sigue;
        
        
     }

miércoles, 15 de enero de 2014

Objetos y cadenas: método para contar número de ocurrencias de un carácter en una cadena.....

package ejercicadenas4;

/**
* Una clase cadena con un par de constructores
* @author juan
*/
public class Cadena {

    /**
     *
     */
    public Cadena() {
        this.miCadena = "";
    }

  
    private String miCadena;

    /**
     *
     * @param miCadena
     */
    public Cadena(String miCadena) {
        this.miCadena = miCadena;
    }
   
    /**
     *
     * @return
     */
    public String getMiCadena() {
        return miCadena;
    }

     /**
      *
      * @param miCadena
      */
     public void setMiCadena(String miCadena) {
        this.miCadena = miCadena;
    }
   
     /**
      * Devuelve un número entero que representa las ocurrencias del caracter
      * car (pasado como parámetro) en el objeto
      * @param car
      * Caracter que se buscará en el objeto para contar cuántas veces está presente
      * @return el número de ocurrencias en la cadena
      */
     public int ocurrencias(char car)
    {
        int num=0,longitud;
       
        longitud= miCadena.length();
        for (int i = 0; i < longitud; i++) {
            if (miCadena.charAt(i)==car) num++;
        }
       
        return num;
    }
   
   
}


## Clase que hace uso de la clase principal

package ejercicadenas4;
import java.util.Scanner;
/**
*
* @author juan
*/
public class EjerciCadenas4 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

    Cadena miCadena = new Cadena();
    char car;
    Scanner leo = new Scanner(System.in);
   
    System.out.println("Introduzca una cadena de texto");
    miCadena.setMiCadena(leo.nextLine());
   
    System.out.println("Introduzca el caracter a buscar:");
    car= leo.next().charAt(0);
   
   
    System.out.println("El número de caracteres "+car +" es "+ miCadena.ocurrencias(car));
   
   
   
    }
}


Explicación cadenas 3: contar el número de vocales en una cadena (Ejercicio 52 del boletín)


package ejercicadenas3;

import java.util.Scanner;

/**
*
* @author juan
*/
public class EjerciCadenas3 {


Explicación cadenas 2

/*
*¿Comprobar si están presentes todas las vocales?
*/
package ejercadenas2;

/**
*
* @author juan
*/
public class EjerCAdenas2 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        String cadena = new String("Hola esta es la cadena de prueba");
        //String cadena2 = "esta es otra forma";
   
        if (cadena.indexOf("i")==-1) System.out.println("La letra i no está presente");
        System.out.println("la primera a está en la posición: "+(cadena.indexOf('a')));
   
        if (cadena.indexOf('i')==-1 || cadena.indexOf("a")==-1 || cadena.indexOf("e")==-1  || cadena.indexOf("o")==-1 || cadena.indexOf("u")==-1)
        {
            System.out.println("No están presentes todas las vocales");}
        else
                System.out.println("Están presentes todas las vocales");
       
        System.out.println("a partir de la posición 3 en la posición: "+(cadena.indexOf('a',3)));
        System.out.println("a partir de la posición 10 la primera a está en la posición: "+(cadena.indexOf('a',10)));
    }
}

Explicación cadenas 1

/*
* Solicitar al usuario que introduzca una cadena e imprimir el número
* de caracteres de la misma
*/
package ejercadenas1;
import java.util.*;
/**
*
* @author juan
*/
public class EjerCadenas1 {

    /**
     */
    public static void main(String[] args) {

        String cadena;
        Scanner leo = new Scanner(System.in);
      
        System.out.println("Introduzca una cadena de caracteres: ");
        cadena=leo.nextLine();
        System.out.println("Número de caracteres:" + cadena.length());
    }
}

Ejercicio 45: Realizar el doble triángulo de acuerdo al enunciado

/*
* 45. Hacer un programa que nos pida por teclado un número N,
* forzando al usuario a que N este comprendido entre 3 y 10 (ambos incluidos), y a continuación escribir un gráfico como el siguiente (sería el caso de N = 3):

*    *
**  **
******

*/
package ud2ejercicio45;

import java.util.Scanner;

/**
*
* @author juan
*/
public class Ud2Ejercicio45 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        int totalEspacios,impresos;
        Scanner leer = new Scanner(System.in);
        int num;
  

Ejercicio 44: realizar el triángulo de la imagen

/*
*
* 44. Hacer un programa que nos pida por teclado un número N,
* forzando al usuario a que N este comprendido entre 3 y 10 (ambos incluidos),
* y a continuación escribir un gráfico como el siguiente (sería el caso de n
* igual a 4):

*
**
***
****

*/
package ud2ejerc44;
import java.util.Scanner;
/**
*
* @author juan
*/
public class Ud2Ejerc44 {

    /**
     * al no haber visto cadenas empleamos sólo caracteres y bucles
     */
    public static void main(String[] args) {
        Scanner leer = new Scanner(System.in);
        int num;
       
        do {
            System.out.println("Introduzca un número entre 3 y 10:");
            num= leer.nextInt();
        } while (num<3 || num>10);
       
        for (int lineas = 1; lineas <= num ; lineas++) {
            for (int asteriscos = 1; asteriscos <=lineas; asteriscos++) {
                System.out.print("*");
            }
            System.out.println();
        }
       
       
   
    }
}