import java.util.BitSet;
import java.util.Scanner;
/**
* Solución a 10783 - Odd Sum [https://uva.onlinejudge.org/]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 24 nov. de 2017
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee = new Scanner(System.in);
int t, a, b, i, j, sum;
BitSet impares = new BitSet(101);
for (i = 1; i <= 100; i += 2)
impares.set(i);
// AQUI INICIA EL PROGRAMA
t = Lee.nextInt();
for (i = 1; i <= t; i++) {
a = Lee.nextInt();
b = Lee.nextInt();
sum = 0;
for (j = a; j <= b; j++) {
if (impares.get(j))
sum += j;
}
System.out.println("Case " + i + ": " + sum);
}
Lee.close();
}
}
Monday, January 22, 2018
Solución al problema: 10783 - Odd Sum con Java
Para ver el link del problema Click aqui
Solución al problema: 488 - Triangle Wave con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* 488 - Triangle Wave [http://uva.onlinejudge.org]
*
* @author BreakDark
* @version 2.0 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int numcasos; // para el numero de casos
byte amplitud; // para la amplitud
int frecuencia; // frecuencia
int i; // para los bucles
// vector de ondas
String[] vec = {"", "1", "1\n22\n1", "1\n22\n333\n22\n1", "1\n22\n333\n4444\n333\n22\n1", "1\n22\n333\n4444\n55555\n4444\n333\n22\n1",
"1\n22\n333\n4444\n55555\n666666\n55555\n4444\n333\n22\n1",
"1\n22\n333\n4444\n55555\n666666\n7777777\n666666\n55555\n4444\n333\n22\n1",
"1\n22\n333\n4444\n55555\n666666\n7777777\n88888888\n7777777\n666666\n55555\n4444\n333\n22\n1",
"1\n22\n333\n4444\n55555\n666666\n7777777\n88888888\n999999999\n88888888\n7777777\n666666\n55555\n4444\n333\n22\n1"};
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
numcasos = Lee.nextInt();
while(numcasos-- > 0){
amplitud = Lee.nextByte();
frecuencia = Lee.nextInt();
for(i = 0; i < frecuencia; i++){
System.out.println(vec[amplitud]);
if(i < frecuencia - 1 || numcasos > 0)
System.out.println();
}
}
}
}
Solución al problema: 106 - Fermat vs Pythagoras con Java
Para ver el link del problema Click aqui
import java.util.BitSet;
import java.util.Scanner;
/**
* 106 - Fermat vs. Pythagoras [http://uva.onlinejudge.org]
*
* @author BreakDark
* @version 3.0 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // Para leer los datos de entrada
int N; // para el N a leer
// AQUI INICIA EL PROGRAMA!!!
Lee = new Scanner(System.in);
while(Lee.hasNext()){
N = Lee.nextInt();
calcula(N);
}
}
/**
* Procedimiento que realiza todo el trabajo
*
* @param N
* el numero a procesar
*/
private static void calcula(int N) {
int cont = 0;
int numUsados = 0;
int r, s, i, x, y, z;
BitSet numeros = new BitSet(N + 1);
for(r = 2; r * r <= N; r++)
for(s = 1; s < r && r * r + s * s <= N; s++){
x = r * r - s * s;
y = 2 * r * s;
z = r * r + s * s;
if(mcd(x, y) == 1){
cont++;
for(i = 1; z * i <= N; i++){
if(!numeros.get(x * i)){
numUsados++;
numeros.set(x * i);
}
// para y
if(!numeros.get(y * i)){
numUsados++;
numeros.set(y * i);
}
// para z
if(!numeros.get(z * i)){
numUsados++;
numeros.set(z * i);
}
}
}
}
System.out.println(cont + " " + (N - numUsados));
}
/**
* Funcion que encuentra el MCD de dos enteros basado en el slgoritmo de
* euclides
*
* @param a
* entero a evaluar el MCD
* @param b
* entero a evaluar el MCD
* @return el MCD de a y b
*/
private static int mcd(int a, int b) {
int r;
if(b > a){
r = a;
a = b;
b = r;
}
r = b;
while(b > 0){
r = a % b;
a = b;
b = r;
}
return a;
}
}
Saturday, February 25, 2017
Solución al problema: 10004 - Islas [http://acm.cs.buap.mx] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
import java.util.Stack;
/**
* Solución al problema: 10004 - Islas [http://acm.cs.buap.mx]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0b 18 feb. 2017
*/
// ACETTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int n; // dimension del mapa
char[][] mapa;
int i; // para los bucles
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
do {
n = Lee.nextInt();
if (n > 0) {
mapa = new char[n][n];
for (i = 0; i < n; i++) {
mapa[i] = Lee.next().toCharArray();
}
System.out.println(obtenerSolucion(n, mapa));
}
} while (Lee.hasNext() && n != 0);
Lee.close();
}
/**
* Metodo que obtiene la solucion del problema
*
* @param n
* Dimension del mapa
* @param mapa
* Matriz que representa el mapa
* @return Un String que representa la solucion
*/
public static String obtenerSolucion(int n, char[][] mapa) {
int[][] mp = new int[n][n]; // mapa de numeros
// int[] dimIslas = new int[n * n]; // dimension de las islas
int numIsla = 0;
int i, j; // para los bucles
// recorremos la matriz del mapa
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (mapa[i][j] != 'm') {
// pintamos la isla
if (mp[i][j] == 0) {
// si no esta pintado ya
Stack pila = new Stack();
pila.push(i); // introcucimos la primera coordenada
pila.push(j);
while (!pila.isEmpty()) {
int ind_j = pila.pop();
int ind_i = pila.pop();
// System.out.println(ind_j + "," + ind_i);
// buscamos los alrededores
// coordenada NorOeste
if (ind_i > 0 && ind_j > 0 && mapa[ind_i - 1][ind_j - 1] == 't'
&& mp[ind_i - 1][ind_j - 1] == 0) {
pila.push(ind_i - 1);
pila.push(ind_j - 1);
}
// coordenada Norte
if (ind_i > 0 && mapa[ind_i - 1][ind_j] == 't' && mp[ind_i - 1][ind_j] == 0) {
pila.push(ind_i - 1);
pila.push(ind_j);
}
// coordenada NorEste
if (ind_i > 0 && ind_j + 1 < n && mapa[ind_i - 1][ind_j + 1] == 't'
&& mp[ind_i - 1][ind_j + 1] == 0) {
pila.push(ind_i - 1);
pila.push(ind_j + 1);
}
// Oeste
if (ind_j > 0 && mapa[ind_i][ind_j - 1] == 't' && mp[ind_i][ind_j - 1] == 0) {
pila.push(ind_i);
pila.push(ind_j - 1);
}
// coordenada Este
if (ind_j + 1 < n && mapa[ind_i][ind_j + 1] == 't' && mp[ind_i][ind_j + 1] == 0) {
pila.push(ind_i);
pila.push(ind_j + 1);
}
// coordenada SurOeste
if (ind_i + 1 < n && ind_j > 0 && mapa[ind_i + 1][ind_j - 1] == 't'
&& mp[ind_i + 1][ind_j - 1] == 0) {
pila.push(ind_i + 1);
pila.push(ind_j - 1);
}
// coordenada Sur
if (ind_i + 1 < n && mapa[ind_i + 1][ind_j] == 't' && mp[ind_i + 1][ind_j] == 0) {
pila.push(ind_i + 1);
pila.push(ind_j);
}
// coordenada SurEste
if (ind_i + 1 < n && ind_j + 1 < n && mapa[ind_i + 1][ind_j + 1] == 't'
&& mp[ind_i + 1][ind_j + 1] == 0) {
pila.push(ind_i + 1);
pila.push(ind_j + 1);
}
mp[ind_i][ind_j] = numIsla + 1;
}
numIsla++;
}
}
}
}
// si no hay islas o solo hay una
if (numIsla == 0)
return "No hay islas";
if (numIsla == 1)
return "Solo hay una isla";
// buscamos el menor y la mayor dimension
int min = Integer.MAX_VALUE, max = Integer.MIN_VALUE;
for (int isla = 1; isla <= numIsla; isla++) {
int cont = 0;
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
if (mp[i][j] > 0 && mp[i][j] == isla)
cont++;
if (cont > 0 && cont < min)
min = cont;
if (cont > max)
max = cont;
}
return min + " " + max;
}
}
Solución al problema: 10003 - Burrito Amarrado [http://acm.cs.buap.mx] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solución al problema: 10003 - Burrito Amarrado [http://acm.cs.buap.mx]
*/
/**
* @author BreakDark (Jhonny Monrroy)
* @version 2.0 b 18 feb. 2017
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para los datos de entrada
int r, n; /// radio y numero de intentos
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
do {
r = Lee.nextInt();
n = Lee.nextInt();
if (r != 0 && n != 0)
System.out.println(obtenerSolucion(r, n));
} while (Lee.hasNext() && r != 0 && n != 0);
Lee.close();
}
/**
* Metodo que obtiene la solucion del problema
*
* @param r
* Radio del corral
* @param n
* Numero de intentos
* @return Un String que representa la distancia del burrito al poste
*/
public static String obtenerSolucion(int r, int n) {
double x = 0, y = 0; // coordenadas del burrito
byte dir = 0; // 0=norte, 1=este, 2=sur, 3=oeste
while (n-- > 0) {
switch (dir) {
case 0: // norte
y = (y + Math.sqrt(r * r - x * x)) / 2;
break;
case 1: // este
x = (x + Math.sqrt(r * r - y * y)) / 2;
break;
case 2: // sur
y = (y - Math.sqrt(r * r - x * x)) / 2;
break;
default: // oeste
x = (x - Math.sqrt(r * r - y * y)) / 2;
dir = -1; // para volver a empezar desde el principio
break;
}
dir++;
}
// mostramos el resultado
return String.format("%.2f", Math.sqrt(x * x + y * y)).replace(',', '.');
}
}
Solución al problema: 10002 - El inspector [http://acm.cs.buap.mx] con Java
Para ver el link del problema Click aqui
import java.util.BitSet;
import java.util.PriorityQueue;
import java.util.Scanner;
/**
* Solución al problema: 10002 - El inspector [http://acm.cs.buap.mx]
*
* @author BreakDark
* @version 1.0b 17 feb. 2017
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int n; // numero de casos de prueba
String p; // nombre de la poblacion
String s; // informacion de los cultivos
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
n = Integer.parseInt(Lee.nextLine());
while (n-- > 0) {
p = Lee.nextLine();
s = Lee.nextLine();
System.out.print(procesar(p, s));
}
Lee.close();
}
/**
* Metodo que resueleve el problema
*
* @param p
* Nombre de la poblacion
* @param s
* Informacion de los cultivos
*/
static String procesar(String p, String s) {
String resp = "";
// contamos los cultivos
int dim = 'z' - 'a' + 1, i;
BitSet tipoCultivos = new BitSet(dim - 1);
char letra;
int d = 0; // desconocidos
int[] cultivos = new int[dim];
for (i = 0; i < s.length(); i++) {
letra = s.charAt(i);
if (letra != '*') {
tipoCultivos.set(letra - 'a');
cultivos[letra - 'a']++;
} else
d++;
}
resp += "POBLACION: " + p + "\n";
resp += "TIPOS DE CULTIVOS: " + tipoCultivos.cardinality() + "\n";
resp += "DESCONOCIDOS: " + d + "\n";
resp += "CANTIDADES:" + "\n";
// mostramos los conteos de los cultivos
PriorityQueue cola = new PriorityQueue();
for (i = 0; i < dim; i++) {
// adicionamos los valores a una cola de prioridad
if (cultivos[i] > 0)
cola.add(new CultivoValor((char) ('a' + i), cultivos[i]));
// resp += (char) ('a' + i) + " - " + cultivos[i] + "\n";
}
// mostramos la cola
while (!cola.isEmpty()) {
CultivoValor cv = cola.poll();
resp += cv.cult + " - " + cv.val + "\n";
}
return resp;
}
}
class CultivoValor implements Comparable {
char cult;
int val;
public CultivoValor(char c, int v) {
this.cult = c;
this.val = v;
}
@Override
public int compareTo(CultivoValor X) {
if (X.val - this.val == 0)
return this.cult - X.cult;
return X.val - this.val;
}
}
Thursday, September 15, 2016
Solucion al Problema: 1354 – IP Checking [http://lightoj.com/] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al Problema: 1354 – IP Checking [http://lightoj.com/]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 14 ago. 2016
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int T; // numero de casos de prueba
String ipDecimal, ipBinario;
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
T = Lee.nextInt();
for (int i = 1; i <= T; i++) {
ipDecimal = Lee.next();
ipBinario = Lee.next();
String aux = Short.parseShort(ipBinario.substring(0, 8), 2) + ".";
aux += Short.parseShort(ipBinario.substring(9, 17), 2) + ".";
aux += Short.parseShort(ipBinario.substring(18, 26), 2) + ".";
aux += Short.parseShort(ipBinario.substring(27), 2);
System.out.println("Case " + i + ": " + (ipDecimal.equals(aux) ? "Yes" : "No"));
}
Lee.close();
}
}
Solucion al Problema: 1293 - Document Analyzer [http://lightoj.com/] con C++
Para ver el link del problema Click aqui
//============================================================================
// Name : 1293.cpp
// Author : BreakDark (Jhonny Monrroy) basado en la solucion publicada en [http://www.cnblogs.com/njczy2010/p/4337078.html]
// Version : 3.0 16/09/2016
// Copyright : (Solucion obtenida de [http://www.cnblogs.com/njczy2010/p/4337078.html])
// Description : Solucion al Problema: 1293 - Document Analyzer [http://lightoj.com/]
//============================================================================
// Accepted!!! xD
#include <iostream>
#include <stdio.h>
#include <string>
#include <cstring>
#include <sstream>
#include <map>
using namespace std;
int T; // para el numero de casos de prueba
int t; // indice
/**
* Metodo procesarPalabra: reemplaza los caracteres que no son letras por
* espacios
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 20 ago. 2016
* @param palabra
* Cadena a procesar
* @return Retorna la cadena ya proceesda
*/
string procesarPalabra(string palabra) {
string nuevaLinea = "";
char letra;
for (int i = 0; i < palabra.length(); i++) {
letra = palabra[i];
if (letra >= 'a' && letra <= 'z') {
nuevaLinea += letra;
} else {
nuevaLinea += ' ';
}
}
return nuevaLinea;
}
/**
* Metodo obtenerRangoMenor: Metodo que busca el rango menor para este
* problema
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 20 ago. 2016
* @param vecPal
* Vector de palabras
* @param numPal
* Numero de palabras del vector
* @param hashPal
* HashMap de palabras no iguales
*/
void obtenerRangoMenor(string vecPal[], int numPal, map<string, int> hashPal) {
int p = -1;
int q = numPal + 1;
int posible_p, posible_q;
int cont = 0; // contador de palabras encontradas
posible_p = 0;
posible_q = 0;
while (posible_p < numPal) {
for (; posible_q < numPal; posible_q++) {
hashPal[vecPal[posible_q]]++;
if (hashPal[vecPal[posible_q]] == 1)
cont++;
if (cont == hashPal.size()) {
for (; posible_p <= posible_q; posible_p++) {
if (hashPal[vecPal[posible_p]] == 1) {
if (posible_q - posible_p < q - p) {
p = posible_p;
q = posible_q;
} else if (posible_q - posible_p == q - p) {
if (posible_p < p) {
p = posible_p;
q = posible_q;
}
}
hashPal[vecPal[posible_p]]--;
cont--;
posible_p++;
posible_q++;
break;
}
hashPal[vecPal[posible_p]]--;
}
break;
}
}
if (posible_q == numPal)
break;
}
printf("Case %d: %d %d\n", t, (p + 1), (q + 1));
}
int main() {
//int T; // para el numero de casos de prueba
string palabra; // para cada palabra
char linea[102]; // para la linea que se lea
string linea_s;
string palabras[50000]; // vector de palabras
int numPal; // para el numero de palabras a almacenar
map<string, int> hashPalabras; // conjunto de palabras no repetidas
// AQUI INICIA EL PROGRAMA
scanf("%d", &T);
for (t = 1; t <= T; t++) {
numPal = 0; // vaciamos el vector
hashPalabras.clear();
while (scanf("%s", linea) != EOF && strcmp(linea, "END") != 0) {
char nuevaLinea[102] = "";
char letra;
for (int i = 0; i < strlen(linea); i++) {
letra = linea[i];
if (letra >= 'a' && letra <= 'z') {
nuevaLinea[strlen(nuevaLinea)] = letra;
} else {
strcat(nuevaLinea, " ");
}
}
strcpy(linea, nuevaLinea);
//cout<<linea<<endl;
char *vecPalabras;
vecPalabras = strtok(linea, " ");
while (vecPalabras != NULL) {
//printf("%s\n", vecPalabras);
palabras[numPal] = vecPalabras;
stringstream ss;
ss << palabras[numPal];
ss >> linea_s;
hashPalabras[linea_s] = 0; // seleccionamos palabras distintas
numPal++;
vecPalabras = strtok(NULL, " ");
}
}
obtenerRangoMenor(palabras, numPal, hashPalabras);
}
return 0;
}
Solucion al Problema: 1109 - False Ordering [http://lightoj.com/] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al Problema: 1109 - False Ordering [http://lightoj.com/]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 13 ago. 2016
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int t; // numero de casos
int n; // numero a evaluar
int vecDiv[]; // vector para almacenar cantidad de veces que es divisor
// cada indice
int vecNum[]; // numero de los valores que seran ordenados
int limite = 1001; // para el limite de las operaciones
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
// generamos el vector de num de divisores
vecDiv = new int[limite + 1];
vecNum = new int[limite + 1];
for (int i = 1; i <= limite; i++) {
for (int j = i; j <= limite; j += i) {
vecDiv[j]++;
}
vecNum[i] = i;
}
// ordenamos los valores por el metodo burbuja adecauado al problema
for (int i = 1; i < limite - 1; i++) {
for (int j = i + 1; j < limite; j++) {
int x = vecNum[j];
int y = vecNum[i];
if (vecDiv[x] < vecDiv[y] || (vecDiv[x] == vecDiv[y] && x > y)) {
int aux = vecNum[i];
vecNum[i] = vecNum[j];
vecNum[j] = aux;
}
}
}
// leemos los datos
t = Lee.nextInt();
for (int i = 1; i <= t; i++) {
n = Lee.nextInt();
System.out.println("Case " + i + ": " + vecNum[n]);
}
Lee.close();
}
}
Solucion al Problema: 1072 – Calm Down [http://lightoj.com/] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al Problema: 1072 – Calm Down [http://lightoj.com/]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 14 ago. 2016
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int T; // numero de casos de prueba
double R; // para el radio
int n; // numero re balas esperado
double r; // radio buscado
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
T = Lee.nextInt();
for (int i = 1; i <= T; i++) {
R = Double.parseDouble(Lee.next());
n = Lee.nextInt();
double angulo = 2 * Math.PI / n;
double senoAngulo = Math.sin(angulo / 2);
r = R * senoAngulo / (1 + senoAngulo);
if (r == (int) r) {
System.out.println(String.format("Case %d: %d", i, (int) r));
} else {
System.out.println(String.format("Case %d: %.10f", i, r).replace(',', '.'));
}
}
Lee.close();
}
}
Solucion al Problema: 1043 - Triangle Partitioning [http://lightoj.com/] con java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al Problema: 1043 - Triangle Partitioning [http://lightoj.com/]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 08/10/2013
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
byte T, caso; // para los casos de entrada
double AB, AC, BC; // para los lados del triangulo
double r; // para el radio de las areas
double Area, Area1, Area2; // para las areas
double SenoDeAlpha; // Seno de Alfa
double h, h1, h2; // la altura del triangulo inicial
double AD; // longitud superior del trapecio, y la longitud buscada
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
T = Lee.nextByte();
for (caso = 1; caso <= T; caso++) {
// leemos la informacion
AB = Lee.nextDouble();
AC = Lee.nextDouble();
BC = Lee.nextDouble();
r = Lee.nextDouble();
// obtenemos el area del traingulo
Area = areaDelTriangulo(AB, AC, BC);
h = 2 * Area / BC;
Area2 = Area / (r + 1);
Area1 = Area - Area2;
// obtenemos el seno del angulo
SenoDeAlpha = Area * 2 / (AB * BC);
h2 = formulaDeSegundoGrado(BC, -(2 * Area2 + h * BC + 2 * Area1), 2
* Area2 * h);
h1 = h - h2;
AD = h1 / SenoDeAlpha;
// mostramos el resultado
System.out.println("Case " + caso + ": " + AD);
}
}
/**
* Obtiene uno de los resultados de la ecuacion de 2do grado ax2+bx+c
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 25/08/2013
* @param a
* El coeficiente A de la ecuacion de 2do grado
* @param b
* El coeficiente B de la ecuacion de 2do grado
* @param c
* El coeficiente C de la ecuacion de 2do grado
* @return uno de los valores de x a partir de la ecuacion ax2+bx+c
*/
private static double formulaDeSegundoGrado(double a, double b, double c) {
double dis = b * b - 4 * a * c; // discriminante
if (dis >= 0)
return ((-b - Math.sqrt(dis)) / (2 * a));
else
System.out.println("El resultado es un numero imaginario :(");
return 0;
}
/**
* obtiene el area de un triangulo a partir de sus lados
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 12/08/2013
* @param a
* Longitud del lado a del triangulo
* @param b
* Longitud del lado b del triangulo
* @param c
* Longitud del lado c del triangulo
* @return El area del triangulo de lados a, b, c
*/
private static double areaDelTriangulo(double a, double b, double c) {
double s = (a + b + c) / 2; // semiperimetro
return Math.sqrt(s * (s - a) * (s - b) * (s - c));
}
}
Solución al problema 1001 - Opposite Task [http://www.lightoj.com] con java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* 1001 - Opposite Task [http://www.lightoj.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
byte T; // para el numero de casos de prueba
byte n; // para el numero de problemas
byte a; // para la computadora 1
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
T = Lee.nextByte();
while (T-- > 0) {
n = Lee.nextByte();
if (n >= 10) {
a = (byte) (n - 10);
System.out.println(a + " " + (n - a));
} else
System.out.println("0 " + n);
}
}
}
Solucion al problema: 1000 - Greetings from LightOJ [www.lightoj.com] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* 1000 - Greetings from LightOJ [www.lightoj.com]
*
* @author BreakDark
* @version 1.0 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer l0os datos de entrada
byte T; // numero de casos
byte caso; // para contar los casos
byte a, b; // problemas en cada computadora
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
T = Lee.nextByte();
for (caso = 1; caso <= T; caso++) {
a = Lee.nextByte();
b = Lee.nextByte();
System.out.println("Case " + caso + ": " + (a + b));
}
}
}
Sunday, June 12, 2016
Solucion al problema: 3056 - Automatic Checking Machine [http://coj.uci.cu] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al problema: 3056 - Automatic Checking Machine [http://coj.uci.cu]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 20/11/2014
*/
// Acepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee;
boolean[] c1, c2;
int i;
boolean nocompatibles = false;
// aca inicia el programa
Lee = new Scanner(System.in);
c1 = new boolean[5];
c2 = new boolean[5];
while (Lee.hasNext()) {
nocompatibles = false;
for (i = 0; i < 5; i++)
c1[i] = (Lee.nextInt() == 1);
for (i = 0; i < 5; i++)
c2[i] = (Lee.nextInt() == 1);
// buscamos si son compatibles
for (i = 0; i < 5; i++)
if (c1[i] == c2[i]) {
nocompatibles = true;
break;
}
if (nocompatibles) {
for (i = 0; i < 5; i++)
if (c1[i] == c2[5 - 1 - i]) {
nocompatibles = true;
break;
}
}
System.out.println((nocompatibles) ? "N" : "Y");
}
}
}
Solucion al problema: 1805 - A+B Complejo [http://coj.uci.cu] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al problema: 1805 - A+B Complejo [http://coj.uci.cu]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 11 de jun. de 2016
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos
long a, b;
long suma;
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
a = Lee.nextInt();
b = Lee.nextInt();
suma = 2 * a + 2 * b; // 2a+2b = (a+b) + (a-b) + (b+a) + (b-a)
System.out.println(suma);
Lee.close();
}
}
Solución al problema: 1666 - WERTYU [http://coj.uci.cu/] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* 1666 - WERTYU [http://coj.uci.cu/]
*
* @author BreakDark
* @version 1.1 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee;
String cadena, salida;
int i;
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
while (Lee.hasNextLine()) {
cadena = Lee.nextLine();
salida = "";
for (i = 0; i < cadena.length(); i++) {
switch (cadena.charAt(i)) {
case 'W':
salida += 'Q';
break;
case 'S':
salida += 'A';
break;
case 'X':
salida += 'Z';
break;
case 'E':
salida += 'W';
break;
case 'D':
salida += 'S';
break;
case 'C':
salida += 'X';
break;
case 'R':
salida += 'E';
break;
case 'F':
salida += 'D';
break;
case 'V':
salida += 'C';
break;
case 'T':
salida += 'R';
break;
case 'G':
salida += 'F';
break;
case 'B':
salida += 'V';
break;
case 'Y':
salida += 'T';
break;
case 'H':
salida += 'G';
break;
case 'N':
salida += 'B';
break;
case 'U':
salida += 'Y';
break;
case 'J':
salida += 'H';
break;
case 'M':
salida += 'N';
break;
case 'I':
salida += 'U';
break;
case 'K':
salida += 'J';
break;
case ',':
salida += 'M';
break;
case 'O':
salida += 'I';
break;
case 'L':
salida += 'K';
break;
case '.':
salida += ',';
break;
case 'P':
salida += 'O';
break;
case ';':
salida += 'L';
break;
case '/':
salida += '.';
break;
case '2':
salida += '1';
break;
case '3':
salida += '2';
break;
case '4':
salida += '3';
break;
case '5':
salida += '4';
break;
case '6':
salida += '5';
break;
case '7':
salida += '8';
break;
case '8':
salida += '7';
break;
case '9':
salida += '8';
break;
case '0':
salida += '9';
break;
case '-':
salida += '0';
break;
case '=':
salida += '-';
break;
case '[':
salida += 'P';
break;
case ']':
salida += '[';
break;
case '\\':
salida += ']';
break;
case '\'':
salida += ';';
break;
case ' ':
salida += ' ';
break;
}
}
System.out.println(salida);
}
}
}
Solución al problema: 1663 - Error Correction [http://coj.uci.cu/] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* 1663 - Error Correction [http://coj.uci.cu/]
*
* @author BreakDark
* @version 1.1 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee;
byte N;
boolean[][] mat;
byte i, j;
byte sum;
byte fil, col;
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
N = Lee.nextByte();
while (N > 0) {
mat = new boolean[N][N];
fil = col = -1;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
mat[i][j] = (Lee.nextByte() == 1) ? true : false;
if (cumpleParidad(mat))
System.out.println("OK");
else {
// buscamos errores en filas
for (i = 0; i < N; i++) {
sum = 0;
for (j = 0; j < N; j++)
if (mat[i][j])
sum++;
if ((sum & 1) == 1) {
fil = i;
break;
}
}
if (fil > 0) {
// buscamos errores en columnas
for (j = 0; j < N; j++) {
sum = 0;
for (i = 0; i < N; i++)
if (mat[i][j])
sum++;
if ((sum & 1) == 1) {
col = j;
break;
}
}
}
// reparamos
if (fil >= 0 && col >= 0)
mat[fil][col] = !mat[fil][col];
if (cumpleParidad(mat))
System.out.println("Change bit (" + (fil + 1) + ","
+ (col + 1) + ")");
else
System.out.println("Corrupt");
}
N = Lee.nextByte();
}
}
/** Para comprobar si la matriz cumple con la paridad */
private static boolean cumpleParidad(boolean[][] mat) {
byte i, j;
byte sum;
// buscamos filas
for (i = 0; i < mat.length; i++) {
sum = 0;
for (j = 0; j < mat.length; j++)
if (mat[i][j])
sum++;
if ((sum & 1) == 1)
return false;
}
// buscamos columnas
for (j = 0; j < mat.length; j++) {
sum = 0;
for (i = 0; i < mat.length; i++)
if (mat[i][j])
sum++;
if ((sum & 1) == 1)
return false;
}
return true;
}
}
Solución al problema: 1662 - Run-Length Encoding-Decoding [http://coj.uci.cu/] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* 1662 - Run-Length Encoding-Decoding [http://coj.uci.cu/]
*
* @author BreakDark
* @version 1.0 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee;
byte T;
byte caso;
String cadena, salida;
char letra;
int i, j;
String aux;
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
T = Lee.nextByte();
for (caso = 1; caso <= T; caso++) {
System.out.print("Case " + caso + ": ");
cadena = Lee.next();
salida = "";
letra = cadena.charAt(0);
aux = "";
for (i = 1; i < cadena.length(); i++) {
if (cadena.charAt(i) >= '0' && cadena.charAt(i) <= '9')
aux += cadena.charAt(i);
else {
for (j = 0; j < Integer.parseInt(aux); j++)
salida += letra;
letra = cadena.charAt(i);
aux = "";
}
}
for (j = 0; j < Integer.parseInt(aux); j++)
salida += letra;
System.out.println(salida);
}
}
}
Solución al problema: 1655 - Xtreme Encription [http://coj.uci.cu/] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* 1655 - Xtreme Encription [http://coj.uci.cu/]
*
* @author BreakDark
* @version 1.0 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee;
String texto, texto2;
int i, j;
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
while (Lee.hasNext()) {
texto = Lee.next();
texto2 = Lee.next();
i = j = 0;
while (i < texto.length() && j < texto2.length()) {
if (texto.charAt(i) == texto2.charAt(j))
i++;
j++;
}
if (i == texto.length())
System.out.println("Yes");
else
System.out.println("No");
}
}
}
Solucion al problema: 1495 - Increasing Order List [http://coj.uci.cu] con Java
Para ver el link del problema Click aqui
import java.util.Arrays;
import java.util.Scanner;
/**
* Solucion al problema: 1495 - Increasing Order List [http://coj.uci.cu]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 12 de jun. de 2016
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer datos
int[] ni; // lista de enteros
int n; // numero de enteros
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
n = Lee.nextInt();
ni = new int[n];
for (int i = 0; i < n; i++) {
ni[i] = Lee.nextInt();
}
Arrays.sort(ni);
for (int i = 0; i < n; i++) {
System.out.println(ni[i]);
}
Lee.close();
}
}
Solucion al problema: 1494 - Hey don't Read!!! [http://coj.uci.cu] con Java
Para ver el link del problema Click aqui
/**
* Solucion al problema: 1494 - Hey don't Read!!! [http://coj.uci.cu]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 19/11/2014
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
System.out.println("I got my first solution!!!");
}
}
Solucion al problema: 1312 - R2 [http://coj.uci.cu] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al problema: 1312 - R2 [http://coj.uci.cu]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 19/11/2014
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int r1, r2, s;
// aqui inicia el programa
Lee = new Scanner(System.in);
r1 = Lee.nextInt();
s = Lee.nextInt();
r2 = (s << 1) - r1;
System.out.println(r2);
}
}
Solucion al problema: 1156 - La Vida, El Universo y El Todo [http://coj.uci.cu] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al problema: 1156 - La Vida, El Universo y El Todo
* [http://coj.uci.cu]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 1 de jun. de 2016
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // Pasra leer los datos de entrada
int i; // para los datos de entrada
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
while (Lee.hasNext()) {
i = Lee.nextInt();
if (i == 42) {
break;
}
System.out.println(i);
}
}
}
Solucion al problema: 1102 - You Can Say 11 [http://coj.uci.cu] con java
Para ver el link del problema Click aqui
import java.math.BigInteger;
import java.util.Scanner;
/**
* Solucion al problema: 1102 - You Can Say 11 [http://coj.uci.cu]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 11 de jun. de 2016
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para ler datos
BigInteger n; // el numero a evaluar
BigInteger once = new BigInteger("11");
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
n = new BigInteger(Lee.next());
while (!n.equals(BigInteger.ZERO)) {
if (n.mod(once).equals(BigInteger.ZERO)) {
System.out.println(n + " is a multiple of 11.");
} else {
System.out.println(n + " is not a multiple of 11.");
}
n = new BigInteger(Lee.next());
}
Lee.close();
}
}
Solución al problema: 1099 - Pythagorean Numbers [http://coj.uci.cu] con Java
Para ver el link del problema Click aqui
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;
/**
* 1099 - Pythagorean Numbers [http://coj.uci.cu]
*
* @author BreakDark
* @version 1.0 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
String linea; // para leer una linea
StringTokenizer LeerLinea;
short[] num = new short[3]; // para la trica phitagorica
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
// leemos los datos
linea = Lee.nextLine();
while (!linea.equals("0")) {
LeerLinea = new StringTokenizer(linea);
num[0] = Short.parseShort(LeerLinea.nextToken());
num[1] = Short.parseShort(LeerLinea.nextToken());
num[2] = Short.parseShort(LeerLinea.nextToken());
Arrays.sort(num); // ordenamos
// mostramos el resultado
if (num[0] * num[0] + num[1] * num[1] == num[2] * num[2])
System.out.println("right");
else
System.out.println("wrong");
linea = Lee.nextLine();
}
}
}
Solucion al problema: 1079 - Sums in a Triangle I [http://coj.uci.cu] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al problema: 1079 - Sums in a Triangle I [http://coj.uci.cu]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 10 de jun. de 2016
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
int nt; // numero de casos de prueba
int n; // tamanio de la matriz
int[][] matriz; // matriz donde guardar los numeros del triangulo
// AQUI INICIA EL PROGRAMA!!!
Lee = new Scanner(System.in);
nt = Lee.nextInt();
while (nt-- > 0) {
n = Lee.nextInt();
matriz = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
matriz[i][j] = Lee.nextInt();
}
}
System.out.println(obtenerSumaMasLarga(matriz, n));
}
Lee.close();
}
/**
* Obtiene la suma mas larga que se puede obtener de un triangulo de enteros
* desde la punta hasta una de sus ramas
*
* @param matriz
* Matriz de enteros a procesar
* @param n
* El tamaño de la matriz de N x N, n debe ser mayor que 0
* @return Un entero con el resultado de la suma mas larga
*/
private static int obtenerSumaMasLarga(int[][] matriz, int n) {
int i, j; // indices
for (i = n - 2; i >= 0; i--) {
for (j = 0; j <= i; j++) {
matriz[i][j] = Math.max(matriz[i][j] + matriz[i + 1][j],
matriz[i][j] + matriz[i + 1][j + 1]);
}
}
return matriz[0][0];
}
}
Solución al problema: 1049 - Sum [http://coj.uci.cu/] con Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* 1049 - Sum [http://coj.uci.cu/]
*
* @author BreakDark
* @version 2.0 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para los datos de entrada
int N; // el N a leer
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
while (Lee.hasNext()) {
// leemos los datos
N = Lee.nextShort();
// mostramos el resultado
if (N > 0)
System.out.println((N * (N + 1)) / 2);
else {
N = -N;
N = ((N * (N + 1)) / 2);
System.out.println(1 - N);
}
}
}
}
Solucion al problema: 1023 - Financial Management [http://coj.uci.cu] en java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* Solucion al problema: 1023 - Financial Management [http://coj.uci.cu]
*
* @author BreakDark (Jhonny Monrroy)
* @version 1.0 beta 19/11/2014
*/
// Accepted!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer lps datos de entrada
double suma, promedio; // para sumar los valores y promedio
int i; // para los bucles
// aqui inicia el programa
Lee = new Scanner(System.in);
suma = 0;
for (i = 1; i <= 12; i++)
suma += Double.valueOf(Lee.next());
promedio = suma / 12;
System.out.println(String.format("$%.2f", promedio).replace(',', '.'));
}
}
Solucion al problema: 1003 - General Election [http://coj.uci.cu] en Java
Para ver el link del problema Click aqui
import java.util.Scanner;
/**
* 1003 - General Election [http://coj.uci.cu]
*
* @author BreakDark
* @version 1.0 beta
*/
// ACEPTADO!!! xD
public class Main {
public static void main(String[] args) {
Scanner Lee; // para leer los datos de entrada
byte T; // casos de prueba
byte n, m; // candidatos y regiones
int[] suma; // vector de la suma de los candidatos
int sumaMax; // suma maxima
int i, j; // indices
// AQUI INICIA EL PROGRAMA
Lee = new Scanner(System.in);
// leemos los datos
T = Lee.nextByte();
while (T-- > 0) {
n = Lee.nextByte();
m = Lee.nextByte();
suma = new int[n];
// sumamos y calculamos
sumaMax = Integer.MIN_VALUE;
for (i = 0; i < m; i++)
for (j = 0; j < n; j++) {
suma[j] += Lee.nextInt();
if (suma[j] > sumaMax)
sumaMax = suma[j];
}
// mostramos al ganador
for (i = 0; i < n; i++)
if (suma[i] == sumaMax) {
System.out.println(i + 1);
break;
}
}
}
}
Solucion al problema: 1078 - Another Candies [http://coj.uci.cu] con C++
Para ver el link del problema Click aqui
#includeusing namespace std; /** * Solucion al problema: 1078 - Another Candies [http://coj.uci.cu] * * @author BreakDark (Jhonny Monrroy) * @version 1.0 beta_cpp 8 de jun. de 2016 */ // Accepted !!! xD int candies[100]; // dulces de cada ninio /** * Funcion que calcula si se pueden repartir los dulces equitativamente * entre los n ninios * * @param n * numero de ninios a calcular * @return truesi se puede repartir en partes iguales, *falseen caso contrario */ bool puedeDistribuirLosCaramelos(int n); int main(){ int t; // casos de entrada int n; // numero de ninios // AQUI INICIA EL PROGRAMA cin>>t; for(int it=1;it<=t;it++){ cin>>n; for(int ni=0;ni<n;ni++){ cin>>candies[ni]; } cout<<(puedeDistribuirLosCaramelos(n)?"YES":"NO")<<endl; } return 0; } bool puedeDistribuirLosCaramelos(int n){ int sum=0; for(int i=0;i<n;i++){ sum+=candies[i]; } return (sum%n)==0; }
Friday, September 26, 2014
Solución al problema 282A - Bit [http://www.codeforces.com] con C++
Para ver el link del problema Click aqui
Thursday, September 18, 2014
Solución al Problema: 96A - Football [http://codeforces.com] Con Java
Para ver el link del problema Click aqui
Solución al Problema: 1C - Ancient Berland Circus [http://codeforces.com] Con Java
Para ver el link del problema Click aqui
Solución al Problema: 1B - Spreadsheets [http://codeforces.com] Con Java
Para ver el link del problema Click aqui
Solucion al Problema: 122A - Lucky Division [http://codeforces.com] Con Java
Para ver el link del problema Click aqui
Solucion al Problema: 110A - Nearly Lucky Number [http://codeforces.com] en Java
Para ver el link del problema Click aqui
Monday, September 02, 2013
Practica 1 de INF 111 Periodo II/2013
Les dejo la practica de inf 111 para que se la descarguen
http://dl.dropboxusercontent.com/u/50967898/INF-111/Practica%20Inf-111_II-2013_%20ver%2020130902.pdf
http://dl.dropboxusercontent.com/u/50967898/INF-111/Practica%20Inf-111_II-2013_%20ver%2020130902.pdf
Subscribe to:
Comments (Atom)