Thursday, 13. August 2009, 02:25:26
Bueno este es otro de los retos que hemos trabajado, es un reto no muy dificil a nivel de programacion, pero si tal vez con sierto grado de dificultad en el analisis.
Enunciado: http://sophia.javeriana.edu.co/maratones/programacion/5.JaverianaPolitecnico/contest/D-IntersectingLines.pdfEntrada:http://sophia.javeriana.edu.co/maratones/programacion/5.JaverianaPolitecnico/contest/D.inSalida:http://sophia.javeriana.edu.co/maratones/programacion/5.JaverianaPolitecnico/contest/D.ans
public class Intersecting_Lines {
private DecimalFormat df = new DecimalFormat("0.00");
private float [] puntos = new float [8];
public static void main(String[] args) throws Exception {
Intersecting_Lines l = new Intersecting_Lines();
l.leer();
}
private void leer() throws Exception {
File f = new File ("lines.in");
BufferedReader entrada = new BufferedReader(new FileReader (f));
String texto=entrada.readLine();
int N = Integer.parseInt(texto);
System.out.println("INTERSECTING LINES OUTPUT");
while ((texto=entrada.readLine())!=null){
validar(asignar(texto));
}
System.out.println("END OF OUTPUT");
}
private void validar(float[] puntos) {
float m1 = (puntos [3]-puntos [1])/(puntos [2]-puntos[0]);
float m2 = (puntos [7]-puntos [5])/(puntos [6]-puntos[4]);
if (m1==m2){
//System.out.println("NONE");
if(funcion(m1,m2)){
System.out.println("LINE");
}else{
System.out.println("NONE");
}
}else{
if ((String.valueOf(m1).equals("Infinity")||String.valueOf(m1).equals("-Infinity"))&&(String.valueOf(m2).equals("Infinity")||String.valueOf(m2).equals("-Infinity"))){
System.out.println("NONE");
}else if (puntos[0]==puntos[2]&&puntos[5]==puntos[7]){ // No hay Pendiente
System.out.println("POINT "+df.format(puntos[0])+" "+df.format(puntos[5]));
}else if (puntos[0]==puntos[2]&&puntos[5]!=puntos[7]){
System.out.println(funcion2(puntos[0],m2));
}else if (puntos[0]!=puntos[2]&&puntos[5]==puntos[7]){
funcion2(puntos[5],m1);
}else{
//System.out.println(m1+" "+m2);
System.out.println(funcion3(m1,m2));
}
}
}
private String funcion3(float m1, float m2) {
float b1=(((puntos[0])*(-1))*m1)+((puntos[1]));
float b2=(((puntos[4])*(-1))*m2)+((puntos[5]));
float x= (b2-b1)/(m1-m2);
float y=(m2*x)+b2;
return "POINT "+df.format(x)+" "+df.format(y);
}
private String funcion2(float a, float m2) {
String f=String.valueOf(a);
String g=String.valueOf(m2)+"X"+String.valueOf((((puntos[4])*(-1))*m2)+((puntos[5])));
float resp=(m2*a)+(((puntos[4])*(-1))*m2)+((puntos[5]));
return "POINT "+df.format(f)+" "+df.format(String.valueOf(resp));
}
private boolean funcion(float m1, float m2) {
String f=String.valueOf(m1)+"X"+String.valueOf((((puntos[0])*(-1))*m1)-((puntos[1])*(-1)));
String g=String.valueOf(m2)+"X"+String.valueOf((((puntos[4])*(-1))*m2)-((puntos[5])*(-1)));
if (f.equals(g)){
return true;
}
return false;
}
private float [] asignar(String texto) {
StringTokenizer tokens = new StringTokenizer(texto," ");
int i =0;
while (tokens.hasMoreTokens()){
puntos[i]=Float.parseFloat(tokens.nextToken());
i++;
}
return puntos;
}
}
Tuesday, 11. August 2009, 02:05:47
El primer parámetro que vemos es el mapeado del cable, el cual indica que está correctamente conectado.
La impedancia del cable puede variar en un 20%; para la categoría 5 mejorada muchos fabricantes están confeccionando los cables con los pares pegados y, aunque la mano de obra se encarece, esto mejora mucho otros parámetros a los cuales la impedancia del cable les afecta.
La longitud está establecida en 100 metros; esto no significa que las redes actuales a 10 ó 100 Mhz no funcionen con una longitud mayor, pero hay que recordar que cada día, como afirmamos al principio de nuestro artículo, las velocidades aumentan y a mayor longitud mayor atenuación de la señal y otros efectos.
Tiempo de propagación. Este es el tiempo que la señal demora en llegar al extremo distante; como se podrá observar el par que tiene mayor longitud tiene mayor tiempo de propagación.
Diferencia de retardo. El límite está fijado en 50 ns., esto no es más que la diferencia que existe entre el límite de retardo y el valor medido de retardo; este parámetro es muy importante, debido a que si estamos trabajando con velocidades de propagación full duplex, o a través de los 4 pares, los receptores pueden tener información errónea, ralentizando la red.
La resistencia. Este parámetro está referido a una medición con frecuencia 0 Hz.
Atenuación. Para este parámetro es muy significativa la longitud del cable, el instrumento va haciendo un barrido de frecuencias, en el cual se detecta a qué frecuencia es dónde se encuentra la mayor pérdida; como se puede observar en el Modelo a 99.9 Mhz se detecta en el par 4-5 una pérdida de 4.4 dB, siendo el límite 24.5 dB; hay que destacar que estamos haciendo una medición sobre un cable de 20 metros, con lo cual los márgenes resultan muy favorables.
Next cercano y Next remoto. Existen equipos en el mercado que sólo arrojan mediciones sobre el next cercano y no hacen la prueba del next remoto, siendo tan importante en un sentido como en el otro.
El next es un efecto físico e indeseable, donde la señal en un par se induce en el otro, originando un ruido en el par y cambiando en muchos casos el valor de la información; para esto lo que se hace es inyectar señal en un par, y medir qué cantidad de esa señal se induce en un segundo par; el equipo genera un barrido de frecuencias, donde se puede observar a que se produce la peor situación, para mejorar este efecto, se fabrican los pares con un paso de trenzado diferente para evitar el acoplamiento. Concluimos que, cuanto mayor sea la diferencia entre la señal deseada y la indeseada, mejor.
Tuesday, 11. August 2009, 01:59:33
Estos son algunos factores a tener en cuenta o mas bien son parámetros de prueba para la certificación de cables de red, lo complementare después con lo que diga en ingeniero en clase.
Mapa de cableado.
La prueba de mapa de cableado prueba y presenta las
conexiones de los hilos entre los extremos lejano y
cercano del cable en los cuatro pares. Se prueba la
continuidad del blindaje si se selecciona un tipo de cable
blindado. Los pares que se prueban son aquellos que
han sido definidos por la norma de prueba seleccionada.
Longitud.
La prueba de longitud mide la longitud de cada cable de
par trenzado probado. La longitud se presenta en
metros o pies. La pantalla de resultados de longitud
muestra la longitud, el límite y el resultado aceptado o
rechazado para cada par de cables.
Es común encontrar una diferencia entre 2 y 5 por ciento
en la longitud medida entre pares trenzados. Esta
diferencia es a causa de la diferencia en la cantidad de
trenzados en los pares de cables.
Atenuación (Insertion Loss).
La atenuación es originada por una pérdida de energía
eléctrica en la resistencia del cable y por fuga de la
energía a través del material aislante del cable. Esta
pérdida de energía se expresa en decibeles.
Los valores más bajos de la atenuación corresponden a
un mejor rendimiento del cable.
Interferencia e interf. del extremo cercano (NEXT).
La interferencia es una transmisión de señales
indeseables de un par de cables a otro par cercano.
De igual forma que el ruido de fuentes externas, la
interferencia puede causar problemas de comunicación
en las redes. De todas las caract. de la operación de
cables de LAN, la interferencia es la que tiene el mayor
efecto en el rendimiento de la red.
La herramienta de prueba mide la interferencia
aplicando una señal de prueba a un par de cables y
midiendo la amplitud de las señales de interferencia que
se reciben en el otro par de cables. El valor de la
interferencia se calcula como la diferencia de amplitud
entre la señal de prueba y la señal de interferencia al
medirse desde el mismo extremo del cable. Esta
diferencia se denomina interferencia del extremo
cercano (NEXT) y se expresa en decibeles.
Los valores más altos de la NEXT corresponden a
menos interferencia y un mejor rendimiento del cable.
Pérdida de retorno (Return Loss).
La pérdida de retorno es la diferencia entre la potencia
de la señal transmitida y la potencia de las reflexiones
de la señal causadas por las variaciones en la
impedancia del cable. Un valor alto de pérdida de
retorno significa que las impedancias son casi iguales, lo
que da como resultado una gran diferencia entre las
potencias de las señales transmitidas y reflejadas.
Los cables con valores altos de pérdida de retorno son
más eficientes para transmitir señales de LAN porque se
pierde muy poco de la señal en reflexiones.
ACR.
La ACR (la razón de la atenuación a la interferencia) es
la diferencia entre la NEXT en decibeles y la atenuación
en decibeles. El valor de la ACR indica cómo se
compara la amplitud de las señales recibidas del
extremo lejano del transmisor con la amplitud de la
interferencia producida por transmisiones del extremo
cercano. Un valor alto de ACR significa que las señales
recibidas son mucho más grandes que la interferencia.
En términos de la NEXT y de valores de atenuación, un
valor alto de ACR corresponde a una NEXT alta y una
atenuación baja.
Retardo.
La velocidad nominal de propagación (NVP) es la
velocidad de una señal por el cable relativa a la
velocidad de la luz. En el vacío, las señales eléctricas
viajan a la velocidad de la luz. En un cable, las señales
viajan a una velocidad menor a la de la luz. La velocidad
de una señal eléctrica en un cable es por lo general
entre el 60% y 80% de la velocidad de la luz.
Si la NVP de un cable es demasiado lenta o el cable es
demasiado largo, las señales se demoran y el sistema
no puede detectar las colisiones lo suficientemente
pronto para prevenir graves problemas en la red.
Sesgos del retardo.
Los sesgos del retardo son las diferencias en los
retardos de propagación entre los retardos más cortos y
los retardos de los demás pares de cables.
Monday, 10. August 2009, 02:04:54
Este es un reto algo interesante, por la amplia posibilidad de soluciones, ya que se peude solucionar desde con un simple manejo de Strings o por arreglos bidimensionales.
La solución que le dimos fue manejando arreglos, se nos facilita mas el manejo de entradas y validaciones, si alguno se anima a mostrar una solución diferente a los arreglos, seria muy agradable estudiarla.
Enunciado: http://sophia.javeriana.edu.co/maratones/programacion/6.Uniminuto/contest/H-PascalLibrary.pdfEntrada: http://sophia.javeriana.edu.co/maratones/programacion/6.Uniminuto/contest/PascalLibrary.inSalida: http://sophia.javeriana.edu.co/maratones/programacion/6.Uniminuto/contest/PascalLibrary.sol
public class Pascal {
private Vector Dinner = new Vector();
public static void main(String[] args) throws Exception {
Pascal p = new Pascal();
p.leer();
}
private void leer() throws Exception {
File f = new File( "Dinner.in" );
BufferedReader entrada = new BufferedReader( new FileReader( f ) );
String linea;
while (!(linea=entrada.readLine()).equals("0 0")){
StringTokenizer token = new StringTokenizer(linea," ");
String N = token.nextToken();
String D = token.nextToken();
//System.out.println(N+" "+D);
for (int i = 0; i <Integer.parseInt(D) ; i++) {
linea=entrada.readLine();
Dinner.add(linea);
}
crearMatriz(Integer.parseInt(N),Integer.parseInt(D));
Dinner.removeAllElements();
}
}
private void crearMatriz(int N, int D) {
String Alumni;
String [][] arrayA= new String [D][N];
int i=0;
for (int j = 0; j < D; j++) {
Alumni = (String)Dinner.get(i);
StringTokenizer token = new StringTokenizer(Alumni," ");
for (int k = 0; k < N; k++) {
arrayA [j][k]= token.nextToken();
//System.out.println(arrayA [j][k]+"Fila: "+j+"Columna: "+k);
}
i++;
}
boolean resultado=validar(arrayA,N,D);
if (resultado==true){
System.out.println("YES");
}else{
System.out.println("NO");
}
}
private boolean validar(String[][] arrayA, int N, int D) {
boolean flag= true;
int contador=0;
//System.out.println(N+" "+D);
//System.out.println(arrayA.length+" "+arrayA[0].length);
for (int i = 0; i < N; i++) {
//D
for (int j = 0; j < D; j++) {
//N
//System.out.println("fila "+j+" colum: "+i);
if (arrayA[j][i].equals("1")){
}else{
flag = false;
}
//System.out.println(arrayA[j][i]+" Fila: "+j+" Columna: "+i+"Bandera: "+flag);
}
if (flag==true){
return true;
}else{
flag= true;
}
}
return false;
}
}
Sunday, 9. August 2009, 16:49:48
Se nos han ocurrido una serie de ideas par el nombre..no se que opinen.
-NosObligaron
-YaPerdimos
-QHacemosAki
-DondeEstamos
-xQueNosotros
No me acuerdo de las demás, pero voy a ir anexándolas.....por ahora la que mas me gusta es la primera xD y ud que opinan?? jeje
Sunday, 9. August 2009, 00:33:20
Hay algo que no nos gusto de la solucion a este problema, y es el tiempo que toma en mostrar todas las salidas, por esa razon tenemos 3 posibles soluciones...aqui les dejo la primera.
Enunciado: http://sophia.javeriana.edu.co/maratones/programacion/2008/politecnico/warmup/phone.pdfEntrada: http://sophia.javeriana.edu.co/maratones/programacion/2008/politecnico/warmup/phone.inSalida: http://sophia.javeriana.edu.co/maratones/programacion/2008/politecnico/warmup/phone.out
class Escenario{
public Vector telefonos = new Vector();
public void setVector(String numero){
telefonos.add(numero);
}
public Vector gatVector(){
return telefonos;
}
}
public class Telefonos {
static Vector escenarios= new Vector();
public static void main(String[] args) throws Exception {
Telefonos t = new Telefonos();
t.leer();
}
private void leer() throws Exception {
File f = new File( "input.in" );
BufferedReader entrada = new BufferedReader( new FileReader( f ) );
int listas = Integer.parseInt((String.valueOf(entrada.readLine())));
for (int i = 0; i < listas; i++) {
int numeros = Integer.parseInt((String.valueOf(entrada.readLine())));
Escenario e= new Escenario();
for (int j = 0; j < numeros; j++) {
e.setVector(entrada.readLine());
}
escenarios.add(e);
}
for (int i = 0; i < escenarios.size(); i++) {
Escenario s= (Escenario) escenarios.get(i);
Vector tel= s.gatVector();
boolean telvalido = comprartel(tel);
if (telvalido) {
System.out.println("YES");
}else{
System.out.println("NO");
}
}
}
private boolean comprartel(Vector tel) {
for (int j = 0; j < tel.size(); j++) {
String num= (String) tel.get(j);
for (int k = 0; k < tel.size(); k++) {
if (k!=j) {
String num2= (String) tel.get(k);
if(num.length()>=num2.length()){
String substr= num.substring(0, num2.length());
if(substr.equalsIgnoreCase(num2)){
return false;
}
}else{
String substr2= num2.substring(0, num.length());
if(substr2.equalsIgnoreCase(num)){
return false;
}
}
}
}
}
return true;
}
}
Friday, 7. August 2009, 22:34:53
-Siempre es mejor leer y guardar para luego operar
-Siempre revisar la condición de parada
-Si los enteros son muy grandes y se necesitan operar, la solución es Biginteger..
-Las combinaciones y el manejo de recursividad siempre son la mejor solución para problemas con Strings.
-Un buen manejo de subStrings nos ara la vida muchisimo mas fácil xD
y por ultimo
No se que seria uno sin CTRL + ESPACIO ...
Friday, 7. August 2009, 22:20:02
Problema: http://sophia.javeriana.edu.co/maratones/programacion/2008/piloto/contest/G.RoundRoundWeGo.pdfEntrada:http://sophia.javeriana.edu.co/maratones/programacion/2008/piloto/contest/round.insalida:http://sophia.javeriana.edu.co/maratones/programacion/2008/piloto/contest/G.round.outEste es otro de los problemas, que vamos solucionanado, aun no estamos seleccionando problemas con mucha dificultad, pero no crean que no estan llenos de trampitas para que a uno se le totee la logica...
public class Round {
private Vector combinaciones = new Vector ();
public static void main(String[] args) throws Exception {
Round r = new Round();
r.leer();
}
private void leer() throws Exception {
File f = new File ("Round.in");
BufferedReader entrada = new BufferedReader (new FileReader (f));
String linea;
while ((linea=entrada.readLine())!=null){
combinar(linea);
producto(linea);
}
}
private boolean producto(String linea) {
BigInteger x = new BigInteger(linea);
for (int i = 1; i <= linea.length(); i++) {
String j=String.valueOf(i);
BigInteger resultado = x.multiply(new BigInteger(j));
String solucion=String.valueOf(resultado);
boolean res= comparar(solucion);
if (res== false){
System.out.println(linea+" is not Cyclik");
return false;
}
}
System.out.println(linea+" is Cyclik");
return true;
}
private boolean comparar(String solucion) {
for (int i = 0; i < combinaciones.size(); i++) {
String number=(String)combinaciones.get(i);
if (solucion.equals(number)||solucion.equals(number.substring(1, number.length()))){
return true;
}
}
return false;
}
private void combinar(String linea) {
linea = linea+""+linea;
for (int i = 0; i < (linea.length()/2); i++) {
String sub = linea.substring(i, (linea.length()/2)+i);
combinaciones.add(sub);
}
}
}
Friday, 7. August 2009, 16:17:40
Bueno este es otro de los problemas de entrenamiento que hemos seleccionado para ir recordando algo de métodos y pues para ir formando un Standard en la forma de programar de nuestro equipo..seguro se darán cuenta que de forma recursiva es mucho mas fácil, pero en este momento no hemos tocado ese tema aun, tan solo hacernos mas mañosos en el manejo de Sting.
Este problema es muy sencillo, se traba de tomar un numero separar sus dígitos y sumarlos..si el resultado es un numero de una cifra, se imprime, pero si es de mas de 1 cifra, se divide y se suma nuevamente, así sucesivamente.
public class Root {
private Vector numeros= new Vector();
public static void main(String[] args) throws Exception {
Root r= new Root();
r.leer();
r.metodoRaiz();
}
public void leer() throws Exception{
File f = new File( "root.in" );
BufferedReader entrada = new BufferedReader( new FileReader( f ) );
String linea;
while ((linea= entrada.readLine()) !=null) {
numeros.addElement(linea);
}
}
public void metodoRaiz(){
for (int i = 0; i < numeros.size(); i++) {
String numero=(String) numeros.get(i);
int arrEnteros[]=convertir(numero);
calcular(arrEnteros);
}
}
private void calcular(int[] arrEnteros) {
String resultado="10";
int raiz=0;
while(resultado.length()!=1){
raiz=0;
for (int i =0; i < arrEnteros.length; i++) {
raiz= raiz+ arrEnteros[i];
}
resultado= String.valueOf(raiz);
arrEnteros=convertir(resultado);
}
if (Integer.parseInt(resultado)!=0) {
System.out.println(resultado);
}
}
public int [] convertir(String numero){
char raiz [] = numero.toCharArray();
int convertir[]=new int [raiz.length];
for (int i = 0; i < raiz.length; i++) {
String num=String.valueOf(raiz[i]);
convertir[i]=Integer.parseInt(num);
}
return convertir;
}
}
Friday, 7. August 2009, 16:10:32
¿Qué es el maratón de programación?Es una competencia que consiste en diversos equipos conformados por tres estudiantes, un técnico y un entrenador, los cuales deben resolver la mayor cantidad de problemas en el menor tiempo posible.
Lenguajes Reconocidos: C, Pascal y Java.
¿Para qué sirve este tipo de eventos?Para estimular el conocimiento de lenguajes de programación, para incentivar la destreza en el manejo de algoritmos, para desarrollar las técnicas de trabajo en grupo y, por supuesto, para divertirse.
Características de los ejercicios. Los ejercicios están planteados en cuatro partes:
Nombre del archivo: En este segmento se dará el nombre del archivo fuente, el nombre del archivo de entrada y el nombre del archivo de salida que debe generar.
Descripción del problema: En este segmento se explicará de forma breve y concisa las características que presenta el ejercicio.
Archivo de entrada: En este segmento se dará a los participantes una entrada de datos para que ellos puedan revisar sus ejercicios y verificar si están bien realizados.
Archivo de salida: Este segmento le dará a los participantes los resultados que se deben obtener del archivo de entrada.
Prguenten en sus universidades, que hacer para participar y si aun no entras a la universidad entonces ponte apracticar
Showing posts 1 -
10 of 15.