ACTUALIZADOS APUNTES FOL 23-01-13

He puesto al día los apuntes de FOL.
Recordad que mañana hay que entregar los ejercicios esos de marras o nos catea... xD

Apuntes Fol 23-01-2013

Un beso a tod@s, maj@s. xDD

Tutorial Base de Datos SQL

Es muy muy bueno -> http://www.sqlserverya.com.ar/

Tiene ejercicios resueltos y todo.

Ejercicio67 condicion

/*
 * 67.    La Lotería Primitiva es un juego de azar regulado por Loterías y Apuestas del Estado
 *  (LAE) que consiste en elegir 6 números diferentes entre 1 y 49, con el objetivo de acertar
 *   la Combinación Ganadora en el sorteo correspondiente, formada por 6 bolas de las 49 que se
 *   extraen del bombo (modalidad comúnmente conocida como 6/49). También se extrae una bola extra
 *    como número complementario, y otra bola de un bombo aparte, entre el 0 y el 9, que hace
 *    de número de «reintegro».


El programa tiene que escribir:

Combinación de la primitiva: 3 , 28 , 47,  33 , 19 , 21

Número complementario: 46

Reintegro: 7

 */

import java.util.Random;

public class Ejercicio67 {
    public static void main(String[] args) {
        // Variables
        int num1, num2, num3, num4, num5, num6, comp, rein;
        // Inicializamos Random
        Random aleatorio = new Random();
        // Empezamos el programa

        do {
            num1 = (aleatorio.nextInt(49) + 1);
            num2 = (aleatorio.nextInt(49) + 1);
            num3 = (aleatorio.nextInt(49) + 1);
            num4 = (aleatorio.nextInt(49) + 1);
            num5 = (aleatorio.nextInt(49) + 1);
            num6 = (aleatorio.nextInt(49) + 1);
            comp = (aleatorio.nextInt(49) + 1);
        } while (num1 == num2 ||num1 == num3 ||num1 == num4 ||num1 == num5 ||num5 == num6 ||num1 == comp
                ||num2 == num3 ||num2 == num4 ||num2 == num5 ||num2 == num6 ||num2 == comp
                ||num3 == num4 ||num3 == num5 ||num3 == num6 ||num3 == comp
                ||num4 == num5 ||num4 == num6 ||num4 == comp
                ||num5 == num6 ||num5 == comp
                ||num6 == comp);

        rein = aleatorio.nextInt(10);

        System.out.println("La combinacion de la primitiva: " + num1 + ", "
                + num2 + ", " + num3 + ", " + num4 + ", " + num5 + ", " + num6);
        System.out.println("Reintegro: " + rein);
        System.out.println("Complementario: " + comp);
        // Comprobamos que finaliza por completo
        System.out.println();
        System.out.print("END_OF_LINE");
    }
}

Ejercicio 66 de PRO

/*
 * 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ó.
 */

import java.util.Scanner;
import java.util.Random;

public class Ejercicio66 {
    public static void main(String[] args) {
        // Variables
        int numMax;
        int generado;
        int intento;
        int numIntentos = 0;
        // Inicializamos Scanner
        @SuppressWarnings("resource")
        Scanner reader = new Scanner(System.in);
        // Inicializamos Random
        Random aleatorio = new Random();
        // Empezamos el programa
        System.out.println("Introduce el valor máximo para generar un aleatorio: ");
        numMax = reader.nextInt();
        generado = aleatorio.nextInt(numMax + 1);
        // System.out.println("Ha generado: " + generado +
        // " (Solo comprobación, no haga trampa.)");
        System.out.println("Intente averiguar el numero generado: ");
        intento = reader.nextInt();
        numIntentos++;
        do {
            System.out.println("Ha fallado, intentelo de nuevo:");
            if(intento < generado){
                System.out.println("El numero generado es mayor al introducido.");
                intento = reader.nextInt();
                numIntentos++;
            }
            else{
                System.out.println("El numero generado es menor al introducido.");
                intento = reader.nextInt();
                numIntentos++;
            }
        } while (intento != generado);
        System.out.println("Enhorabuena, ha acertado el numero generado: " + generado);
        System.out.println("ha realizado " + numIntentos + " intentos. ^.^");
        // Comprobamos que finaliza por completo
        System.out.print("END_OF_LINE");
    }
}

Ejercicio63 Sin cadenas

