Colección de figuras en Java

DESCARGAR



import java.util.Scanner;

/**
 *
 */

public class Main {

/**
* Lee una colección de figuras con su identificador y sus medidas básicas asociadas
* por la entrada estándar y devuelve sus áreas y perímetros, en orden ascendente respecto
* a su identificador de figura.
*
* La entrada será de la forma siguiente
* <LetraTipoFigura> <número_identificativo_unico> <lista_medidas>
*
* donde <LetraTipoFigura> será una T por triángulo, una R por rectángulo y una C por círculo,
* <número_identificativo_único> será un número long único por cada figura, independientemente del
* tipo de figura que sea y <lista_medidas> serán tres números dobles para un triángulo, representando
* la longitud de sus tres lados, dos números dobles para un rectángulo, representando la longitud de
* sus lados y un único número para un círculo, representando la longitud del radio del círculo.
*
* La salida será una línea por cada figura de la entrada, ordenadas por su identificador único de la
* forma:
* <número_identificativo único> <perímetro_figura> <área_figura>
* donde tanto el perímetro como el área se darán con dos dígitos decimales.
* @param args
*/
public static void main(String[] args) {
Scanner lee = new Scanner(System.in);
ColeccionFiguras cf = new ColeccionFiguras();

while (lee.hasNext()){
String tipoFig = lee.next();
long id = lee.nextLong();
Figura f=null;
switch (tipoFig) {
case "T":  f = new Triangulo(id, lee.nextDouble(), lee.nextDouble(), lee.nextDouble()); break;
case "R":  f = new Rectangulo(id, lee.nextDouble(), lee.nextDouble()); break;
case "C":  f = new Circulo(id, lee.nextDouble()); break;
}

cf.add(f);
}

cf.ordenaFiguras();

System.out.print(cf);;
}

}








public class Circulo extends Figura {

}







/**
 * Clase que permite almacenar un conjunto de figuras y realizar algunas operaciones con la colección.

 *
 */
public class ColeccionFiguras implements ListaFiguras{
}










/**
 * Interfaz que declara un método para comparar dos figuras.
 */
public interface Comparable {
/**
* Compara según el orden definido por el identificador de una figura la figura this con la figura fig que se pasa como parámetro.
* @param fig Objeto Figura a comparar con this.
* @return Devuelve un -1 si this es menor que o, 0 si es igual, y 1 si es mayor.
*/
int comparaA(Figura fig);

}








/** Clase abstracta que representa figuras geométricas planas.
 * 
 */
public abstract class Figura implements Comparable{
protected long idFigura; //Identificador único de una figura
public long getIdFigura(){
   return idFigura;
}
/**
* Calcula el área de una figura geométrica plana.
* @return El área en unidades de longitud al cuadrado.
*/
public abstract double area();

/**
* Calcula el perímetro de una figura geométrica plana.
* @return El perímetro en unidades de longitud al cuadrado.
*/
public abstract double perimetro();
}









/**
 * Define un conjunto de operaciones para manipular una colección de figuras.
 */


public interface ListaFiguras {

/** 
* Añade una figura a la colección.
* @param f La figura a añadir.
*/
void add (Figura f);

/**
* Ordena las figuras que pertenezcan al objeto de la clase que implementa el interfaz ListaFiguras.
* Después de llamar a éste método las figuras están en orden de menor a mayor respecto a su atributo
* identificador.
*/
void ordenaFiguras ();
}










public class Rectangulo extends Figura {

}












public class Triangulo extends Figura {

}


Calcular el primer cuartil en Java

/**
 * Se pide construir un programa que lea una serie de números enteros (tipo int) por la entrada estándar
 * y devuelva el primer cuartil de la serie. El primer cuartil es el número más pequeño de la serie que es mayor
 * o igual que al menos el 25% del total de los números de la serie. El 25% se calculará redondeando por arriba.
 * El primer número de la entrada será el tamaño n (1 <= n <= 100) de la serie de números y a continuación de él
 * vendrán todos los números de la serie. La salida será la serie leída ordenada de menor a mayor en una única línea
 * y separando cada valor con un blanco (excluido el último) y en otra línea el primer cuartil calculado.
 * Ejemplo.
 * Entrada
 * 8 2 3 10 -11 200 0 7 8
 * Salida
 * -11 0 2 3 7 8 10 200
 * 0
 */
