Saltar al contenido

Practica 2 – Ejercicio 1

Programa que pide un valor para la base de una función exponencial y representa las partes real e imaginaria de la función, así como el módulo y la fase.

function [] =cuestion1()
%Pide el valor de a, que es el factor que multiplica a n
a=input('Introduce el valor de a: ');
%Define el vector de tiempos
n=0:10;
%Define y evalua la funcion
funcion=exp(a.*n);
%Dibuja la parte real de la funcion anterior
subplot(211), stem(n,real(funcion)), title('Parte real de la señal')
%Dibuja la parte imaginaria de la funcion anterior
subplot(212), stem(n,imag(funcion)), title('Parte imaginaria de la señal')
%Dibuja en otra figura el modulo y el argumento de la funcion
figure;stem(n,abs(funcion),'r') , title('Modulo de la señal en rojo y argumento en verde')
hold on
stem(n,angle(funcion),'g')

Aquí tenemos un ejemplo del resultado de la ejecución de este problema para a=0.5+0.5j

Image Hosted by ImageShack.us
Image Hosted by ImageShack.us

Anuncios

Resultados en los dados

Este programa lo he realizado a partir de una duda que me han preguntado acerca de cual es el resultado más probable al tirar dos dados. Mi respuesta inmediata ha sido 7, pero en vista de que no conseguía convencerlo, he dejado que sea Java quien dé el resultado por mi.

public class dados {
    public static void main (String args[]){
        int [] contador=new int [36];
        int cont=0;
        int [] dado=new int [6];
        for (int i=0;i<dado.length;i++){
            dado[i]=i+1;
        }
        for (int j=0;j<dado.length;j++){
            for (int k=0;k<dado.length;k++){
                contador[cont]=dado[j]+dado[k];
                cont++;
            }

        }
        for (int l=2;l<=12;l++){
            int num=0;
            for (int m=0;m<contador.length;m++){
                if (contador[m]==l){
                    num++;
                }
            }
            System.out.println("Hay "+num+" combinaciones que dan "+l+" como resultado");
        }
    }
}

Práctica de camiones

Esta es la última práctica que hice para la asignatura de Programación I.
El paquete ccj os lo podéis descargar de http://www.horstmann.com/ccj/ccjfiles.zip

Código fuente de la clase Camión

import ccj.*;
/* Clase Camion.java */
/**
 * clase Camion. Describe como es un camion y los viajes que puede realizar
 * @author Juande Mata
 * @since 10/12/2009
 */