/*
 * 63.    Hacer un programa que pida por teclado un número binario forzando al usuario
 *  a que realmente introduzca un número formado por ceros y unos. A continuación
 *  escriba en pantalla el valor decimal del número introducido. Para resolver
 *  este programa es necesario utilizar los métodos siguientes:
 *
 *   lógico función esBinario(entero x). Devuelve verdadero o falso si el número  x es binario o no.
 *   entero función cifras(entero x). Devuelve el número de dígitos del número x.
 *     entero función extraeDigito(entero x,entero c).
 *     Devuelve el dígito en la posición c del número x,
 *     empezando a contar por la izquierda. Por ejemplo, extraeDigito(23456,2) devuelve 3.
 */

import java.util.Scanner;

public class Ejercicio63SinCadenas {
    public static void main(String[] args) {
        //Variables
        int num;   
        //Inicializamos Scanner
        @SuppressWarnings("resource")
        Scanner reader = new Scanner(System.in);
        //Empezamos el programa
        //Obligamos a introducir un numero que sea binario.
        do{
            System.out.println("Introduzca un numero binario: ");
            num = reader.nextInt();
        }
        while(esBinario(num)==false);
        //Mostramos el numero de cifras del numero introducido (Por usar el método, sino, no se usa)
        System.out.println("Has introducido un numero de "+ cifras(num) + " cifras");
        //Mostramos por pantalla el resultado
        System.out.println("El tercer numero empezando por la izquierda es: " + extraerDigito(num,3));
        System.out.println("El numero " + num + " en decimal es: " + pasaBinADec(num));
        //Comprobamos que finaliza por completo
        System.out.print("END_OF_LINE");
    }   
   
    //Hay que comprobar que el numero introducido sea binario, "1" y "0".
    static boolean esBinario(int num){
        for (int i = 1; i <= cifras(num); i++){
            if (extraerDigito(num,i) != 0 && extraerDigito(num,i) != 1){
                return false;
            }
        }
        return true;
    }
   
    //Así es mas facil saber el número de cifras que tiene el número introducido.
    static int cifras(int num) {
        int cifras = 0;
        do{
            num = num / 10;
            cifras++;
        }while(num != 0);
        return cifras;
    }
   
    static int extraerDigito(int num, int pos) {
        int divisor = 10;
        for (int i = 1; i <= cifras(num) - pos; i++) {
            divisor = divisor * 10;
        }
        num = num % divisor;
        divisor = divisor / 10;
        return (num / divisor);
    }

    static int pasaBinADec(int num){
            int resto, decimal=0, i=0;
            while (num != 0){
               resto = num % 10;
               decimal = decimal + (resto * (int) Math.pow(2, i)); //(Fórmula -> cambio de base)
               i++;
               num = num / 10;
            }
            return decimal;
        }

}

Ejercicio 63 con Cadenas

/*
 * 63.    Hacer un programa que pida por teclado un número binario forzando al usuario
 *  a que realmente introduzca un número formado por ceros y unos. A continuación
 *  escriba en pantalla el valor decimal del número introducido. Para resolver
 *  este programa es necesario utilizar los métodos siguientes:
 *
 *   lógico función esBinario(entero x). Devuelve verdadero o falso si el número  x es binario o no.
 *   entero función cifras(entero x). Devuelve el número de dígitos del número x.
 *     entero función extraeDigito(entero x,entero c).
 *     Devuelve el dígito en la posición c del número x,
 *     empezando a contar por la izquierda. Por ejemplo, extraeDigito(23456,2) devuelve 3.
 */


import java.util.Scanner;

public class Ejercicio63 {
    public static void main(String[] args) {
        //Variables
        int num;
      
        //Inicializamos Scanner
        @SuppressWarnings("resource")
        Scanner reader = new Scanner(System.in);
        //Empezamos el programa
        //Obligamos a introducir un numero que sea binario.
        do{
            System.out.println("Introduzca un numero binario: ");
            num = reader.nextInt();
        }
        while(esBinario(num)==false);
        //Mostramos el numero de cifras del numero introducido (Por usar el método, sino, no se usa)
        System.out.println("Has introducido un numero de "+ cifras(num) + " cifras");
        //Mostramos por pantalla el resultado
        // Esto no se usa---->>>    System.out.println("El tercer numero empezando por la izquierda es: " + extraerDigito(num,3));
        System.out.println("El numero " + num + " en decimal es: " + pasaBinADec(num));
        //Comprobamos que finaliza por completo
        System.out.print("END_OF_LINE");
    }
  