public class PrimerCuartil{

/**
* Método que ordena un array de enteros por el algortimo de la burbuja. El array
* de entrada queda modificado de forma que al final se encuentra ordenado.
* @param nums El array a ordenar.
* @return Una referencia al array ordenado.
*/
public static int[] ordenaBurbuja (int[] nums){
for (int i=1; i < nums.length; i++)
for (int j=nums.length-1; j >= i; j--){
if (nums[j-1] > nums[j]) {
int aux = nums[j-1];
nums[j-1] = nums[j];
nums[j] = aux;
}
}
return nums;
}


public static void main (String[] args){

// Leemos el número de ints en la serie y todos los números de la serie
java.util.Scanner scan = new java.util.Scanner(System.in);

int tam = scan.nextInt();

int[] serie = new int[tam];

for (int i=0; i < tam; i++){
serie[i] = scan.nextInt();
}
scan.close();

// Ordenamos el array
int[] serieOrdenada = ordenaBurbuja(serie);

// Enviamos la serie a la salida estándar. Observar que ahora "serie" está
// ordenada debido al comportamiento del método ordenaBurbuja.
// El último elemento es un caso especial puesto que no le sigue un blanco.
for (int i=0; i < tam-1; i++){
System.out.print(serie[i]+" ");
}
System.out.println(serie[tam-1]);

// Calculamos la posición del cuartil
int pos_cuartil = (int)Math.ceil(0.25*tam) - 1;

// Devolvemos el valor del primer cuartil.
System.out.println(serieOrdenada[pos_cuartil]);

}
}

Juego de la vida en Java

DESCARGAR


import java.util.Scanner;

public class Main {
public static void main(String[] args){
Scanner lee = new Scanner(System.in);
// Leemos el tamaño del mundo
// Creamos un objeto que represente el mundo
Mundo mundo = new Mundo(lee.nextInt(),lee.nextInt());

// Leemos el número de células en la posición inicial
int numPos = lee.nextInt();

// Para el número de células iniciales
for (int i = 1; i <= numPos; i++){
// leemos la posición de la célula
// la añadimos al mundo
mundo.ponCelulaEn(lee.nextInt(),lee.nextInt());
}
// Leemos el número de generaciones
int numSim = lee.nextInt();

lee.close();
// Para el número de generaciones leído menos 1
// (la posición inicial es la 1º genración)
for (int i = 1; i < numSim; i++){
// Calculamos el nacimiento y muerte de células
boolean[][] nextGen = mundo.calculaCambiosSigGeneracion();
// Aplicamos los nacimientos y muertes para obtener la siguiente generación
mundo.aplicaCambiosSigGeneracion(nextGen);
}

// Enviamos a la salida estándar el estado del mundo en la última generación
System.out.print(mundo);
}

}





/*
 * Clase que implementa un mundo de ciertas dimensiones para simular el juego de la vida.
 */
public class Mundo {

/** Almacena la matriz que representa el mundo,
*  cada celda puede ser:<p>
*  
*  &emsp; true: hay célula en la celda<p>
*  &emsp; false: no hay célula en la celda<p>
*/
private boolean[][] _hayCelula;

/** Crea un objeto que representa el mundo
* de un tamaño dado.
* @param f Número de filas del mundo
* @param c Número de columnas del mundo
*/
public Mundo(int f, int c) {
_hayCelula = new boolean[f][c];
}

/** Añade una célula en la posición dada.
* 
* @param f Fila donde se pone la célula.
* @param c Columna donde pone la célula.
*/
public void ponCelulaEn(int f, int c) {
this._hayCelula[f][c] = true;
}
/** 
* Calcula qué celdas cambiarán en la siguiente generación del juego de la vida.
* Una celda cambia si tiene una célula y esta muere en la siguiente generación o
* no tiene célula y una célula nacerá en la siguiente generación.
* 
* @return  devuelve una matriz de booleanos de tamaño igual al mundo actual donde 
* una celda tiene el valor true si y solo si cambia su estado en la siguiente
* generación del juego de la vida.
*/
public boolean[][] calculaCambiosSigGeneracion() {
boolean[][] result = new boolean[_hayCelula.length][_hayCelula[0].length];
for (int i=0; i < _hayCelula.length; i++)
for (int j=0; j < _hayCelula[0].length; j++){
int numVec = this.calculaNumVecinas(i,j);
if (_hayCelula[i][j]) {// Si hay célula, esta puede morir
result[i][j] = (numVec == 0 || numVec == 1 || numVec > 3);
} else // si no hay célula, puede nacer
result[i][j] = numVec == 3;
}
return result;
}
private int calculaNumVecinas(int i, int j) {
int num = 0;
for (int l = -1; l < 2; l++)
for (int k = -1; k < 2; k++)
if (this.esCeldaValida(i+l,j+k) && !(l==0 && k==0))
if (_hayCelula[i+l][j+k])
num++;
return num;
}
private boolean esCeldaValida(int i, int j) {
return (0 <= i && i < _hayCelula.length && 0 <= j && j < _hayCelula[0].length);
}
/**
* Aplica los cambios dados en nextGen al estado actual del mundo.
* @param nextGen Una matriz de booleanos donde una celda es true si y sólo si
* en la siguiente generación esa celda cambia: si tiene célula, ésta muere
* y si no tiene célula, nacerá una nueva.
*/
public void aplicaCambiosSigGeneracion(boolean[][] nextGen) {
for (int i=0; i < _hayCelula.length; i++)
for (int j=0; j < _hayCelula[0].length; j++)
_hayCelula[i][j] ^= nextGen[i][j];
}
/** 
* Devuelve una cadena que representa el estado actual del mundo.
* Cada fila del mundo viene dada en una línea completa, con una celda vacía representada
* por un punto . y una celda llena representada por un asterísco *. 
*/
@Override
public String toString(){
StringBuffer sb = new StringBuffer();
for (int i=0; i < _hayCelula.length; i++){
for (int j=0; j < _hayCelula[0].length; j++){
if (_hayCelula[i][j])
sb.append('*');
else
sb.append('.');
}
sb.append('\n');
}
return sb.toString();

}
}