public class Camion {
    /**
     * Dato miembro que indica la matricula del camion
     */
    private String matricula;
    /**
     * Dato miembro que indica la cantidad de viajes provinciales que ha realizado el camion
     */
    private int provinciales;
    /**
     * Dato miembro que indica la cantidad de viajes interprovinciales que ha ralizado el camion
     */
    private int interprovinciales;
    /**
     * Dato miembro que indica la cantidad de viajes internacionales que ha realizado el camion
     */
    private int internacionales;
    /**
     * Dato miembro que indica los dias del mes que el camion ha estado de viaje
     */
    private int dias;
    /**
     * Dato miembro que indica el nombre del conductor
     */
    private String conductor;
    /**
     * Variable que almacena la opcion del usuario de continuar con la ejecucion del programa o no
     */
    public String opcion;
    /**
     * Parametro que indica el numero de viajes provinciales realizados en ese viaje
     */
    public int nuevoProvinciales;
    /**
     * Parametro que indica el numero de viajes interprovinciales realizados en ese viaje
     */
    public int nuevoInterprovinciales;
    /**
     * Parametro que indica el nuemro de viajes internacionales realizados en ese viaje
     */
    public int nuevoInternacionales;
    /**
     * Parametro que indica la duracion de dias del viaje
     */
    public int nuevoDias;
    /**
     * Parametro que indica el maximo numero de viajes provinciales que puede realizar un camion
     */
    public int maximoProvinciales=10;
    /**
     * Parametro que indica el maximo numero de viajes interprovinciales que puede realizar un camion
     */
    public int maximoInterprovinciales=6;
    /**
     * Parametro que indica el maximo numero de viajes internacionales que puede realizar un camion
     */
    public int maximoInternacionales=4;
    /**
     * Parametro que indica el maximo numero de viajes totales que puede realizar un camion
     */
    public int maximoViajes=20;
    /**
     * Parametro que indica el maximo numero de dias que puede viajar un camion
     */
    public int maximoDias=30;
    /**
     * Parametro que indica el porcentaje de viajes provinciales realizados respecto del total de viajes provinciales posibles para el camion
     */
    public double porcentajeProvinciales;
    /**
     * Parametro que indica el porcentaje de viajes interprovinciales realizados respecto del total de viajes interprovinciales posibles para el camion
     */
    public double porcentajeInterprovinciales;
    /**
     * Parametro que indica el porcentaje de viajes internacionales realizados respecto del total de viajes internacionales posibles para el camion
     */
    public double porcentajeInternacionales;
    /**
     * Parametro que indica el porcentaje de viajes totales realizados respecto del total de viajes totales posibles para el camion
     */
    public double porcentajeTotal;
    /**
     * Constructor que crea un camion con una matricula y un conductor e inicializa los viajes y los dias del mes a 0
     * @param matricula Matricula que tendra el camion
     * @param conductor Conductor del camion
     */
    public Camion (String matricula, String conductor){
        this.matricula=matricula;
        this.conductor=conductor;
        provinciales=0;
        interprovinciales=0;
        internacionales=0;
        dias=0;
    }
    /**
     * Metodo que nos devuelve la cantidad de viajes provinciales que ha realizado el camion
     * @return Numero de viajes provinciales que ha realizado el camion
     */
    public int provinciales(){
        return provinciales;
    }
    /**
     * Metodo que nos devuelve la cantidad de viajes interprovinciales que ha realizado el camion
     * @return Numero de viajes interprovinciales que ha realizado el camion
     */
    public int interprovinciales(){
      return interprovinciales;
    }
    /**
     * Metodo que nos devuelve la cantidad de viajes internacionales que ha realizado el camion
     * @return Numero de viajes internacionales que ha realizado el camion
     */
    public int internacionales(){
        return internacionales;
    }
    /**
     * Metodo que nos permite incrementar la cantidad de viajes provinciales del camion
     * @param numero Cantidad que se incrementa el numero de viajes provinciales
     */
    public void incrementaProvinciales(int numero){
        provinciales=provinciales+numero;
    }
    /**
     * Metodo que nos permite incrementar la cantidad de viajes interprovinciales del camion
     * @param numero Cantidad que se incrementa el numero de viajes interprovinciales
     */
     public void incrementaInterprovinciales(int numero){
        interprovinciales=interprovinciales+numero;
    }
    /**
     * Metodo que nos permite incrementar la cantidad de viajes internacionales del camion
     * @param numero Cantidad que se incrementa el numero de viajes internacionales
     */
    public void incrementaInternacionales(int numero){
        internacionales=internacionales+numero;
    }
    /**
     * Metodo que nos devuelve la cantidad de dias que el camion ha viajado en el mes
     * @return Numero de dias que el camion ha viajado en el mes
     */
    public int dias(){
        return dias;
    }
    /**
     * Metodo que nos permite incrementar la cantidad de dias que el camion ha viajado
     * @param dias Cantidad de dias que se añade a los que ya ha viajado el camion
     */
    public void incrementaDias (int dias){
        this.dias=this.dias+dias;
    }
    /**
     * Metodo que nos devuelve la cantidad de viajes totales que ha realizado el camion
     * @return Numero de viajes totales que ha realizado el camion
     */
    public int totalViajes(){
        return (provinciales+interprovinciales+internacionales);
    }
    /**
     * Metodo que nos devuelve la matricula del camion
     * @return Matricula del camion
     */
    public String matricula(){
        return matricula;
    }
    /**
     * Metodo que nos devuelve el nombre del conductor del camion
     * @return Nombre del conductor del camion
     */
    public String conductor(){
        return conductor;
    }
    /**
     * Metodo que nos permite manejar los viajes de un camion durante un mes, permitiendonos abandonar el manejo cuando queramos o saliendose automaticamente al llegar al maximo permitido
     */
    public void rellenarCalendario(){
        do{
            System.out.println("Ingresa el numero de dias del viaje");
            nuevoDias=Console.in.readInt();
            System.out.println("Ingresa el numero de viajes provinciales");
            nuevoProvinciales=Console.in.readInt();
            System.out.println("Ingresa el numero de viajes interprovinciales");
            nuevoInterprovinciales=Console.in.readInt();
            System.out.println("Ingresa el numero de viajes internacionales");
            nuevoInternacionales=Console.in.readInt();
            if ((dias+nuevoDias)<=30&&(provinciales+nuevoProvinciales)<=maximoProvinciales&&(interprovinciales+nuevoInterprovinciales)<=maximoInterprovinciales&&(internacionales+nuevoInternacionales)<=maximoInternacionales){
                incrementaDias(nuevoDias);
                incrementaProvinciales(nuevoProvinciales);
                incrementaInterprovinciales(nuevoInterprovinciales);
                incrementaInternacionales(nuevoInternacionales);
                System.out.println("Viaje aceptado y procesado");
            }else System.out.println("Viaje erroneo, exceso de dias o de viajes");
            System.out.println("¿Deseas continuar (S/N)?");
            Console.in.readLine();
            opcion=Console.in.readLine();
            System.out.println(opcion);
        }while(dias<maximoDias&&totalViajes()<maximoViajes&&(opcion.equals("S")||opcion.equals("s")));
        porcentajeProvinciales=((provinciales()*100)/maximoProvinciales);
        porcentajeInterprovinciales=((interprovinciales()*100)/maximoInterprovinciales);
        porcentajeInternacionales=((internacionales()*100)/maximoInternacionales);
        porcentajeTotal=((totalViajes()*100)/maximoViajes);
        System.out.println("El porcentaje de viajes provinciales realizados es de: "+porcentajeProvinciales+"%");
        System.out.println("El porcentaje de viajes interprovinciales realizados es de: "+porcentajeInterprovinciales+"%");
        System.out.println("El porcentaje de viajes internacionales realizados es de: "+porcentajeInternacionales+"%");
        System.out.println("El porcentaje de viajes totales realizados es de: "+porcentajeTotal+"%");
    }
    /**
     * Metodo que nos muestra por pantalla la matricula y el conductor del camion
     * @return String en el que se nos muestra la matricula y el conductor del camion
     */
    public String toString(){
        return "El camion tiene matricula: "+matricula()+" y es conducido por: "+conductor()+". \n";
    }
}

