Archivo del Author
Palíndromos en Java
Un palíndromo es una palabra, número o frase que se lee igual de izquierda a derecha o de derecha a izquierda. Un ejemplo clásico es “Dábale arroz a la zorra el abad”, o como dijeron en los Simpson “Anita lava la tina”. También palabras como “ala” o números como “2002″.
Lo que este código hace es leer una línea y ver si ordenándola de alguna manera se puede generar un palíndromo, por ejemplo “Yoga hoy yo hago” NO es un palíndromo, pero si lo ordenamos de esta forma “Yo hago yoga hoy” obtenemos una frase que SI es un palíndromo. Para hacer esto me resultó útil parte del código que publiqué en el post “Anagramas en Java” ya que lo que hago es probar todas las conjugaciones que se pueden hacer con las palabras de la frase ingresada y luego ver si alguna(s) de ellas es un palíndromo.
Es una solución que usa fuerza bruta y se puede mejorar fácilmente, por ejemplo detectando si para la primera palabra de una conjugación hay otra palabra que acabe con la misma letra (“Sx xxxx xx xx xx xxs”) y no hacer conjugaciones en vano, pero esa es otra historia.
Este código lee un número n de casos y luego imprime los parónimos que se pueden obtener ordenando las palabras de alguna manera. Para evitar palíndromos repetidos (por ejemplo si ponemos “a a b” podríamos tener 2 veces “a b a” – “a b a”) seguí la recomendación de Pedro en “Anagramas en Java” y almacené todos los palídromos en un Set y así evitamos los repetidos =D. Si no hay ningún palíndromo posible se muestra el mensaje “imposible”.
PD: El código no funciona con tildes (bienvenido el que quiera agregar los replace() ).
import java.io.*;
import java.util.HashSet;
public class Palindromos {
public static void main(String[] args) throws IOException {
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.println("Ingrese el numero de lineas:");
int nro= Integer.parseInt(br.readLine());
for (int i=0;i<nro;i++){
String cadena=br.readLine();
//Pasamos todas las letras a mayuscula para no hacer distincion
cadena=cadena.toUpperCase();
//Un arreglo con cada palabra
String[] palabras=cadena.split(" ");
//Una variable de control para el método recursivo
//que se va a usar
int veces=0;
//Un arreglo de cadenas que se usará para
//hacer conjugaciones
String[] conjugacion= new String[palabras.length];
//Un Set donde se almacenarán las conjugaciones
//y permitirá identificar repetidos
HashSet<String> palindromos=new HashSet<String>();
//El méttodo recursivo
conjugar(palabras, veces,conjugacion,palindromos);
//Output
if (palindromos.isEmpty()){
System.out.println("imposible");
}else{
System.out.println("Palindromos encontrados: ");
for(String pal:palindromos){
System.out.println("- "+pal);
}
}
}
}
public static void conjugar(String[] palabras, int veces,
String[] conjugacion, HashSet<String> palindromos){
//Si la conjugacion está completa, probamos si es palíndromo
if (veces==palabras.length){
probarPalindromo(conjugacion,palindromos);
return;
}
//Desde aquí es casi idéntico que el código del anagrama
veces++;
for (int i=0; i<=palabras.length-1;i++){
if (palabras[i].compareTo("@")==0){
continue;
}else{
String palabraAuxiliar=palabras[i];
conjugacion[veces-1]=palabraAuxiliar;
palabras[i]="@";
conjugar(palabras,veces,conjugacion,palindromos);
palabras[i]=palabraAuxiliar;
}
}
}
public static void probarPalindromo(String[] conjugacion,
HashSet<String> palindromos){
//Armamos una cadena en base al arreglo de Strings
//La cadena no tendrá espacios entre letras,
//ya que para ser palíndromo
//estas no se toman en cuenta
String cadena1="";
for (String s:conjugacion){
cadena1=cadena1+s;
}
int veces;
//Luego lo pasamos a un arreglo de caracteres
//para hacer las comparaciones
//Esto se puede hacer de varias maneras
char[] carac=cadena1.toCharArray();
int longitud=carac.length;
if (longitud % 2==0){
veces=longitud/2;
}else{
veces=(longitud-1)/2;
}
//Una bandera que indica que no es palindromo
boolean flagNoPalindromo=false;
for(int i=0;i<=veces;i++){
//La idea es comparar el primer caracter con el último
//Luego el segundo con el penúltimo, etc etc
if (carac[i]==carac[longitud-i-1]){
}else{
flagNoPalindromo=true;
}
}
if (flagNoPalindromo==true){
return;
}
//Armamos otra cadena, ahora los espacios entre letras
String cadenaSalida="";
for (String s:conjugacion){
cadenaSalida=cadenaSalida+s+" ";
}
//Finalmente le damos un poco de formato y lo agregamos al Set
String cadenaFormateada=cadenaSalida.substring(0,1)+
cadenaSalida.substring(1,
cadenaSalida.length()-1).toLowerCase();
cadenaFormateada="\""+ cadenaFormateada+"\"";
palindromos.add(cadenaFormateada);
}
}
Anagramas en Java
Un anagrama es una palabra que resulta de la transposición de las letras de otra palabra. Por ejemplo con ifx podemos obtener ifx,ixf,fix,fxi,xif,xfi (saber cuales de estas son palabras reales es un asunto totalmente distinto …). Hacer un programa en java para obtener todas estas posibles conjugaciones no es difícil, pero es interesante porque se requiere usar un método recursivo y esta clase de métodos tiende a seguir el patrón pocas líneas de código bastante dolor de cabeza. Esta es sólo una manera de solucionar un anagrama, debe de haber varias más.
import java.util.ArrayList;
public class Anagrama {
private ArrayList<String> soluciones=new ArrayList<String>();
public Anagrama(){ }
public static void main(String args[]){
Anagrama a=new Anagrama();
String palabra="ifx";
a.resolver(palabra);
System.out.println(a.getSoluciones());
}
public void resolver(String palabra){
palabra=palabra.toLowerCase();
char[] letras=palabra.toCharArray();
int tamanioPalabra=letras.length;
int numeroIteraciones=0;
char[] cadenaActual=new char[letras.length];
resolver(letras,cadenaActual,tamanioPalabra,numeroIteraciones);
}
private void resolver(char[] letras,char[] cadenaActual,
int tamanioPalabra,int numeroIteraciones){
if (numeroIteraciones==tamanioPalabra){
getSoluciones().add(new String(cadenaActual));
}
numeroIteraciones++;
for(int i=0;i<tamanioPalabra;i++){
if (letras[i]=='A'){
//Como se paso todas las letras a minúscula, se usa "A"
//para indicar que la letra en esa posición ya se utilizó,
//de ser así sólo paso a la siguiente letra
}else{
char valorEliminado=letras[i];
//valorEliminado es la letra que ya use y no
//se debe seguir usando
cadenaActual[numeroIteraciones-1]=valorEliminado;
letras[i]='A';
//Un valor q le doy para mostrar que ya lo elimine
resolver(letras,cadenaActual,tamanioPalabra,numeroIteraciones);
letras[i]=valorEliminado;
}
}
}
public ArrayList<String> getSoluciones() {
return soluciones;
}
public void setSoluciones(ArrayList<String> soluciones) {
this.soluciones = soluciones;
}
}
Definiendo colores para una web
Elegir colores para el diseño de una página web no me parece un trabajo sencillo, al menos a mí me toma bastante elegir qué colores combinan (mis elecciones son más que debatibles) y no terminar cogiendo los del primer cartel de propaganda de los hermanos yaipen. Este ciclo estoy llevando un curso de ingeniería web en la universidad y nos dejaron como trabajo hacer el diseño que tendrá nuestro proyecto de laboratorio, así que el lector entenderá mi desesperación por hacer que los colores combinen.
Afortunadamente existe una pequeña (pero realmente útil) aplicación llamada Kuler que me sacó del apuro. Kuler pertenece a Adobe y nos permite crear esquemas de colores, es decir, juegos de colores que se complementan, son análogos entre sí, o simplemente “se ven bonito juntos”.Para llegar a esos esquemas hay que jugar con la rueda de colores, que viene a ser la paleta de Miguel Angel; podemos usar reglas como triada (3 colores distribuidos equitativamente en la rueda), colores complementarios, colores análogos, etc. Podemos elegir el color base directamente de la rueda o ingresar el código (hay varios códigos pero solo conozco el hexadecimal) y después ir modificándolo de acuerdo a nuestras preferencias. Es necesario tener flash instalado para usar la aplicación.
Esta herramienta es gratuita y no es necesario registrarse para comenzar a usarla, sólo hace falta entrar al siguiente link para empezar a formar tus propios esquemas: http://kuler.adobe.com
- Para más información sobre esquemas de colores y la rueda de colores pueden visitar este link: http://s3.accesoperu.com/wp6/includes/htmlarea/mezclador/ayuda/ec.htm
Google Buzz
Este es un producto nuevo de Google que se presenta diciendo “Mucho más que mensajes de estado. Comparte tus novedades, fotos y vídeos con tus amigos. Inicia conversaciones sobre los temas que te interesan”.
Buzz tiene un gran parecido con Twitter y Facebook en cuanto a las funcionalidades que brinda, como es el manejo de estado y compartición de fotos, aunque hay que decir que es más limpio que facebook en cuanto a su interfaz. Con este nuevo servicio Google busca sacar provecho a toda esa red social que está bajo Gmail.
Algo que me pareció interesante fue que al querer poner una imagen en mi mensaje de estado aparte de la opción de subir imágenes desde mi PC me aparecieron todas las imágenes que he usado en algún post en mi blog de blogger. Una vez que las fotos han sido publicadas las demás personas pueden verlas haciendo click en ellas, para lo cual se oscurece la pantalla enfocándose dicha foto.
Buzz está incluido dentro de la bandeja de Gmail por lo que será más fácil que la gente experimente con él, a diferencia de Google Wave que es un servicio separado. Permite integrar elementos de Google Reader, Twitter, Flickr, Picasa, Youtube, etc. Además cuenta con un sistema de filtrado para que llegue lo más relevante al usuario.
Aquí dejo el video de presentación de Google Buzz, más divertido que leer todo lo que he escrito:
Algoritmo de la Amistad
Este es algoritmo para hacer amigos, sacado de The Big Bang Theory, alguien se anima a hacerlo en diagrama N-S?
Efecto de Nieve en Action Script 3.0
//Posiciones de fondonieve
//Fondo nieve es un símbolo que marca el cuadro donde caerá nieve
var left:Number = this.fondonieve.x;
var right:Number = left+this.fondonieve.width;
var top:Number = this.fondonieve.y;
var bottom:Number = top+this.fondonieve.height;
//Número de copos de nieve
var total:Number;
total=250;
//Variable que almacenará los copos de nieve
var miArray:Array;
//Crear el fondo, en este caso el Sprite donde va la nieve
//y la máscara para que los copos de nieve no salgan de ahí
function createBackground():void {
//Crear el Sprite para la nieve
var ele:Sprite =new Sprite();
ele.name="ele";
//Posicionarlo en el mismo lugar que fondonieve
ele.x=this.fondonieve.x;
ele.y=this.fondonieve.y;
//Agregalo
addChild(ele)
//Crear el Sprite mask2 que usaremos de máscara
var mask2:Sprite =new Sprite();
mask2.name="mask2";
//Posicionarlo en el mismo lugar que fondonieve
mask2.x=this.fondonieve.x;
mask2.y=this.fondonieve.y;
//Agregalo
addChild(mask2)
//Dibujar un rectángulo con las medidas de fondonieve
var g2:Graphics = mask2.graphics;
g2.beginFill(0x000000, 100);
g2.moveTo(0, 0);
g2.lineTo(this.fondonieve.width, 0);
g2.lineTo(this.fondonieve.width, this.fondonieve.height);
g2.lineTo(0, this.fondonieve.height);
g2.lineTo(0, 0);
g2.endFill();
//Establecer a mask2 como la máscara de ele
ele.mask=mask2;
}
//Creación los copos de nieve
function createParticles() {
//Obtener el Sprite ele del escenario
var ele:Sprite;
ele=Sprite(getChildByName("ele"));
//Instanciar el arreglo
miArray=new Array();
//Usar un for para crear los copos de nieve
for (var i:Number = 0; i<total; i++) {
//Nieve es una clase-símbolo con la imagen de un copo
var clip3:Nieve=new Nieve();
ele.addChild(clip3);
//Crear un Object con los atributos necesarios: el movieclip del copo de nieve(Sprite), posiciones x - y, velocidad de movimiento x - y, rotación, dos contadores ct y c para realizar los cambios de dirección y hasta donde deben caer fl
var obj:Object = {mc:clip3, mn:1+Math.random()*2, x:Math.random()*this.fondonieve.width, y:-100, movx:Math.random()*2-1, movy:Math.random()*3+0.5, r:Math.random()*10-5, ct:Math.ceil(Math.random()*60), c:0, fl:this.fondonieve.height-Math.random()*3};
//Unicar el copo de nieve en las posiciones establecidas
clip3.x=obj.x;
clip3.y=obj.y;
//Agregar el obj al arreglo
miArray.push(obj);
//Deformar y girar el copo de nieve para que no sean todos iguales
clip3.scaleX= 2+Math.random()*3;
clip3.scaleY= 2+Math.random()*3;
clip3.rotation=Math.random()*360;
}
}
//Funcion que se va a ejecutar en cada evento EnterFrame
function myForEachFunction (obj:Object, index:int, array:Array):void
{
//obj es cada Object que se tiene en miArray
//Recordar que obj.mc contiene el MovieClip del copo de nieve
var mc:MovieClip = obj.mc;
obj.c++;
//Verificar si hay que cambiar la dirección
//Esto es cuando el contador c pasa a ct
if (obj.c>obj.ct) {
//Cambiar la dirección y reestablecer c y ct
obj.movx = Math.random()*5-2.5;
obj.c = 0;
obj.ct = Math.floor(Math.random()*60);
}
//Hacer los cambios en obj
obj.x += obj.movx;
obj.y += obj.movy+obj.mn
//Aplicar los cambios en el movieclip del copo de nieve
mc.rotation += obj.r;
mc.y = obj.y;
mc.x = obj.x;
//Verificar si el copo de nieve ha salido de los bordes derecho o izquierdo
//De ser así reaparece por el borde contrario
if (mc.xthis.fondonieve.width+5) {
obj.x = left-2;
}
//Verificar si el copo de nieve ya cayo completamente
if (mc.y>obj.fl) {
obj.fl=this.fondonieve.height-Math.random()*3;
//Reubicar el copo de nieve arriba
obj.y -=this.fondonieve.height;
obj.movy = Math.random()*3+0.5;
}
}
//Función a realizar en cada evento Enter Frame
function onLoop(evt:Event):void {
//Ejecutar para cada elemento de miArray la función myForEachFunction
miArray.forEach(myForEachFunction)
}
//Agregar un listener al evento Enter Frame y darle la función onLoop
this.addEventListener(Event.ENTER_FRAME, onLoop, false,0, true);
//Llamadas a los métodos para crear todo
createBackground()
createParticles()
Pueden modificar valores como la cantidad de copos de nieve o mejor aún pueden agregarle sus propias imagenes y ver cómo cae la nieve. El resultado es algo así:
Para ver la animación real ir a este link:
Xoo Image

Xoo Image es un hosting frances que fácilmente se puede considerar “un misterio”, o también una bendición dependiendo de como lo mires. No pide registro, es rápido, es gratis, y te permite subir cualquier tipo de archivo. Descubrí esta página hace un tiempo cuando buscaba algún hosting para archivos swf ya que lo necesitaba para mi blog, traté con varios pero o no aceptaban este tipo de archivos o no se veía bien al querer usarlos.
Su página principal no nos dice casi nada, tan solo tiene un mensaje “Subir una imagen o fichero” (al menos eso creo porque está en francés) y luego dos botones, uno para elegir el archivo y el otro dice “Envoyer” (enviar segun WordReference). Una vez que has subido el archivo que quieres Xoo te brinda una url (bastante simple la forma en que te devuelve la url) con la que puede acceder al archivo que subiste.