Histograma en Java

import java.util.Scanner;

/**

Escribir un programa que tome varias palabras, 100 como máximo, en
minúsculas, separadas por espacios, desde la entrada estándar y
devuelva un histograma por cada una de las palabras dando la
frecuencia de aparición de cada letra, así como un histograma final
para todas las palabras. Un histograma debe visualizarse en orden
alfabético siguiendo las siguientes directrices: una línea completa
por cada letra del alfabeto español (27 letras) que aparezca en la
palabra, comenzando la línea por la letra seguida de dos puntos y un
espacio a continuación. Después de eso, tantos símbolos de suma (+)
como la frecuencia de aparición de la letra en la palabra. Si la letra
tiene frecuencia cero, no debe aparecer su línea en el histograma.
Cada histograma debe ser separado con una línea vacía del siguiente,
exceptuando el último. El histograma final debe mostrar la frecuencia
de las letras en todas las palabras de entrada.

Ejemplo

Entrada

hola lala

Salida

a: +
h: +
l: +
o: +

a: ++
l: ++

a: +++
h: +
l: +++
o: +
 */


public class Main {

/**
* @param args
*/
public static void main(String[] args) {
Scanner lee = new Scanner(System.in);
Histograma global = new Histograma();

// Mientras haya palabras en la entrada
while (lee.hasNext()){
//      Leer palabra
String pal = lee.next();

// Calcular histograma
Histograma hpal = new Histograma();
hpal.aumentaFrecuencias(pal);
global.aumentaFrecuencias(pal);
// Imprimir Histograma
System.out.print(hpal);
// Imprimir una línea en blanco
System.out.println();
}

// Imprimir histograma global
System.out.print(global);
}

}

class Histograma {
enum Letras {a,b,c,d,e,f,g,h,i,j,k,l,m,n,ñ,o,p,q,r,s,t,u,v,w,x,y,z};

private int[] _frecuencias;

public Histograma(){
_frecuencias = new int[Letras.values().length];
}

public void aumentaFrecuencias(String s){
for (int i=0; i < s.length(); i++){
_frecuencias[Letras.valueOf(s.substring(i, i+1)).ordinal()]++;
}
}

@Override
public String toString(){
StringBuffer sb = new StringBuffer();
for (Letras l:Letras.values() ){
if (_frecuencias[l.ordinal()] > 0){
String name=l.name();
sb.append(name+": ");
for (int i=1; i <= _frecuencias[l.ordinal()]; i++ ){
sb.append('+');
}
sb.append("\n");
}
}

return sb.toString();
}
}

Reescribir fecha en Java

public class Main {

/**
* @param args No se utiliza
*/
public static void main(String[] args) {

java.util.Scanner lee = new java.util.Scanner(System.in);

//Leemos la fecha de una sóla línea
String fechaIn = lee.nextLine();

//Eliminamos blancos iniciales y finales
fechaIn = fechaIn.trim();
//Buscamos el primer de
int de1 = fechaIn.indexOf('d');

//Seleccionamos la substring que representa el dia
String dia = fechaIn.substring(0, de1);

//Eliminamos blancos al final del año
dia = dia.trim();

//Seguimos procesando la fecha para obtener el mes
fechaIn = fechaIn.substring(de1+3);

fechaIn = fechaIn.trim();
//Buscamos el segundo de. Hay que buscar "de" por la colisión con diciembre
int de2 = fechaIn.indexOf("de");

//Seleccionamos la substring que representa el mes
String mes = fechaIn.substring(0, de2);

mes = mes.trim();

//Seguimos procesando la fecha para obtener el año
fechaIn = fechaIn.substring(de2+3);

fechaIn = fechaIn.trim();

//Seleccionamos la substring que representa el año
String agno = fechaIn;

//Imprimimos la fecha en el formato pedido
System.out.println(agno + "-" + mes + "-" + dia);

}

}