Código fuente de la clase prEmpresaCamion

import ccj.*;
/* Clase prEmpresaCamion.java */
/**
 * clase prEmpresaCamion. Describe como es un camion y los viajes que puede realizar
 * @author Juande Mata
 * @since 10/12/2009
 */
public class prEmpresaCamion {
    /**
     * Dato miembro que nos dice el nombre de la empresa
     */
    private String nombre;
    /**
     * Dato miembro que nos indica la primera posicion libre en el array de camiones
     */
    private int pos;
    /**
     * Dato miembro que se usa para definir la longitud del array de camiones
     */
    private int NCamiones=5;
    /**
     * Dato miembro que es un array de camiones sobre el que se trabajara en los otros metodos
     */
    private Camion camiones[]= new Camion[NCamiones];
    /**
     * Metodo que nos devuelve el nombre de la empresa
     * @return Nombre de la empresa
     */
    public String nombre(){
        return nombre;
    }
    /**
     * Constructor que crea una empresa con un nombre determinado y un array de camiones con longitud 5
     * @param nombre Nombre que recibira la empresa
     */
    public prEmpresaCamion(String nombre){
        this.nombre=nombre;
        pos=0;
    }
    /**
     * Constructor que crea una empresa con un nombre determinado y un array de camiones con longitud definida por el usuario
     * @param nombre Nombre que recibira la empresa
     * @param n Longitud del array de la empresa a crear
     */
    public prEmpresaCamion(String nombre, int n){
        this.nombre=nombre;
        NCamiones=n;
        pos=0;
    }
    /**
     * Metodo que nos devuelve el array de camiones para poder trabajar con el desde otras clases
     * @return Array de camiones de la empresa
     */
    public Camion[] camiones(){
        return camiones;
    }
    /**
     * Metodo que nos devuelve la primera posicion libre en el array
     * @return Primera posicion libre en el array
     */
    public int pos(){
        return pos;
    }
    /**
     * Metodo que nos permite crear camiones e introducirlos en el camion sin que se puedan repetir matriculas y que crea un array mas grande en caso de necesitarlo.
     * @param nombre Nombre del conductor del camion a dar de alta.
     * @param matricula Matricula del camion a dar de alta.
     */
    public void altaCamion(String nombre, String matricula){
        boolean coincidencia=false;
        if (pos!=0){
            for (int a=0;a<pos&&coincidencia==false;a++){
                if (matricula.equals(camiones()[a].matricula())){
                coincidencia=true;
                    }
            }
        }
        if ((pos==camiones.length)){
            Camion nuevoCamiones[]=new Camion[(camiones.length*2)];
            System.arraycopy(camiones, 0, nuevoCamiones, 0, camiones.length);
            camiones=nuevoCamiones;
        }
        if (coincidencia==false){
            Camion altaCamion=new Camion(matricula, nombre);
            camiones[pos]=altaCamion;
            pos++;
        }else System.out.println("Matricula ya en uso");
    }
    /**
     * Metodo que nos permite localizar un camion en el array al darsele la matricula.
     * @param matr Matricula del camion a localizar.
     * @return Posicion que ocupa el camion en el array que si no existe, nos devuelve el valor -1 para advertirnos de que no existe.
     */
    public int posicionCamion(String matr){
        for (int i=0;i<pos;i++){
            if (matr.equals(camiones[i].matricula())){
                return i;
            }
        }
        return (-1);
    }
    /**
     * Metodo que nos permite localizar un camion en el array al darsele el nombre del conductor.
     * @param nombrea Nombre del conductor del camion a localizar.
     * @return Posicion que ocupa el camion en el array que si no existe, nos devuelve el valor -1 para advertirnos de que no existe.
     */
    public int posicionCamion2(String nombre){
        for (int i=0;i<pos;i++){
            if (nombre.equals(camiones[i].conductor())){
                return i;
            }
        }
        return (-1);
    }
    /**
     * Metodo que nos permite eliminar un camion del array sin dejar espacios vacios en este.
     * @param matricula Matricula del camion a eliminar.
     */
    public void bajaCamion (String matricula){
        int k=posicionCamion(matricula);
        if (k!=-1){
            for(k=posicionCamion(matricula);k<pos;k++){
                camiones[k]=camiones[k+1];
            }
            camiones[(pos-1)]=new Camion("","");
            pos--;
        }
    }
    /**
     * Metodo que nos permite eliminar un camion del array sin dejar espacios vacios en este.
     * @param nombre Nombre del conductor del camion a eliminar.
     */
    public void bajaCamion2 (String nombre){
        int l=posicionCamion2(nombre);
        if (l!=-1){
            for (l=posicionCamion2(nombre);l=0;a--){
                for (int b=0;b=0;a--){
                for (int b=0;b=0;a--){
                for (int b=0;b<pos;b++){
                    if(camiones()[b].internacionales()==a){
                        cadena2=cadena2+"El camion cuya matrícula es "+camiones()[b].matricula()+" lleva "+a+" viajes internacionales. \n";
                    }
                }
            }
        }else System.out.println("Tipo de viaje incorrecto introducido.");
        System.out.println(cadena2);

    }
    /**
     * Metodo que nos muestra por pantalla la cantidad de camiones que posee la empresa, asi como el conductor y la matricula de cada camion.
     * @return String en el que se nos muestra la cantidad de camiones, conductores y matricula de los camiones
     */
    public String toString(){
        String cadena="";
        for(int j=0;j<pos;j++){
            cadena=cadena+camiones()[j].toString();
        }
        return ("La empresa "+nombre+" tiene un total de "+(pos)+" camiones: \n"+cadena);
    }
}

Código fuente de la clase empresaCamiones

import ccj.*;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.lang.Integer;
/* Clase empresaCamiones.java */
/**
 * clase empresaCamiones. Describe como es una empresa de camiones y como gestionarla.
 * @author Juande Mata
 * @since 10/12/2009
 */
public class empresaCamiones{
    /**
     * Metodo que permite el salvado de datos de una empresa mediante la creacion de un fichero txt
     * @param guardado Empresa de la que se va a realizar el salvado
     */
    public static void guardarEnFichero(prEmpresaCamion guardado){
        System.out.println("Introduzca el nombre con el que se guardara el fichero");
        String fichero=Console.in.readLine()+".txt";
        try{
            FileOutputStream file= new FileOutputStream(fichero);
            byte[] title=new byte[10];
            String title2=guardado.nombre()+"$";
            title=title2.getBytes();
            file.write(title);
            for (int i=0;i<guardado.pos();i++){
                byte[] matricula=new byte[guardado.camiones()[i].matricula().length()];
                String matricula2=guardado.camiones()[i].conductor()+"$"+guardado.camiones()[i].matricula()+"$"+guardado.camiones()[i].provinciales()+"$"+guardado.camiones()[i].interprovinciales()+"$"+guardado.camiones()[i].internacionales()+"$"+guardado.camiones()[i].dias()+"$";
                matricula=matricula2.getBytes();
                file.write(matricula);
            }
            byte[] fin=new byte[1];
            String fin2="#";
            fin=fin2.getBytes();
            file.write(fin);
            file.close();
        }catch(Exception e){
            System.out.println("Fichero imposible de guardar");
            return;
        }
    }
    /**
     * Método que permite cargar la empresa cuyos datos están almacenados en un fichero txt anteriormente guardado
     */
    public static void cargarDeFichero(){
        System.out.println("Introduce el nombre del fichero con los datos");
        String nombreFichero=Console.in.readLine()+".txt";
        int cont=0;
        empresaCamiones ejemplo=new empresaCamiones();
        try{
            FileInputStream fichero=new FileInputStream(nombreFichero);
            int h=fichero.available();
            byte[] lectura=new byte[h];
            for(int i=0;i<h;i++){
                lectura[i]=(byte)fichero.read();
            }
            String lectura2=new String (lectura);
            int j=0;
            String title="";
            do{
                title=title+lectura2.substring(j,j+1);
                j++;
            }while(!(lectura2.substring(j,j+1).equals("$")));
            j++;
            prEmpresaCamion guardado=new prEmpresaCamion(title);
            do{
                String nmb="";
                do{
                    nmb=nmb+lectura2.substring(j,j+1);
                    j++;
                }while(!(lectura2.substring(j,j+1).equals("$")));
                j++;
                String mtr="";
                do{
                    mtr=mtr+lectura2.substring(j,j+1);
                    j++;
                }while(!(lectura2.substring(j,j+1).equals("$")));
                j++;
                String prv="";
                do{
                    prv=prv+lectura2.substring(j,j+1);
                    j++;
                }while(!(lectura2.substring(j,j+1).equals("$")));
                int prv2=Integer.parseInt(prv);
                j++;
                String ipr="";
                do{
                    ipr=ipr+lectura2.substring(j,j+1);
                    j++;
                }while(!(lectura2.substring(j,j+1).equals("$")));
                int ipr2=Integer.parseInt(ipr);
                j++;
                String ina="";
                do{
                    ina=ina+lectura2.substring(j,j+1);
                    j++;
                }while(!(lectura2.substring(j,j+1).equals("$")));
                int ina2=Integer.parseInt(ina);
                j++;
                String dia="";
                do{
                    dia=dia+lectura2.substring(j,j+1);
                    j++;
                }while(!(lectura2.substring(j,j+1).equals("$")));
                int dia2=Integer.parseInt(dia);
                j++;
                guardado.altaCamion(nmb,mtr);
                guardado.camiones()[cont].incrementaProvinciales(prv2);
                guardado.camiones()[cont].incrementaInterprovinciales(ipr2);
                guardado.camiones()[cont].incrementaInternacionales(ina2);
                guardado.camiones()[cont].incrementaDias(dia2);
                cont++;
            }while(!(lectura2.subSequence(j,j+1).equals("#")));
            ejemplo.cargarDatos(title,guardado);
            fichero.close();
        }catch(Exception e){
            System.out.println("Fichero imposible de cargar");
            return;
        }
    }
    /**
     * Metodo que nos permite gestionar la empresa de camiones, pudiendo dar de alta camiones, buscarlos, ordenarlos segun el tipo de viaje, buscar los viajes o dias de un camion, hacer una lista de los camiones de la empresa, asignar viajes a un camion y dar de baja camiones.
     * @param ttl Nombre de la empresa
     * @param camionEmpresa Objeto de la clase prEmpresaCamion con el que se trabajará
     */
    public void cargarDatos(String ttl,prEmpresaCamion camionEmpresa){
        int opcion;
        do{
            System.out.println("1. Alta de un Camión bien indicando el conductor o el número matricula \n" +
                "2. Buscar un camión por matricula o por conductor \n" +
                "3. Listar los camiones de mayor a menor número de viajes de un tipo \n" +
                "4. Consultar para un camión los viajes o días asignados durante un mes \n" +
                "5. Listar EmpresaCamiones \n" +
                "6. Rellenar calendario para un camión \n" +
                "7. Dar de baja un Camión \n" +
                "8. Salir \n"+
                "9. Guardar datos en un fichero \n");
            opcion=Console.in.readInt();
            switch (opcion){
                case 1:
                    System.out.println("Introduce el nombre del conductor");
                    Console.in.readLine();
                    String nombreCamion=Console.in.readLine();
                    System.out.println("Introduce la matricula del camion");
                    String matriculaCamion=Console.in.readLine();
                    camionEmpresa.altaCamion(nombreCamion, matriculaCamion);
                    break;
                case 2:
                    System.out.println("Introduce el parametro de busqueda que prefieras: matricula (1) o conductor (2)");
                    int opcionBusqueda=Console.in.readInt();
                    switch (opcionBusqueda){
                        case 1:
                            System.out.println("Introduce la matricula del camion");
                            Console.in.readLine();
                            String busqueda=Console.in.readLine();
                            int posicionCamion=camionEmpresa.posicionCamion(busqueda);
                            if (posicionCamion!=-1){
                                System.out.println(camionEmpresa.camiones()[posicionCamion].toString());
                            }else System.out.println("No existe ningun camion con dicha matricula");
                            break;
                        case 2:
                            System.out.println("Introduce el nombre del conductor");
                            Console.in.readLine();
                            String busquedab=Console.in.readLine();
                            int posicionCamionb=camionEmpresa.posicionCamion2(busquedab);
                            if (posicionCamionb!=-1){
                                System.out.println(camionEmpresa.camiones()[posicionCamionb].toString());
                            }else System.out.println("No existe ningun camion conducido por dicho conductor");
                            break;
                        default:
                            System.out.println("Opcion incorrecta introducida");
                            break;
                    }
                    break;
                case 3:
                    System.out.println("Introduce el tipo de viaje (proviciales/interprovinciales/internacionales)");
                    Console.in.readLine();
                    String viajeListado=Console.in.readLine();
                    camionEmpresa.listadoPorViajes(viajeListado);
                    break;
                case 4:
                    System.out.println("Introduce el parametro de busqueda que prefieras: matricula (1) o conductor (2)");
                    int opcionBusqueda3=Console.in.readInt();
                    switch (opcionBusqueda3){
                        case 1:
                            System.out.println("Introduce la matricula del camion");
                            Console.in.readLine();
                            String busqueda=Console.in.readLine();
                            int posicionCamion=camionEmpresa.posicionCamion(busqueda);
                            if (posicionCamion!=-1){
                                System.out.println("El camion tiene asignados "+camionEmpresa.camiones()[posicionCamion].dias()+ " dias de viaje. \n" +
                            "Tiene programados "+camionEmpresa.camiones()[posicionCamion].provinciales()+" viajes provinciales, "+camionEmpresa.camiones()[posicionCamion].interprovinciales()+" viajes interprovinciales y "+camionEmpresa.camiones()[posicionCamion].internacionales()+" viajes internacionales.");
                            }else System.out.println("No existe ningun camion con dicha matricula");
                            break;
                        case 2:
                            System.out.println("Introduce el nombre del conductor");
                            Console.in.readLine();
                            String busquedab=Console.in.readLine();
                            int posicionCamionb=camionEmpresa.posicionCamion2(busquedab);
                            if (posicionCamionb!=-1){
                                System.out.println("El camion tiene asignados "+camionEmpresa.camiones()[posicionCamionb].dias()+ "dias de viaje. \n" +
                            "Tiene programados "+camionEmpresa.camiones()[posicionCamionb].provinciales()+" viajes provinciales, "+camionEmpresa.camiones()[posicionCamionb].interprovinciales()+" viajes interprovinciales y "+camionEmpresa.camiones()[posicionCamionb].internacionales()+" viajes internacionales.");
                            }else System.out.println("No existe ningun camion conducido por dicho conductor");
                            break;
                        default:
                            System.out.println("Opcion incorrecta introducida");
                            break;
                    }
                    break;
                case 5:
                    System.out.println(camionEmpresa.toString());
                    break;
                case 6:
                    System.out.println("Introduce el parametro de busqueda que prefieras: matricula (1) o conductor (2)");
                    int opcionBusqueda4=Console.in.readInt();
                    switch (opcionBusqueda4){
                        case 1:
                            System.out.println("Introduce la matricula del camion");
                            Console.in.readLine();
                            String busqueda=Console.in.readLine();
                            int posicionCamion=camionEmpresa.posicionCamion(busqueda);
                            if (posicionCamion!=-1){
                                camionEmpresa.rellenarCalendario(busqueda);
                            }else System.out.println("No existe ningun camion con dicha matricula");
                            break;
                        case 2:
                            System.out.println("Introduce el nombre del conductor");
                            Console.in.readLine();
                            String busquedab=Console.in.readLine();
                            int posicionCamionb=camionEmpresa.posicionCamion2(busquedab);
                            if (posicionCamionb!=-1){
                                camionEmpresa.rellenarCalendario2(busquedab);
                            }else System.out.println("No existe ningun camion conducido por dicho conductor");
                            break;
                        default:
                            System.out.println("Opcion incorrecta introducida");
                            break;
                    }
                    break;
                case 7:
                    System.out.println("Introduce el parametro de busqueda que prefieras: matricula (1) o conductor (2)");
                    int opcionBusqueda2=Console.in.readInt();
                    switch (opcionBusqueda2){
                        case 1:
                            System.out.println("Introduce la matricula del camion");
                            Console.in.readLine();
                            String busqueda=Console.in.readLine();
                            int posicionCamion=camionEmpresa.posicionCamion(busqueda);
                            if (posicionCamion!=-1){
                                camionEmpresa.bajaCamion(busqueda);
                            }else System.out.println("No existe ningun camion con dicha matricula");
                            break;
                        case 2:
                            System.out.println("Introduce el nombre del conductor");
                            Console.in.readLine();
                            String busquedab=Console.in.readLine();
                            int posicionCamionb=camionEmpresa.posicionCamion2(busquedab);
                            if (posicionCamionb!=-1){
                                camionEmpresa.bajaCamion2(busquedab);
                            }else System.out.println("No existe ningun camion conducido por dicho conductor");
                            break;
                        default:
                            System.out.println("Opcion incorrecta introducida");
                            break;
                    }
                case 8:
                    System.out.println("Finalizando el programa");
                    break;
                case 9:
                    Console.in.readLine();
                    empresaCamiones.guardarEnFichero(camionEmpresa);
                    break;
                default:
                    System.out.println("Opcion errónea introducida, por favor, seleccione otra opcion");
            }
        }while(opcion!=8);
    }
    public static void main(String args[]){
        empresaCamiones empresaEjemplo=new empresaCamiones();
        int option;
        do{
            System.out.println("¿Desea cargar una compañía existente (1), empezar con una nueva (2) o salir (3)?");
            option=Console.in.readInt();
            switch(option){
                case 1:
                    Console.in.readLine();
                    empresaCamiones.cargarDeFichero();
                    break;
                case 2:
                    Console.in.readLine();
                    System.out.println("Introduce el nombre de la empresa");
                    String titulo=Console.in.readLine();
                    prEmpresaCamion camionEmpresa=new prEmpresaCamion(titulo);
                    empresaEjemplo.cargarDatos(titulo, camionEmpresa);
                    break;
                case 3:
                    System.out.println("Finalizando el programa");
                    break;
                default: System.out.println("Opción incorrecta introducida");
            }
        }while(option!=3);
    }
}

Programa rebajas Métodos Matemáticos 2

Este es un programa creado para una ejercicio de Métodos Matemáticos 2 que comprueba si una serie de rebajas al aplicarlas en serie cumplen el requisito de producir una rebaja total que sea múltiplo de 5, tomando porcentajes.

public class Main {

public static void main(String args[]){

double[] descuentos1={90, 85, 80, 75, 70, 50};

double[] descuentos2={90, 85, 80, 75, 70, 50};

double precioInicial=100;

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

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

double precioFinal=100*(descuentos1[i]/100)*descuentos2[j]/100;

if((precioFinal%5)==0){

System.out.println(“La rebaja de Enero del “+(100-descuentos1[i])+”% se puede combinar con la de Febrero del “+(100-descuentos2[j])+”%”);

}

}

}

}

}

