Universidad Carlos III de Madrid

Solución

No aplica. Preguntad al profesor.

Solución

No aplica. Preguntar al profesor

Solución

La solución se puede ver en el siguiente listado:

/**
 * Carlos III University, Madrid
 *
 */


/**
 *
 * Prints a chess board out the console
 */

class ChessBoard
{
  // Chess board as a 2-dimensional array
  public void prints()
  {
    char board[][] = new char[8][8];
    char cell = '0';

    for (int row = 0; row < 8; row++)
    {
      for (int column = 0; column < 8; column++)
      {
        if (column == 0)
        {
          if (row % 2 == 0)
          {
            // Black
        	  cell = 'B';
          }
          else
          { // White
        	  cell = 'W';
          }
        }
        else
        {
          if (cell == 'W')
        	  cell = 'B';
          else
        	  cell = 'W';
        }

        board[row][column] = cell;
      }
    }

    // Prints out
    for (int row = 0; row < 8; row++)
    {
      for (int column = 0; column < 8; column++)
      {
        System.out.print(board[row][column]);
      }
      System.out.println();
    }
  }

  // Testing
  public static void main(String args[])
  {
    ChessBoard t = new ChessBoard();
    t.prints();
  } //main

} // ChessBoard

	  

Resultando un error de compilación de este estilo: Main.java:7: Figura is abstract; cannot be instantiated Figura f = new Figura(Figura.BLANCO);

Solución

La solución se puede ver en el siguiente listado:

public class For2While
{

	public static void main(String [] args)
	{
	
		// loop for
		for (int i=0;i<10;i++)
		{
			System.out.print(i);
		}
		System.out.println("");
		
		// loop while
		int j = 0;
		while (j<10)
		{
			System.out.print(j);		
			j++;
		}
		System.out.println("");	
	}

} // For2While

Solución

La solución se puede ver en el siguiente listado:

public class While2For
{
	public final static int MAX_ITEMS = 10;
	
	public static void main(String [] args)
	{
		int [] items = { 2, 4, 6, 8, 10, 9, 7, 5, 3, 1};
		boolean found = false;
		int     find  = 10;
		
		// While loop
		int i = 0;
		while ((!found) && (i<MAX_ITEMS))
		{
			found = (items[i]==find);		
			i++;
		}	
		System.out.println(i-1);
		
		// loop for
		int j = 0;
		for (j=0;j<MAX_ITEMS;j++)
		{
			if (items[j]==find)
			{	
				found = true;
				break;
			}
		}
		System.out.println(j);		
	}
} // While2Java

Solución

La solución se puede ver en el siguiente listado:

/**
 * Carlos III University, Madrid
 * 
 */


/**
 *
 * Arrays review
 */

class ArraysReview
{

  /** Calculates the biggest integer */
  public void exercise1()
  {
    int elements [] = new int[200];

    // Fills the array
    for (int i=0;i<200;i++)
    {
         elements[i] = i+1;
    }

    // Calculates the biggest number
    int biggest = Integer.MIN_VALUE;
    for (int i=0;i<200;i++)
    {
         if (elements[i]>biggest)
         {
        	 biggest = elements[i];
         }
    }
    System.out.println("The biggest is: " + biggest);
  } // Exercise 1


   // Mean of the elements
   public void exercise2()
   {
     long elements [] = new long[200];

     // Fills the array
     for (int i=0;i<200;i++)
     {
       elements[i] = i+1;
     }

     // Summation of the elements
     long sum = 0;
     for (int i=0;i<200;i++)
     {
    	 sum = sum + elements[i];
     }
     // Don't forget to change the type due to the precision
     double mean = (double)sum/(double)200;
     System.out.println("The mean is: " + mean);
    } // exercise2

    // Shows the even elements in the array
    public void exercise3()
    {
       int elements [] = new int[200];

       // Fills the array
       for (int i=0;i<200;i++)
       {
            elements[i] = i+1;
       }

       // Prints the even elements
       for (int i=0;i<200;i++)
       {
            if (elements[i] % 2 == 0)
                     System.out.println(elements[i]);
       }
    } // exercise3


    // Summation of the elements
    public void exercise4()
    {
        long elements [] = new long[200];

        // Fills the array
        for (int i=0;i<200;i++)
        {
                elements[i] = i+1;
        }

        // Sum all the elements
        long sum = 0;
        for (int i=0;i<200;i++)
        {
        	sum = sum+ elements[i];
        }
        System.out.println("The summation is: " + sum);
     } // Exercise4