    //Hay que comprobar que el numero introducido sea binario, "1" y "0".
    static boolean esBinario(int num){
        String str = String.valueOf(num);
        for(int i=0; i<str.length(); i++){
            if (str.charAt(i) != '0' && str.charAt(i) != '1'){
                return false;
            }
        }
        return true;
    }
    //Así es mas facil saber el número de cifras que tiene el número introducido.
    static int cifras(int num){
        int cifras;
        String str = String.valueOf(num);
        cifras = str.length();
        return cifras;
    }
    //La funcion extraerDigito es super sencilla
    static int extraerDigito(int num, int pos){  
        String str = String.valueOf(num);
        /* Si la cadena es "Hola Mundo" y queremos sacar la M,
         * tenemos que colocar el puntero justo antes, para sacar la M.
         * Es decir, posicion inicial 5, final 6. Y de 5->6 Hay una 'M' en medio,
         * que es lo que nos devuelve .substring(5,6).
         */
        int digito = Integer.parseInt(str.substring((pos-1),pos));
        return digito;
    }
    static int pasaBinADec(int num){
            int resto, decimal=0, i=0;
            while (num != 0){
               resto = num % 10;
               decimal = decimal + (resto * (int) Math.pow(2, i)); //(Fórmula -> cambio de base)
               i++;
               num = num / 10;
            }
            return decimal;
        }

}

Ejercicio62 PRO

/*
 * 62.    Diseñar un método de nombre cifras que devuelva
 *  el número de cifras que tiene un valor
 *  de tipo entero que se le pasa como parámetro
 */

import java.util.Scanner;

public class Ejercicio62 {
    public static void main(String[] args) {
        //Variables
        int num;
       
        //Inicializamos Scanner
        @SuppressWarnings("resource")
        Scanner reader = new Scanner(System.in);
        //Empezamos el programa
        System.out.println("Introduce un numero: ");
        num = reader.nextInt();
        System.out.println(num + " tiene " + cifras(num) + " cifras.");
       
        //Comprobamos que finaliza por completo
        System.out.print("END_OF_LINE");
    }
    static int cifras(int x){
        int numCifras = 1;
        x = x/10;
        while(x != 0){
            numCifras++;
            x = x/10;
        }
        return numCifras;
    }
}

Ejercicio 61 PRO

 Dos números son amigos si la suma de los divisores del primer excepto el mismo es igual al segundo y viceversa. Hacer un programa que pida dos números por teclado y averigüe si son amigos. Emplear el método sumaDivisores, que calcule la suma de los divisores de un número menos el propio número leído.

(220, 284) (17.296, 18.416) (9.363.584, 9.437.056)

import java.util.Scanner;

public class Ejercicio61 {
    public static void main(String[] args) {
        //Variables
        int num1;
        int num2;
       
        //Inicializamos Scanner
        @SuppressWarnings("resource")
        Scanner reader = new Scanner(System.in);
        //Empezamos el programa
        System.out.println("Introduce el primer numero: ");
        num1 = reader.nextInt();
        System.out.println("Introduce el segundo numero: ");
        num2 = reader.nextInt();
       
        if( sonamigos(num1,num2) == true){
            System.out.println("Los numeros " + num1 + " y " + num2 + " son amigos.");
        }else{
            System.out.println("Los numeros " + num1 + " y " + num2 + " no son amigos.");
        };
       
        //Comprobamos que finaliza por completo
        System.out.print("END_OF_LINE");
    }
    public static int sumaDivisores(int n) {
        int sumaDiv = 0;

        for (int j = 1; j <= (n / 2); j++) {
            if (n % j == 0) {
                sumaDiv = sumaDiv + j;
            }
        }
        return sumaDiv;
    }
    static boolean sonamigos(int num1, int num2) {
        if ( num2 == sumaDivisores(num1)){
            return true;
        }if(sumaDivisores(num2) == num1){
            return true;
        }else{
            return false;
        }       
    }
}

Juego del ahorcado en Java (Modo Texto)

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;