Sorteo de 16 entradas

Aquí un programa en el que tras introducir los 16 ítems a sortear, hace el sorteo. Es para un torneo que estamos haciendo en un foro.

import java.io.*;
import java.util.Random;
/**
* @author kang
*/
public class sorteo {

public static void main(String[] args) throws IOException{

String[] titulos=new String[16];
for(int i=0;i<16;i++){

System.out.println(“Introduzca el título de la película”);
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
titulos[i]=br.readLine();

}

System.out.println(“Los emparejamientos son:”);
for(int j=0;j<16;j++){
Random seleccion=new Random();
int selec=seleccion.nextInt(16-j);
System.out.println(titulos[selec]);
titulos[selec]=titulos[15-j];

}

}

}

Programa para dividir en Símplez

Debido a la no existencia de un algoritmo directo en Símplez que nos permita calcular una división, he decidido crear yo uno, aunque sólo realice divisiones enteras.

Posteriormente pondré la ayuda de todos los pasos intermedios que se realizan.

BR   /INI
VAL1    DATA    19
VAL2    DATA    6
CONT    RES    1
RESULT    RES    1
UNO    DATA    1
INI    CLR
LD    /VAL2
ST    /CONT
BUC1    LD    /VAL1
DEC
ST    /VAL1
LD    /CONT
DEC
BZ    /INC
ST    /CONT
LD    /VAL1
BZ    /FIN
BR    /BUC1
INC    LD    /RESULT
ADD    /UNO
ST    /RESULT
LD    /VAL1
BZ    /FIN
BR    /INI
FIN    LD    /RESULT
HALT
END