Problema 1A. Theatre Square [Codeforces]

Aqui un problema que resolví de http://www.codeforces.com
Problema 1A. Theatre Square

import java.math.BigInteger;
import java.util.Scanner;

/**
* Problema 1A - Theatre Square [http://www.codeforces.com]
*
* @author BreakDark
* @version 1.1 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int n, m, a; // para las dimensiones n*m y a*a
BigInteger r; // para el resultado final
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
while (Lee.hasNext()) {
n = Lee.nextInt();
m = Lee.nextInt();
a = Lee.nextInt();
n = (int) Math.ceil((double) n / a);
m = (int) Math.ceil((double) m / a);
r = new BigInteger(String.valueOf(n));
r = r.multiply(new BigInteger(String.valueOf(m)));
System.out.println(r);
}
}
}

110203 Hartals

/**
* 110203 - Hartals
* @author BreakDark
* @version 1.0 beta
* --- RESUELTO --- :)
*/
import java.util.*;

public class Main {

public static void main(String[] args) {
int t; // para el numero de casos
int n; // numero de dias en la simulación
int p; // numero de partidos
int[] ph=new int[120]; // para metro hartal para cada partido
int i,j; // para los indices
int caso; // para controlar los casos
Scanner Lee; // para leer los datos
BitSet dia; // para controlar los dias que hay huelga
int aux; // auxiliar
int c; // contador de dias que se perderian

// Aqui inicia le programa
Lee=new Scanner(System.in);
t=Lee.nextInt();
caso=1;
while(caso<=t){
n=Lee.nextInt();
p=Lee.nextInt();
dia=new BitSet(3700);
for(i=0;i ph[i]=Lee.nextInt();
for(i=0;i aux=ph[i];
//empieza en domingo
for(j=aux;j<=n;j+=aux){
if(!dia.get(j)){
dia.set(j);
//
//System.out.println("j="+j);
//
}
}
}
// descartamos los dias viernes y sabado
for(j=6;j<=n;j+=7){
if(dia.get(j))
dia.set(j,false);
if(dia.get(j+1))
dia.set(j+1,false);
}
// contamos los dias
c=0;
for(j=1;j<=n;j++){
if(dia.get(j))
c++;
//
//System.out.print("i="+j+":"+dia.get(j)+",");
//
}
System.out.println(c);
caso++;
}

}

}

110201 Secuencias saltarinas

import java.util.BitSet;
import java.util.Scanner;

/**
* 110201 - Secuencias Saltarinas [Programing-Challenges]
*
* @author BreakDark
* @version 3.0 beta
*/
// ACEPTADO!!! xD
class Main {
public static void main(String[] args) {
short n = 3005; // numero a verificar entre 1 y n-1
int[] secuencia; // para guardar la secuencia
int diferencia; // para calcular la diferencia absoluta
BitSet num; // para comprobar si todos los numeros posibles son
// utilizados
boolean saltarina; // para verificar si la secuencia es saltarina o no
Scanner Lee; // para leer los datos de entrada
int i; // para los bucles
// EL PROGRAMA INICIA AQUI!!!
Lee = new Scanner(System.in);
while (Lee.hasNext()) {
n = Lee.nextShort();
secuencia = new int[n];
for (i = 0; i < n; i++)
secuencia[i] = Lee.nextInt();
// revisamos si la secuencia es saltarina
num = new BitSet(n);
for (i = 1; i < n; i++) {
diferencia = secuencia[i - 1] - secuencia[i];
if (diferencia < 0)
diferencia = -diferencia;
// verificamos si esta en el rango
if (diferencia > 0 && diferencia < n)
num.set(diferencia);
}
// aqui preguntamos si todos los valores posibles fueron usados
saltarina = true;
for (i = 1; i < n; i++)
if (!num.get(i)) {
saltarina = false;
break;
}
if (saltarina)
System.out.println("Jolly");
else
System.out.println("Not jolly");
}
// FIN DEL PROGRAMA
}
}

110107 Jaque al jaque

import java.util.*;

/**
* 110107 - Jaque al jaque
*
* @author BreakDark
* @version 1.2 beta
*/
public class Main {
static char[][] Tab = new char[10][10]; // para el tablero de ajedrez

public static void main(String[] args) {
int d = 1; // número de configuraciones
String linea; // para leer una linea
Scanner Lee; // para leer los datos
int i, j; // los índices de la matriz
boolean sw; // par controlar que no haya un tablero vacio

// AQUI EMPIEZA EL PROGRAMA
Lee = new Scanner(System.in);
// leemos la entrada
do{
sw = true;
for(i = 0; i < 8; i++){
linea = Lee.nextLine();
for(j = 0; j < 8; j++){
Main.Tab[i][j] = linea.charAt(j);
if(Main.Tab[i][j] != '.')
sw = false;
}
}
if(!sw){
linea = Lee.nextLine(); // lee una linea en blanco
if(Main.evaluar('p', 'n', 'b', 'r', 'q', 'K'))
System.out.println("Game #" + d + ": white king is in check.");
else
if(Main.evaluar('P', 'N', 'B', 'R', 'Q', 'k'))
System.out.println("Game #" + d + ": black king is in check.");
else
System.out.println("Game #" + d + ": no king is in check.");
d++;
}
} while(!sw);
}

/**
* Método que evalua el tablero Retorna verdad si hay jaque. donde:
* evaluar(peon, caballo, alfil, torre, dama, rey);
*/
static boolean evaluar(char peon, char caballo, char alfil, char torre, char dama, char rey) {
int i, j; // los índices de la matriz
int k, l; // otros indices auxiliares
boolean sw; // para ver si se produce el jaque
boolean aux; // un auxiliar para no repetir procesos
// buscamos al rey
sw = false;
for(i = 0; i < 8; i++)
for(j = 0; j < 8; j++){
if(Main.Tab[i][j] == rey){
// pregunto si es atacado por un peon
if(rey == 'k'){
k=i+1;
if(k < 8){
l=j-1;
if((l >= 0) && (Main.Tab[k][l] == peon))
sw = true;
l=j+1;
if((l < 8) && (Main.Tab[k][l] == peon)&&!sw)
sw = true;
}
}
else{
k=i-1;
if(k >= 0){
l=j-1;
if((l > 0) && (Main.Tab[k][l] == peon))
sw = true;
l=j+1;
if((l < 8) && (Main.Tab[k][l] == peon)&&!sw)
sw = true;
}
}
if(!sw){
// pregunto si es atacado por una torre o una reina
// hacia el norte
k = i - 1;
aux = true;
while((k >= 0) && (aux)){
if(Main.Tab[k][j] != '.'){
if((Main.Tab[k][j] == torre) || (Main.Tab[k][j] == dama))
sw = true;
aux = false;
}
k--;
}
}
if(!sw){
// hacia el sur
k = i + 1;
aux = true;
while((k < 8) && (aux)){
if(Main.Tab[k][j] != '.'){
if((Main.Tab[k][j] == torre) || (Main.Tab[k][j] == dama))
sw = true;
aux = false;
}
k++;
}
}
if(!sw){
// hacia el oeste
k = j - 1;
aux = true;
while((k >= 0) && (aux)){
if(Main.Tab[i][k] != '.'){
if((Main.Tab[i][k] == torre) || (Main.Tab[i][k] == dama))
sw = true;
aux=false;
}
k--;
}
}
if(!sw){
// hacia el este
k = j + 1;
aux = true;
while((k < 8) && (aux)){
if(Main.Tab[i][k] != '.'){
if((Main.Tab[i][k] == torre) || (Main.Tab[i][k] == dama))
sw = true;
aux=false;
}
k++;
}
}
if(!sw){
// pregunto si es atacado por una alfil o una reina
// hacia el noroeste
k = i - 1;
l = j - 1;
aux = true;
while((k >= 0) && (l >= 0) && (aux)){
if(Main.Tab[k][l] != '.'){
if((Main.Tab[k][l] == alfil) || (Main.Tab[k][l] == dama))
sw = true;
aux=false;
}
k--;
l--;
}
}
if(!sw){
// hacia el noreste
k = i - 1;
l = j + 1;
aux = true;
while((k >= 0) && (l < 8) && (aux)){
if(Main.Tab[k][l] != '.'){
if((Main.Tab[k][l] == alfil) || (Main.Tab[k][l] == dama))
sw = true;
aux = false;
}
k--;
l++;
}
}
if(!sw){
// hacia el sudoeste
k = i + 1;
l = j - 1;
aux = true;
while((k <>= 0) && (aux)){
if(Main.Tab[k][l] != '.'){
if((Main.Tab[k][l] == alfil) || (Main.Tab[k][l] == dama))
sw = true;
aux = false;
}
k++;
l--;
}
}
if(!sw){
// hacia el sudeste
k = i + 1;
l = j + 1;
aux = true;
while((k < 8) && (l < 8) && (aux)){
if(Main.Tab[k][l] != '.'){
if((Main.Tab[k][l] == alfil) || (Main.Tab[k][l] == dama))
sw = true;
aux = false;
}
k++;
l++;
}
}
if(!sw){
// busco amenaza de algun caballo
// por arriba
k = i - 2;
if(k >= 0){
l = j - 1;
if(l >= 0)
if(Main.Tab[k][l] == caballo)
sw = true;
l=j+1;
if((l < 8) && !sw)
if(Main.Tab[k][l] == caballo)
sw = true;
}
k=i-1;
if((k >= 0)&&!sw){
l = j -2;
if(l >= 0)
if(Main.Tab[k][l] == caballo)
sw = true;
l=j+2;
if((l < 8) && !sw)
if(Main.Tab[k][l] == caballo)
sw = true;
}
// por abajo
k=i+2;
if((k <8)&&!sw){
l = j -1;
if(l >= 0)
if(Main.Tab[k][l] == caballo)
sw = true;
l=j+1;
if((l < 8) && !sw)
if(Main.Tab[k][l] == caballo)
sw = true;
}
k=i+1;
if((k <8)&&!sw){
l = j -2;
if(l >= 0)
if(Main.Tab[k][l] == caballo)
sw = true;
l=j+2;
if((l < 8) && !sw)
if(Main.Tab[k][l] == caballo)
sw = true;
}
}
}
}
return sw;
}
}

110106 Intérprete

import java.util.*;
/**
* 110106 - Intérprete
*
* @author BreakDark
* @version 1.5 beta
* --- RESUELTO --- :)
*/
public class Main {

static int[] reg = new int[20]; // 10 registros
static int[] ram = new int[1010]; // 1000 de memoria ram

public static void main(String[] args) {
int casos; // # de casos
int i; // para contar las posiciones de la ram;
long c; // cantidad de instrucciones ejecutadas hasta terminar
int dig1; // para el primer digito
int dig2, dig3;
int aux; // digito auxiliar
Scanner Lee; // para leer los datos
String linea; // para leer una linea
Scanner texto; // para leer una linea

// EL PROGRAMA SE INICIA AQUI
Lee = new Scanner(System.in);
linea = Lee.nextLine();
texto = new Scanner(linea);
casos = texto.nextInt();
// System.out.println("Casos=" + casos);
linea = Lee.nextLine(); // para leer la linea en blanco
while ((casos > 0)&& (Lee.hasNextLine())) {
// System.out.println("Caso="+casos);
// System.out.println("linea="+linea);
// leemos la ram
Main.inicializa();
i = 0;
linea = Lee.nextLine();
while (!(linea.equals("")) && (i < 1000)) {
texto = new Scanner(linea);
Main.ram[i] = texto.nextInt();
i++;
if(Lee.hasNextLine())
linea=Lee.nextLine();
else
linea="";
}
// System.out.println("linea2=" + linea);
// // //////////
// System.out.println("Contenido de la ram");
// i = 0;
// while (i < 20) {
// System.out.println("Pos " + i + ": " + Main.ram[i]);
// i++;
// }
// leemos la ram
c = 1;
i = 0;
dig1 = Main.ram[i] / 100;
//System.out.println("Dig1= "+dig1);
while ((dig1 != 1) && (i < 1000)) {
//System.out.println("Se lee la pos= "+Main.ram[i]);
aux = Main.ram[i] % 100;
dig2 = aux/10;
dig3 = aux % 10;
switch (dig1) {
case 2 :
Main.reg[dig2] = dig3;
i++;
break;
case 3 :
Main.reg[dig2] += dig3;
if (Main.reg[dig2] > 999)
Main.reg[dig2] %= 1000;
i++;
break;
case 4 :
Main.reg[dig2] *= dig3;
if (Main.reg[dig2] > 999)
Main.reg[dig2] %= 1000;
i++;
break;
case 5 :
Main.reg[dig2] = Main.reg[dig3];
i++;
break;
case 6 :
Main.reg[dig2] += Main.reg[dig3];
if (Main.reg[dig2] > 999)
Main.reg[dig2] %= 1000;
i++;
break;
case 7 :
Main.reg[dig2] *= Main.reg[dig3];
if (Main.reg[dig2] > 999)
Main.reg[dig2] %= 1000;
i++;
break;
case 8 :
Main.reg[dig2] = Main.ram[Main.reg[dig3]];
i++;
break;
case 9 :
Main.ram[Main.reg[dig3]] = Main.reg[dig2];
i++;
break;
case 0 :
if (Main.reg[dig3] != 0)
i = Main.reg[dig2];
else
i++;
break;
}
c++;
//
//System.out.println(c);
//
dig1 = Main.ram[i] / 100;
}
System.out.println(c);
casos--;
if (casos > 0)
System.out.println();
}
}

/** Inicializa reg y ram con 000 */
static void inicializa() {
int i;
for (i = 0; i < 10; i++)
Main.reg[i] = 000;
for (i = 0; i < 1000; i++)
Main.ram[i] = 000;
}
}

110104 Pantalla de cristal liquido

import java.util.Scanner;

/**
* 110104 - Pantalla de cristal líquido
*
* @author BreakDark
* @version 1.5 beta
*/
// ACEPTADO!!! xD
class Main {
// matriz para cada dígito
static char[][] d1 = {{' ', ' ', ' '}, {' ', ' ', '|'}, {' ', ' ', ' '}, {' ', ' ', '|'}, {' ', ' ', ' '}};

static char[][] d2 = {{' ', '-', ' '}, {' ', ' ', '|'}, {' ', '-', ' '}, {'|', ' ', ' '}, {' ', '-', ' '}};

static char[][] d3 = {{' ', '-', ' '}, {' ', ' ', '|'}, {' ', '-', ' '}, {' ', ' ', '|'}, {' ', '-', ' '}};

static char[][] d4 = {{' ', ' ', ' '}, {'|', ' ', '|'}, {' ', '-', ' '}, {' ', ' ', '|'}, {' ', ' ', ' '}};

static char[][] d5 = {{' ', '-', ' '}, {'|', ' ', ' '}, {' ', '-', ' '}, {' ', ' ', '|'}, {' ', '-', ' '}};

static char[][] d6 = {{' ', '-', ' '}, {'|', ' ', ' '}, {' ', '-', ' '}, {'|', ' ', '|'}, {' ', '-', ' '}};

static char[][] d7 = {{' ', '-', ' '}, {' ', ' ', '|'}, {' ', ' ', ' '}, {' ', ' ', '|'}, {' ', ' ', ' '}};

static char[][] d8 = {{' ', '-', ' '}, {'|', ' ', '|'}, {' ', '-', ' '}, {'|', ' ', '|'}, {' ', '-', ' '}};

static char[][] d9 = {{' ', '-', ' '}, {'|', ' ', '|'}, {' ', '-', ' '}, {' ', ' ', '|'}, {' ', '-', ' '}};

static char[][] d0 = {{' ', '-', ' '}, {'|', ' ', '|'}, {' ', ' ', ' '}, {'|', ' ', '|'}, {' ', '-', ' '}};

// matriz para la cadena de dígitos
static String[] vector = new String[5];
static int i, j; // para los bucles
static byte s; // para el tamaño de las lineas

public static void main(String[] args) {
Scanner Lee; // para leer los datos

String numero; // para el número a mostrar
// INICIA EL PROGRAMA
Lee = new Scanner(System.in); // leo los datos de entrada
s = Lee.nextByte();
numero = Lee.next();
while((s != 0) || !(numero.equals("0"))){
// cargo el número en la matriz
Main.cargar(numero);
// muestro la matriz
if(s > 0)
Main.mostrar();
System.out.println(); // imprimo una linea en blanco
s = Lee.nextByte();
numero = Lee.next();
}
}

/**
* Método que carga la matriz con el número num
*
* @param num
* Cadena con el valor del número
*/
static void cargar(String num) {
byte k; // para un bucle
char[][] digito = new char[5][3]; // para guardar el digito
// inicializamos el vector
vector[0] = "";
vector[1] = "";
vector[2] = "";
vector[3] = "";
vector[4] = "";
for(i = 0; i < num.length(); i++){
switch(num.charAt(i)){
case '1':
digito = d1;
break;
case '2':
digito = d2;
break;
case '3':
digito = d3;
break;
case '4':
digito = d4;
break;
case '5':
digito = d5;
break;
case '6':
digito = d6;
break;
case '7':
digito = d7;
break;
case '8':
digito = d8;
break;
case '9':
digito = d9;
break;
case '0':
digito = d0;
break;
}
for(j = 0; j < 5; j++){
vector[j] += digito[j][0];
for(k = 0; k < s; k++)
vector[j] += digito[j][1];
vector[j] += digito[j][2];
vector[j] += ' ';
}
}
}

/**
* Método que muestra la matriz
*/
static void mostrar() {
byte k; // para un bucle
for(i = 0; i < 5; i++){
if((i == 1) || (i == 3)){
for(k = 0; k < s; k++)
System.out.println(vector[i].substring(0, vector[i].length()-1));
}
else
System.out.println(vector[i].substring(0, vector[i].length()-1));
}
}
}

110103 El viaje

// ACEPTADO!!!
/**
* 110103 - El viaje
*/
import java.util.*;

/**
* @author BreakDark
* @version 1.6 beta
*/
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int n = 1000; // número de estudiantes
double total = 1000000000; // total gastos de los estudiantes
double[] estudiante = new double[1010];
double promedio; // para calcular la media
double suma_dan; // pa los que dan dinero
double suma_reciben; // pa los que reciben dinero
double resta; // para hacer las diferencias con respecto al promedio
int i; // pa los bucles
// Inicia el programa
Lee = new Scanner(System.in); // leemos desde el sistema
n = Lee.nextInt();
while (n > 0) {
// Ahora leemos el total de gastos y lo guardamos en un vector
total = 0;
promedio = 0;
for (i = 0; i < n; i++) {
estudiante[i] = Double.parseDouble(Lee.next());
estudiante[i]*=100; // para eliminar la coma
total += estudiante[i];
}
if (n > 0)
promedio = total/(double)n; // el valor mas alto
// ahora calculamos el dinero que debe de intercambiarse
suma_dan = 0;
suma_reciben = 0;
for (i = 0; i < n; i++) {
if(estudiante[i]>promedio)
suma_reciben+=(int)(estudiante[i]-promedio);
else
suma_dan+=(int)(promedio-estudiante[i]);
}
if(suma_dan>suma_reciben)
resta=suma_dan;
else
resta=suma_reciben;
// mostramos el resultado
System.out.print("$" +(int)(resta / 100) + ".");
resta %= 100;
System.out.print((int)(resta / 10));
System.out.println((int)(resta % 10));
// volvemos a leer n
n = Lee.nextInt();

//System.out.printf("$%.2f\n",resta/100);
// volvemos a leer n
//n = Lee.nextInt();
}
// FIN DEL PROGRAMA!!!
}
}