@SuppressWarnings("serial")
public class Ahorcado extends Applet
    implements KeyListener
{

    final int NUMPALABRAS = 12;
    final int MAXINTENTOS = 5;
      // No deberíamos modificar el número máximo de intentos,
      // porque vamos a dibujar 5 "cosas" cuando se equivoque

    String palabra;        // La palabra a adivinar
    StringBuffer intento;  // Lo que el jugador 2 va consiguiendo
    String letras="";      // Las letras que se han probado

    int oportunidades;     // El número de intentos permitido
    char letra;            // Cada letra que prueba el jug. dos
    int i;                 // Para mirar cada letra, con "for"
    boolean acertado;      // Si ha acertado alguna letra
    boolean terminado;     // Si la partida ha terminado

    String datosPalabras []=
    {
        "Alicante","Barcelona","Coruña","Guadalajara","Madrid",
        "Malaga","Ourense","Sevilla","Toledo",
        "Valencia","Valladolid","Zaragoza"
    };


    void PrimerFallo(Graphics g)
    {   // Primer fallo: Dibujamos la "plataforma"
        g.setColor(Color.cyan);
        g.drawLine(20, 180,  120, 180);
    }


    void SegundoFallo(Graphics g)
    {   // Segundo fallo: Dibujamos el "palo vertical"
        g.drawLine(100, 180,  100, 125);
    }


    void TercerFallo(Graphics g)
    {   // Tercer fallo: Dibujamos el "palo superior"
        g.drawLine(100, 125,   70, 125);
    }


    void CuartoFallo(Graphics g)
    {  // Cuarto fallo: Dibujamos la "cuerda"
       g.drawLine(70, 125,   70, 130);
    }


    void QuintoFallo(Graphics g)
    {  // Quinto fallo: Dibujamos la "persona"
      
        //int j;

            // Cabeza
        g.setColor(Color.yellow);
        g.drawOval(62, 130, 16, 16);
            // Tronco
        g.drawLine(70, 146,   70, 160);
            // Brazos
        g.drawLine(50, 150,  90, 150);
            // Piernas
        g.drawLine(70, 160,   60, 175);
        g.drawLine(70, 160,   80, 175);
    }


    public void init() {

        // Valores iniciales
        i = (int) Math.round(Math.random() * NUMPALABRAS);
        palabra = datosPalabras[ i ];
        oportunidades = MAXINTENTOS;

        // Relleno con * y " " lo que ve Jug. 2
        intento = new StringBuffer(palabra);

        for (i=1; i<=palabra.length(); i++)
        if (palabra.charAt(i-1) == ' ' )
            intento.setCharAt(i-1, ' ');
        else
            intento.setCharAt(i-1, '*');

        terminado = false;
        requestFocus();
        addKeyListener(this);
    }


    public void paint(Graphics g) {

        // Primero borro el fondo en negro
        g.setColor( Color.black );
        g.fillRect( 0, 0, 639, 479 );

        // Digo cuantos intentos le quedan
        g.setColor(Color.white);
        g.drawString("Te quedan " + oportunidades + " intentos",
            80, 18);

        // Le muestro como va
        g.drawString(intento.toString(),
            80, 32);

        // Muestro las letras probadas
        g.setColor(Color.yellow);
        g.drawString("Letras intentadas:" + letras,
            20, 72);

        // Y le pido otra letra
        g.drawString("Que letra?", 20, 60);

        // Dibujo lo que corresponde del "patibulo"
        if (oportunidades <= 4) PrimerFallo(g);
        if (oportunidades <= 3) SegundoFallo(g);
        if (oportunidades <= 2) TercerFallo(g);
        if (oportunidades <= 1) CuartoFallo(g);
        // Si se acabo: Le felicito o le digo cual era
        if ((oportunidades <= 0) || (palabra.equals(intento.toString()))) {
            terminado = true;
            if ( palabra.equals(intento.toString() ) )
                g.drawString("Acertaste!",
                    20, 100);
            else
            {
            g.drawString("Lo siento.  Era: " + palabra,
                20, 100);
            QuintoFallo(g);
            }
        }
    }


    public void keyTyped(KeyEvent e) {
        letra=e.getKeyChar();
        if (! terminado) {
            letras=letras+letra;

            acertado = false;      // Miro a ver si ha acertado
            for (i=1; i<=palabra.length(); i++)
              if (Character.toLowerCase(letra) == Character.toLowerCase(palabra.charAt(i-1)))
                {
                intento.setCharAt(i-1, palabra.charAt(i-1) );
                acertado = true;
                }

            if ( ! acertado )     // Si falló, le queda un intento menos
              oportunidades --;
        }
        repaint();
        e.consume();
    }

    public void keyReleased(KeyEvent e) {
    }

    public void keyPressed(KeyEvent e) {
    }

}

//Son 166 líneas un juego simple del ahorcado.
//Os dejo también el archivo en Java

//Ahorcado.java

Welcome back!

Volvemos de las vacaciones autodestructivas de navidad.

Espero este fin de semana actualizar el blog con los apuntes de FOL actualizados, los ejercicios de SINF, con unas cuantas cosas de PROG... Muchos teneis problemillas con Programación, asique iré ampliando los conocimientos básicos, recordad:

"A programar se aprende programando"

:p