     // Testing
     public static void main(String args[])
     {
        ArraysReview r = new ArraysReview();
        r.exercise1();
        r.exercise2();
        r.exercise3();
        r.exercise4();
     } // main

} // ArraysReview

	  

Solución

Una posible solución se lista a continuación:

/**
 * Carlos III University, Madrid
 * Systems Programming.
 *  
 * Program that detects if a word or sentence is palindrome.
 */


/**
 *
 * Palindrome class.
 */
public class Palindrome
{

    /**
     * Detects if a word or sentence is palindrome
     * @param string String
     * @return boolean
     */
    public boolean isPalindrome(String string)
    {
        // By default, string is palindrome
        boolean isPalin = true;
        // To detect the end of the loop -the end of the string-.
        boolean end = false;
        // Convert the characters to lower-letters and omit the blank characters to avoid problems
        String normalizedString = string.replaceAll(" ","");
        normalizedString = normalizedString.toLowerCase();

        // Initialize the position in left and right ends
        int left_to_right = 0;
        int right_to_left = normalizedString.length() - 1;

        // Go along the string
        while ((isPalin) && (!end))
        {
            // Compare the characters
        	isPalin = (normalizedString.charAt(left_to_right) == normalizedString.charAt(right_to_left));
            
        	left_to_right++;
        	right_to_left--;

            // Check if we have finished.
            end = ((right_to_left == -1) || (left_to_right ==normalizedString.length()));
        }

        return isPalin;
    }

    public static void main(String [] args)
    {
        boolean palindrome = false;
        Palindrome p = new Palindrome();

        System.out.println("==========");
        System.out.println("PALYNDROME");
        System.out.println("==========");

        palindrome = p.isPalindrome("Ana");
        System.out.println("Ana: " + palindrome);

        palindrome = p.isPalindrome("Level");
        System.out.println("Level: " + palindrome);
        
        palindrome = p.isPalindrome("Si a la ingenieria telematica");
        System.out.println("Si a la ingenieria telematica: " + palindrome);

        palindrome = p.isPalindrome("Dabale arroz a la zorra el abad");
        System.out.println("Dabale arroz a la zorra el abad: " + palindrome);
        
        palindrome = p.isPalindrome("Satan oscillate my metallic sonatas");
        System.out.println("Satan oscillate my metallic sonatas: " + palindrome);
        
    }


} // Palindrome

	  

Solución

La solución se puede ver en el siguiente listado:

/**
 * Class to calculate factorials
 */
class FactorialEx {

   // FOR-BASED SOLUTION
   /**
    * Calculates the factorial of an integer with a 'for' loop
    *
    * @param n Integer whose factorial is going to be calculated
    * @return Factorial of the integer 'n'
    */
   public static int fact( int n ) {
    
      int result = 1;

      for (int i = 1; i <= n; i++) {
    	  result *= i;
      }

      return result;
   }
   
   // WHILE-BASED SOLUTION
   /**
    * Calculates the factorial of an integer with a 'while' loop
    * 
    * @param n Integer whose factorial is going to be calculated
    * @return Factorial of the integer 'n'
    */
   public static int factWhile( int n ) {
    
      int result = 1;
      
      int i = 1;
      while ( i <= n ) {
    	  result *= i;
         i++; // The auto-increment statement can also be stated in the 'while' condition
      }

      return result;
   }
   
   // SOLUTION WITH DO-WHILE LOOP  
  
  
   /**
    * Main method, for testing purpose
    * The program gets as argument the number whose factorial is going
    * to be calculated.
    */
   public static void main(String[] args) {
    
      // Integer variables to store the number and the factorial result
      int number;
      int result;

      // Exceptions are managed (try-catch block)       
      try {
         // Gets the number whose factorial is going to be calculated
         number = new Integer( args[0] ).intValue();
          
          
         // Factorial with for loop
         System.out.println( "Testing 'for' loop:" );    
          
         // Prints the beginning of the message
         System.out.print(number + "! = ");
          
         // Calculates the factorial
         result = fact(number);
          
         // Prints the result
         System.out.println(result + "\n");          
          
         // Factorial with while loop
         System.out.println( "Testing 'while' loop:" );
          
         // Prints the beginning of the message
         System.out.print(number + "! = ");
          
         // Calculates the factorial
         result = factWhile( number );
          
         // Prints the result
         System.out.println(result + "\n");
         
      } catch ( Exception e ) {
         // error
         System.out.println( "Error: An integer number was expected" );
      }
      
  }
  
}


	  