110102 Buscaminas

/**
* Buscaminas
*/

/**
* @author BreakDark
* @version 1.0 beta
* @link BreakDark666@yahoo.es
*/

import java.util.*;

public class Main
{
public static void main(String[] args)
{
Scanner Lee;
short n, m, x = 0;
char[][] sal = new char[100][100];
String linea;
Lee = new Scanner(System.in);
n = Lee.nextShort();
m = Lee.nextShort();
while (n != 0 || m != 0)
{
x++;
// aqui se lee la n filas
for (short i = 0; i < n; i++)
{
if (m != 0)
{
linea = Lee.next();
for (short j = 0; j < m; j++)
// Se introduce los caracteres en una
// matriz
sal[i][j] = linea.charAt(j);
}
}
short[][] dat = modMat(sal, n, m);
// se muestra el resultado
System.out.println("Field #" + x + ":");
for (short i = 0; i < n; i++)
{
for (short j = 0; j < m; j++)
{
if (dat[i][j] != -1)
System.out.print(dat[i][j]);
else
System.out.print('*');
}
if (m != 0)
System.out.println();
}
n = Lee.nextShort();
m = Lee.nextShort();
if (n != 0 || m != 0)
System.out.println();
}
}

// Método para devolver una matriz de enteros con valores
public static short[][] modMat(char[][] dat, int fil, int col)
{
short[][] res = new short[100][100];
for (short i = 0; i < fil; i++)
{
for (short j = 0; j < col; j++)
{
if (dat[i][j] != '*')
{
int c = 0; // contador de minas adiacentes
// fila superior
if (i - 1 >= 0)
{
if (j - 1 >= 0)
c = (dat[i - 1][j - 1] == '*')? c + 1 : c;
c = (dat[i - 1][j] == '*')? c + 1 : c;
if (j + 1 < col)
c = (dat[i - 1][j + 1] == '*')? c + 1 : c;
}
// fila central
if (j - 1 >= 0)
c = (dat[i][j - 1] == '*')? c + 1 : c;
if (j + 1 < col)
c = (dat[i][j + 1] == '*')? c + 1 : c;
// fila inferior
if (i + 1 < fil)
{
if (j - 1 >= 0)
c = (dat[i + 1][j - 1] == '*')? c + 1 : c;
c = (dat[i + 1][j] == '*')? c + 1 : c;
if (j + 1 < col)
c = (dat[i + 1][j + 1] == '*')? c + 1 : c;
}
res[i][j] = (short)c;// aux.charAt(0);
}
else
res[i][j] = -1;
}
}
return res;
}
}

Problemas resueltos de Programming-Challenges con java

Hola, decidi publicar mis ejercicios resueltos, ojala que a alguien le sirva. Ojo no vale copiar la idea es ayudarnos a entender estos problemas ;)

110101 El problema de 3n + 1

/**
* El problema de 3n + 1
* @author BreakDark
* @version 1.0 beta
* @link BreakDark666@yahoo.es
*/

import java.util.*;

public class Main {
public static void main(String[] args) {
long i, j;
int c;
long aux;
int may;
long dat1, dat2;
Scanner Lee = new Scanner(System.in);
while (Lee.hasNext()) {
i = Lee.nextLong();
j = Lee.nextLong();
dat1 = i;
dat2 = j;
if (i > j) {
aux = i;
i = j;
j = aux;
}
may = 0;
if (i != 0 || j != 0) {
for (long k = i; k <= j; k++) {
aux = k;
c = 1;
while (aux > 1) {
aux = ((aux & 1) == 0) ? aux >> 1 : (aux * 3 + 1);
c++;
}
if (c > may)
may = c;
}
}
System.out.println(dat1 + " " + dat2 + " " + may);
}
}
}