Aclaración

El número de filas y columnas de la matriz deberá indicarse en el momento de creación del objeto.

Solución

La solución se puede ver en el siguiente listado:

/**
 * <p>This class encapsulates the behavior of a matrix formed by integer numbers.
 * Implemented characteristics:
 *    - Number of rows and columns can be defined
 *    - Inicialization element can be defined
 *    - Offers a 'sum' function without modifying the matrix object 
 *   
 * </p>
 *
 * @author UC3M - Telematics Department
 * @version 1.0
 */
public class Matrix
{
    /** Where elements are stored */
    private int elements[][];
    private int rows;
    private int columns;

    /** Object constructor, taking into account rows and columns */
    public Matrix(int rows, int columns, int initElement)
    {
        elements = new int[rows][columns];
        this.rows = rows;
        this.columns = columns;

        // Initialization
        for (int row=0;row<rows;row++)
            for (int column = 0; column < columns; column++)
                elements[row][column] = initElement;

    }

    /** Sums to the current matrix another 'm' matrix, returning the resulting one */
    /** It neither modifies the current matrix nor the second one which is added to the current one*/
    public Matrix sum(Matrix m) throws Exception
    {
        // We check the necessary conditions to sum the two matrix.
        if (this.rows != m.rows)
            throw new Exception ("Error: Matrixes with different number of rows cannot be sumed");

        if (this.columns != m.columns)
            throw new Exception ("Error: Matrixes with different number of rows cannot be sumed");

        Matrix aux = new Matrix(this.rows,this.columns,0);
        for (int row=0;row<rows;row++)
            for (int column = 0; column < columns; column++)
                aux.elements[row][column] =
                       this.elements[row][column] +
                       m.elements[row][column];
        return aux;
    }


    /** Testing the results */
    public void print()
    {
        for (int row=0;row<rows;row++)
        {
            for (int column = 0; column < columns; column++)
            {
                System.out.print(elements[row][column] + "-");
            }
            System.out.println("");
         }
    }


    /** Testing */
    public static void main(String [] args)
    {
        Matrix m1, m2, m3, m4;
        m1 = new Matrix(2,3,1);
        m2 = new Matrix(3,2,2);
        m3 = new Matrix(2,3,3);

        try
        {
            m4 = m1.sum(m2);            
        }
        catch(Exception ex)
        {
            System.out.println(ex);
        }

        try
        {
            m4 = m2.sum(m3);
        }
        catch(Exception ex)
        {
            System.out.println(ex);
        }

        try
        {
            m4 = m1.sum(m3);
            System.out.println("m1:");
            m1.print();
            System.out.println("m3:");
            m3.print();
            System.out.println("m1+m3:");
            m4.print();
        }
        catch(Exception ex)
        {
            System.out.println(ex);
        }
    }


} // Matrix

	  

Aclaración

Puede encontrar información de la clase Vector en el siguiente archivo: Vector.pdf

Solución

La solución se puede ver en el siguiente listado:

import java.util.Enumeration;
import java.util.Vector;

/**
  *
  * <p>String usages</p>
  *
  * @author UC3M Telematics Department
  * @version 1.0
  */
class MyString
{
	/**
	* Function which splits a string formed by substrings separated by
	* |, such as "Yes|No|Sometimes"
	* @param myString String String with the previous format
	* @return Vector Vector storing each of the substrings.
	*/
	public Vector split(String string)
	{
		Vector v = new Vector();
		String aux = "";
		for (int i=0; i<string.length();i++)
		{
			if (string.charAt(i) != '|')
			{
				aux += string.charAt(i);
			}
			else
			{
				v.add(aux);
				aux = "";
			}
		}
		//For the last substring.
		v.add(aux);
		return v;
	}
} // MyString

/** Class testing*/
public class Strings
{
	public static void main(String [] args)
	{
		MyString myString = new MyString();
		Vector v = myString.split("Yes|No|Sometimes");
		// Example of vector iteration
		Enumeration e = v.elements();
		while (e.hasMoreElements())
		{
			String s = (String)e.nextElement();
			System.out.println(s);
		}
	}
}