a veces, las cosas cambian
22/10/2007 19:53

Esta semana estaré de reunión en Santiago de Chile, preparando la próxima edición de IEEEXtreme, el concurso de programacion de IEEE, pero prometo mandar algun problemilla desde allá en cuanto tenga conexion.

De momento, por dejar algo mas ligero que el ultimo problema que puse, para que no se me queje nadie, os dejo un pequeño puzzler, en el que (como ya comentamos) lo que queremos es adivinar que función realiza un determinado programa pero SIN ejecutarlo. La idea subyacente es que, si lo que pasa no es lo que esperábamos, siempre podemos investigar por qué.

En nuestro caso, sea el siguiente programa:

using System;

public class MusicStar {
string name;
Style style;

protected MusicStar() {
// utilizado solo para las herencias
}

public MusicStar(String name, Style style) {
this.name = name;
this.style = style;
}

public override string ToString() {
return "nombre: " + name + " (estilo:" + style + ")";
}

public class Style {
string stylename;

public Style() {
}

public void SetStyleName(string name) {
this.stylename = name;
}

public override string ToString() {
return stylename;
}
}
}

public class HardRockStar : MusicStar {

public HardRockStar(String name, Style style) : base(name, style) {
if(style.ToString() != "Hard Rock") {
throw new ArgumentException(
"Nada de mariconadas! Solo me gusta el rock!");
}
}
}

public class Changes {

public static void Main(String[] args) {
MusicStar.Style style = new MusicStar.Style();

style.SetStyleName("Hard Rock");
HardRockStar slash = new HardRockStar("Slash", style);

style.SetStyleName("CutrePop");
MusicStar paulina = new MusicStar("Paulina Rubio", style);
MusicStar marta = new MusicStar("Marta Sanchez", style);

Console.WriteLine("nuestras estrellas de esta noche son:");
Console.WriteLine(slash.ToString());
Console.WriteLine(paulina.ToString());
Console.WriteLine(marta.ToString());
}
}

¿Cual seria la salida al ejecutar la funcion principal (Main) de MainProgram? ¿Por que?

NOTA: para el que quiera alguna pista adicional, aqui os dejo dos en forma de videos: Paulina y Marta (para ahorraros el tiempo de ver el resto de la basurilla musical, os recomiendo pasar directamente a los minutos 2:30 y 2:45 respectivamente) 

ACTUALIZACION: me di cuenta tarde que habia pegado la version del codigo que no era! Os he dejado la version actualizada, pero abajo pongo un comentario para los que ya os animasteis a enviar respuestas. Mil perdones! 

todos por igual
16/10/2007 15:30

Este es otro problema de algoritmia generica, antes de que sigamos analizando algoritmos y tecnicas de diseño, para intentar pensar "out-of-the-box".

Imaginemos que tenemos un array de enteros, de tamaño K, y un flujo del que vamos leyendo enteros, hasta un numero N. No conocemos N de antemano, pero sabemos que sera igual o mayor que K. Lo que queremos es tener en nuestro array de K posiciones una muestra equiprobable de los enteros del flujo.

¿Que quiere decir esto? Imaginemos que nuestro array tiene K=5 elementos y supongamos una notacion (a-b-c) para un flujo que contenga los elementos a, b y c.

Si nuestro flujo fuera todo de unos, como en (1-1-1-1-1-1-1), nuestro array final debe contener 5 unos siempre.

Si en cambio nuestro flujo fuera algo como (1-1-1-1-2-1-1-1-1-2), debe haber 4 veces mas posibilidades de tener unos que doses, con lo que nuestros posibles resultados serian: un array con todo unos (aproximadamente un 22.2% de las veces), un array con 4 unos y 1 dos (el dos puede estar en distintas posiciones, pero ocurrira aproximadamente un 55.6% de las veces) y un array con 3 unos y 2 doses (de nuevo pudiendo estar los doses en distintas posiciones, y que ocurrira aproximadamente el 22.2% de las veces)


Supongamos que nuestro flujo de entrada esta modelado mediante las funciones:

- boolean hasNext(): devuelve true si quedan elementos por leer, false en otro caso
- int getNext(): obtiene el siguiente entero del flujo mientras queden elementos, o un valor indeterminado en otro caso

Dado un numero K de posiciones para el array, y un flujo de entrada de longitud N indeterminada (pero finita): ¿serias capaz de construir el algoritmo para devolver una muestra equiprobable tal como la hemos definido anteriormente?

nota: las funciones que modelan el flujo estan dadas en notacion estilo C. Podeis cambiarlas a algo apropiado en el lenguaje que utiliceis, siempre y cuando conserven la semantica, claro 

por phobeo | 14 comment(s)
Archivado en: ,
ejercicio y números confusos
4/10/2007 11:19

Supongo que no hace falta que os diga que el ejercicio es bueno para la salud. Todo el mundo deberia practicarlo a menudo: te hace sentir bien, te pones menos enfermo... A mi hasta me parece que piensas mejor si haces ejercicio de cuando en cuando! Y eso sin contar con que supone una muy buena "desconexion" del mundo, que ayuda a dar otro punto de vista a las cosas.

Yo suelo tener por costumbre hacer ejercicio a mediodia, antes de la hora de comer. Despues de la jornada de la mañana, una pausa para nadar te da una hora de relajacion que ademas puedes aprovechar al volver para repensar aquello en lo que estabas trabajando.. y a veces darle a las cosas un giro en el que no habias caido antes.

De hecho, este problema se me ocurrio en una de estas visitas a la piscina antes de trabajar, y tiene que ver bastante con "cambiar el punto de vista". A ver que os parece:

En el centro al que yo voy, como en muchos otros, hay un sistema de taquillas para dejar la bolsa mientras nadas. simplemente pides una taquilla en la puerta y te dan una llavecita con un numero. Vas a la taquilla, dejas tus cosas, cierras, te vas a nadar y posiblemente cuando vuelvas aun este todo alli. El caso esta en que esa tarde a mi me dieron la llave numero 89. Yo fui tan contento a cambiarme y cuando estaba buscando... me di cuenta que solo veia 80 taquillas.

"Se me debe estar pasando algo", me dije. Conte el numero de armarios, vi cuantas taquillas cabian... y no, no podia ser. Ademas, no hay mas sitio para armarios. "¿Sera que a lo mejor a partir de la 80 estan en el vestuario de las chicas y me han dado la llave que no es?" Estaba yo pensando en dar la vuelta e ir a preguntar a recepcion cuando me dije... "mmm... dar la vuelta... podia ser..." Y claro, es que un llavero no tiene un derecho ni un reves, y los numeros escritos a mano son dificiles de leer, asi que mi llave numero 89, dada la vuelta, bien podria ser la numero 68, ¿no? Pues efectivamente... ¡asi de simple era! Asi que abri mi taquilla, deje mis cosas y me fui a nadar

Pero claro, ya iba pensando en lo siguiente: imaginemos que hacemos un sistema de OCR limitado, que usaremos para reconocer numeros a partir de imagenes de video. Como no conocemos la orientacion de la camara, esos numeros podrian estar en un momento cualquiera tanto al derecho como al reves. Asi, esfacil leer un 6 como si fuera un 9, o viceversa. Ademas, si estos numeros estan escritos a mano y las imagenes son de baja resolucion es facil confundir algunos incluso sin tener orientacion: por ejemplo el 8 con el 0 (especialmente si escribis el cero con una barra cruzada, como yo)

Imaginemos entonces que hemos definido las siguientes posibles confusiones:

  • 0 se puede confundir con 8, tanto al derecho como al reves
  • 1 se puede confundir con 7, tanto al derecho como al reves
  • 2 se puede confundir con 7, al reves
  • 3 se puede confundir con 8, tanto al derecho como al reves
  • 4 y 5 no se confunden con nada, son asi de majos
  • 6 se puede confundir con 9, al reves
  • 7 se puede confundir con 1, tanto al derecho como al reves, y con 2, al reves
  • 8 se puede confundir con 0 y con 3, tanto al derecho como al reves
  • 9 se puede confundir con 6, al reves

¿Podrias crear una funcion que reciba un array de caracteres con lo que hemos leido del OCR y devuelva un array de enteros con todos los posibles valores que pueden representar leidos al derecho o al reves (si se puede), teniendo en cuenta que pueden ocurrir las confusiones que hemos citado antes? En el ejemplo de mi llave de la taquilla, recibiriamos el array ['8','9'] y tendriamos que devolver [89, 68, 09, 60, 39, 63]

Suponemos que la entrada siempre es un array de caracteres que representa un numero entero positivo.

el bug de multiplicacion de Excel 2007
28/9/2007 1:14

Acabo de aterrizar de Ibiza de unas minivacaciones impresionantes (y en las cuales de paso he escrito un par de problemas nuevos para programancia101!) asi que no he podido seguir en directo la serie de articulos que han aparecido en la blogosfera acerca de un bug en Excel 2007. Afortunadamente, mi amigo Chema "el maligno" me ha mandado un correito para asegurarse que nos haciamos eco de esta noticia.

 Para los que no lo hayais visto ya, resulta que se ha encontrado un pequeño bug en Excel 2007 (noticia en español en Microsiervos) con algunas multiplicaciones. Podeis encontrar mas ejemplillos por la web, pero el aviso original se referia a la multiplicacion 850 * 77.1, que en vez de 65535, que es el resultado correcto, se muestra como 100000.

 

Como buenos lectores de programancia101 y revisando algunos de nuestros articulos anteriores (como este y este), seriais capaces de adivinar cual es la hipotesis razonable mas probable que puede causar este tipo de fallo?

Para los que quieran directamente "la solucion", podeis mirar este post del equipo de Excel, que se puso manos a la obra para arreglarlo el dia despues del aviso.
 

arrejuntando listas
19/9/2007 12:15

Antes de que nadie me comente nada: prometo que "arrejuntarse" es un verbo español perfectamente valido! Pese a que suene un poco "brutito" en realidad se refiere a vivir vida de casados sin estarlo. Tengo de hecho un par de amigos que estaban haciendo eso mismo hasta que hace unos meses se les fue la pinza cambiaron de idea y decidieron casarse, asi que este finde nos tocara boda! (y vistos los ejemplos de algunos miembros de geeks, parece que este año hay ida de olla general tendencia al tema)

Pero en fin, nosotros a lo que es el codigo, que es lo nuestro...

 

 Vamos a proponer hoy un par de variaciones de problemas con listas:

Para empezar, imaginemos que tenemos dos listas previamente ordenadas y que queremos generar una tercera lista que tenga todos los elementos de las dos anteriores, pero tambien ordenados. Asi por ejemplo si una lista es (1,4,7) y la otra (2,5,6) el resultado debe ser la lista (1,2,4,5,6,7)

Podrias escribir una funcion que reciba como entrada las dos listas y que devuelva la lista resultante, segun la descripcion anterior? Se te ocurre una forma de crear una funcion generalizada que haga lo mismo para un numero N de listas?

Y ahora imaginemos que tenemos un sentido del orden un poco extraño, y que lo que queremos es ordenar las listas de modo que en la lista resultado los elementos impares esten ordenados ascendentemente partiendo desde el centro y hacia la izquierda, y los pares desde el centro, hacia la derecha. Es decir, en el ejemplo anterior con (1,4,7) y (2,5,6) nuestro resultado deberia ser (7,5,1,2,4,6)

Podrias escribir una funcion que cree la lista resultante en este caso?

que tal vuestra vuelta al cole?
14/9/2007 9:49

Buenas a todos!

Esto no es ninguna noticia pero... se acabaron las vacaciones! Agh! Que sufrir! Hay que volver al trabajo, verle la cara al jefe otra vez, reunirnos con unos clientes que necesitan algo "para ya" porque se les ha ido el verano y nadie se acordaba que habia que entregar en septiembre, pasar la semana releyendo el codigo que dejamos "a medias" y que no recordamos muy bien lo que hace porque con las prisas se nos "olvido" documentar y comentar... os suena? (el caso peor de esto ultimo es cuando al volver miras tu codigo y dices: "seguro que esto lo escribi yo?")

Para haceroslo mas leve, os recomiendo que empeceis leyendo algo gracioso como este clasico sobre comentarios en el sistema UNIX (que incluye uno de mis favoritos: "no hace falta que entiendas esto" };D) Si conoceis algun otro ejemplo, de esos dignos de salir en worsethanfailure.com... compartidlo!

En fin, solo queria avisar que en breve comenzamos el nuevo curso en programancia101, con nuevos problemas de todos los niveles y los ocasionales truquitos divertidos. Este curso ademas contaremos con un par de "articulos invitados" y algunas recomendaciones de libros. Y por supuesto, si teneis alguna otra idea que podamos añadir, hacedmelo saber! }:)

Feliz vuelta al cole! 

volvemos a la carga: rellenando espacios
16/5/2007 11:50

Hola de nuevo, crases! Mil perdones por mi desconexion del mundo estas ultimas semanas. He tenido algunos lios que atender que han ido postponiendo la publicacion de mas problemas. La buena noticia es que me ha dado tiempo a pensar algunos problemas mas asi que... espero resarcirme publicando a un ritmo mas acelerado en los proximos dias!

Como deciamos en los ultimos posts, habia pensado seguir con algunos ejercicios de algoritmia basica y que nos permitan repasar conceptos como la ordenacion, la insercion y distintas tecnicas que nos serviran mas adelante. Para empezar a calentar despues de esta pausa, os propongo un problema sencillo:

Imaginemos que tenemos un array de caracteres que representa una cadena de texto formada por palabras separadas por espacios. Imaginemos que tenemos una cantidad N de caracteres de subrayado ('_') por los que queremos sustituir los espacios, de una forma uniforme. Es decir: si tenemos los caracteres que representan "una frase cualquiera" y tenemos 4 caracteres de subrayado, querriamos algo como "una__frase__cualquiera" (2 signos de subrayado por espacio). Si solo tuvieramos 3 caracteres, tanto "una_frase__cualquiera" (un subrayado primero, dos en el segundo) como "una__frase_cualquiera"  (dos subrayados en el primero, uno en el segundo) serian validas.


taken from http://flickr.com/photos/ashleylynn/252023013/)

Asi que en resumidas cuentas: podrias escribir una funcion que dado el array de caracteres que representa la cadena, y un numero N de caracteres de subrayado, devuelva la cadena resultante de sustituir los espacios por subrayados de forma uniforme?

Si quieres complicarlo un poco mas podrias intentar tambien devolver todas las posibles cadenas (si hay mas de una) 

Actualizacion: Parece ser que no me explique del todo bien en este problema, lo siento. Para que no haya equivocos sobre que quiere decir "distribucion uniforme" una definicion "formal" seria: no puede haber una diferencia de mas de 1 entre el numero de subrayados que asignamos a cada espacio. Asi por ejemplo:

  • Si tenemos "frase con tres espacios" y 7 signos de subrayado, la distribucion "frase__con__tres___espacios" (2 al primero, 2 al segundo y 3 al tercero) es uniforme, pero la distribucion "frase___con___tres_espacios" (3 al primero, 3 al segundo y uno al tercero) no lo es
  • Si tenemos "frase mas larga que la anterior", la distribucion "frase_mas_larga_que__la__anterior" (1-1-1-2-2 signos de subrayado) es uniforme, pero la distribucion "frase___mas_larga_que_la_anterior" (3-1-1-1-1 signos de subrayado) no lo es

Asimismo, para efectos de "precondiciones" podeis suponer que la frase siempre tiene al menos un espacio, y que solo hay un espacio entre palabra y palabra.

por phobeo | 18 comment(s)
Archivado en: ,
dandole al interruptor
9/3/2007 1:33

El fin de semana pasado prometi a varios amigos que de esta semana no pasaba que publicara un nuevo problemilla de programancia101, porque ya veo que a la que uno se descuida, le sale competencia! Mirad si no a mi camarada Kartones, que se esta animando a publicar problemas en su blog.

Como me ha gustado la idea, se me ha ocurrido dejar otro problema que podeis resolver con un algoritmo sencillito, o bien usando "trucos":

Imaginemos que tenemos una fila con 64 interruptores, cada uno de los cuales conectamos a una bombilla. Supongamos que partimos de una posicion en la que todas las bombillas estan apagadas y procedemos a pasar por todas ellas y cambiar el estado del interruptor. Una vez hecho esto, volvemos al principio y volvemos a cambiar la posicion del interruptor pero solo para las bombillas en posiciones que sean multiplos de 2 (la segunda, la cuarta, la sexta, ...) De nuevo volvemos al principio y volvemos a cambiar la posicion del interruptor pero solo para posiciones multiplos de 3 (la tercera, la sexta, la novena, ...) Y seguimos repitiendo el procedimiento para posiciones multiplos de 4, de 5, de 6... asi hasta los multiplos de 64.

Que algoritmo usarias para saber cuales de las bombillas permaneceran encendidas al terminar? Y, si te apetece complicarte un poco mas: Como podriamos hacerlo utilizando la menor cantidad de memoria posible? 

ordenando a montones
14/2/2007 13:45

Como algunos de vosotros sabreis, esta semana tengo a Chema de visita en casa, asi que escribir se nos esta haciendo mucho mas dificil (porque claro, la fiesta y los blogs no son muy compatibles). Sin embargo, tenia pensado empezar a anyadir mas tipos de problemas esta semana, asi que... alla vamos!

En este problema vamos a intentar subir un poco el nivel... de abstraccion, quiero decir. Vamos a desempolvar un poco esos libros de algoritmos y ver un problema muy basico: la ordenacion. Pero claro, esto es programancia101 y aqui no podemos ordenar cualquier cosa. Al igual que en otras ocasiones, vamos a plantear este problema por fases:

  • La primera parte seria algo como: sabrias decir cual es la forma mas rapida de ordenar diez mil (10.000) numeros? Que tiempo (aproximadamente) llevaria hacerlo en tu ordenador?
  • La segunda, continuando con la idea: cual es la forma mas rapida de ordenar un millon (1.000.000) de numeros? Que tiempo (aproximadamente) llevaria hacerlo en tu ordenador? Se comporta de forma lineal con el caso anterior? Por que?
  • La tercera, partiendo de este segundo caso: imaginemos que la maquina en la que vamos a ordenar nuestro millon de numeros solo tiene 2 megabytes de memoria, una cantidad ilimitada de disco duro y que nuestros numeros son enteros sin signo de 32 bits. Supon que disponemos de un flujo de entrada para leer los enteros de forma secuencial y un flujo de salida en el que podemos escribir enteros, ambos accesibles mediante las funciones/metodos:
    // Devuelve el siguiente entero a ordenar
    int LeerSiguiente();
    // Escribe el entero en el stream de salida
    void Escribir(int numero);

    NOTA: a efectos de complejidad, podemos suponer que las llamadas a estas funciones/metodos son de orden constante
    Cual seria la mejor forma en este caso?
  • Y finalmente, la cuarta, rizando el rizo: imaginemos que los numeros anteriores proceden de un listado sin repeticiones de numeros de telefono de exactamente 7 digitos y que NO tenemos acceso a disco (y si, seguimos teniendo solo 2 megabytes de memoria): serias capaz de ordenarlos de la forma mas rapida posible?

Como siempre, estais invitados a comentar vuestras soluciones en los comentarios, o bien publicarlas en vuestro blog y dejar un enlace! }:)

NOTAS: Como orientacion de dificultad: las dos primeras partes deberian ser sencillas para un nivel basico/medio y repasando un poco algo de algoritmos de ordenacion. La tercera es un poco mas intermedia y la cuarta requiere un poco mas de pensar (asi que la he puesto como avanzada).


testeando en el cuarto de baño
6/2/2007 12:35
(y pondria lo de "testeando" entre comillas porque no se como traducir "bonitamente" el anglicismo, pero es que entonces suena sospechoso)

Ya comente que una de las cosas que queria poner en programancia101, aparte de problemas, son recomendaciones de "buenas practicas". En este caso, no es que vaya a decir que testear es una buena idea, eso lo sabeis todos (verdad?)... solo queria compartir este programa que usamos en Google para dar a conocer buenas practicas para la fase de pruebas entre los desarrolladores. La idea basica es: coloca la informacion donde TODOS puedan leerla }:)



Asi surgio la idea de "Testing On The Toilet" (lo que viene a traducirse en español como el titulo de este articulo). Si colocamos semanalmente una hoja con problemas sobre testing en uno de los lugares mas visitados de la oficina, la gente acaba por leerla. Desde hace unos dias, estos bonitos ejemplos de cultura Googley estan disponibles para descarga desde el Google Testing Blog (solo en ingles, eso si)

Asi que ya sabes: bajatelo, imprime y... difunde el conocimiento alla donde sea necesario! }:)


expansiones infinitas
1/2/2007 11:45
Para los que ya le han echado un ojo al problema anterior y han leido los comentarios sobre las expansiones (hey! recuerdo que si no habeis probado sin leer pistas primero es hacer trampa!) os dejo otro pequeño puzzler sobre el tema.

Imaginemos un trocito de codigo como:

double result1 = 3.65d + 0.05d;
float result2 = 3.65f + 0.05f;

Console.WriteLine(result1 == 3.7d);
Console.WriteLine(result2 == 3.7f);
Console.WriteLine(result1 == result2);


¿Sabríais decir cuál será la salida que obtendremos al ejecutar?

numeros bestias y descuentos
31/1/2007 23:54

Que bonita esa cancion de los Maiden... 666, el numero de la bestia. Sin embargo, programanticamente hablando, el 666 es un numero de lo mas normalito (si lo ponemos  como 0x29A, 0o1232 o 0b1010011010 no impone el mismo respeto, verdad?)

Pero en programacion si que hay numeros "especiales" que son a la vez enormemente interesantes para los curiosos y terribles para los descuidados. En este articulo vamos a ver un par de puzzlers que espero que nos hagan pensar un par de veces la proxima vez que tengamos que evaluar estos "casos extremos" y de paso nos ayuden a repasar un poquito mas de aritmetica programante.

El primero, hablando de casos extremos, es para examinar unos conceptos basicos sobre matematica. Si tenemos este trocito de codigo que declara distintos valores y operaciones:

float zero = 0.0f;
float one = 1.0f;
float negativeone = -1.0f;

float division1 = zero / one;
float division2 = zero / negativeone;

float infinity1 = one / zero;
float infinity2 = negativeone / zero;

float division0 = zero / zero;

Console.WriteLine(division1 == division2);
Console.WriteLine(infinity1 == infinity2);

Console.WriteLine(infinity1 == infinity1);
Console.WriteLine(infinity2 == infinity2);
Console.WriteLine(division0 == division0);

¿Sabríais decir cuál será la salida que obtendremos al ejecutar?

Y el segundo es un caso de "depuracion pensando" que tiene que ver con numeros especiales tambien. Supongamos que tenemos una serie de productos a los que queremos aplicar un descuento (porque para eso estamos de rebajas de Enero). Tenemos algunos cuyo precio se ha reducido a la mitad, y otros que rebajamos un 10%. Como no nos gusta andar con la calculadora todo el rato nos hemos hecho un programita que aplica los descuentos por nosotros. El trocito de codigo que hace lo que queremos es algo como:

int[] precios = {20, 30, 20};
float[] descuentos = {0.5f, 0.5f, 0.1f};

for(int i = 0; i < precios.Length && i < descuentos.Length; i++) {
  int precioRebajado = (int) (precios[ i ] * (1 - descuentos[ i ]));
  int porcentaje = (int) (100 * descuentos[ i ]);
  Console.WriteLine("antes: {0} euros... ahora solo {1}!!! (-{2}%)",
  precios[ i ], precioRebajado, porcentaje);
}

Sin embargo, al ejecutar nos hemos dado cuenta que la salida no es justo la que esperabamos. ¿Sabríais decir cuál es el error o errores que hemos cometido? ¿Como podemos hacer que nuestro programa funcione correctamente?

NOTAS/Actualizacion: Un par de apuntes sobre el problema de parte de un par de lectores avanzados (ver comentarios) }:)

  • Tal y como menciona Augusto, estos problemas pueden arreglarse usando la clase System.Decimal (o java.math.BigDecimal o el equivalente en cada plataforma). El tipo Decimal es bastante interesante, asi que dejamos aqui la referencia por si alguien es curioso y quiere adivinar por que sirve para este tipo de problemas (y cuales son sus ventajas e inconvenientes)
  • Curiosea que te curiosea, Tio_Luiso nos indica que en el primer trocito de codigo, C# parece que no representa el resultado de 0/-1 como "menos cero" (de acuerdo al estandar IEEE 754). En cuanto pueda informarme sobre esto pongo una actualizacion! }:)
Muchisimas gracias a los dos por tomaros el tiempo de compartir esta informacion! }:D
contando hacia atras
5/1/2007 10:50

Vaya, este artículo debería haberlo publicado hace unos días, cuando muchos de vosotros sí que os estábais preparando para la cuenta atrás... de final de año, claro. Espero que me perdonéis, pero estoy un poco griposillo así que no me ha dado instancia a dedicar tiempo a escribir.

Aun así: ¡aprovecho para felicitaros a todos desde aquí y desear que los 0x757B12C00 milisegundos de este 2007 os sean propicios! }:)

El caso es que, continuando con el emocionante tema de los tipos de datos, he pensado en dejaros un pequeño puzzler para empezar el año. Os recuerdo que la idea de los puzzlers es responder a las preguntas sobre el código sin ejecutarlo primero (y si sois capaces ademas de saber qué hace, saber el por qué... ¡son gallifantes extra!)

Al igual que en el problema anterior, podéis publicar la solución en vuestro blog y enlazarla desde un comentario aquí o bien enviarlas directamente como comentario del artículo. En cualquier caso, intentaremos comentar la solución entre todos }:)

Pero basta ya de preámbulos: la idea es que tenemos estos tres pedacitos de código:

pedacito #1
int counter = (int)1e8;
while(counter > 0) {
counter--;
}
Console.WriteLine("counter: " + counter);

pedacito #2
float counter = (float)1e8;
while(counter > 0) {
counter--;
}
Console.WriteLine("counter: " + counter);

pedacito #3
double counter = (double)1e8;
while(counter > 0) {
counter--;
}
Console.WriteLine("counter: " + counter);

¿Sabríais decir cuál será la salida de cada uno de ellos? Y ya puestos: ¿sabríais decir cuál tardará MENOS y cual MÁS en ejecutarse?

NOTA: tal y como estan expresados, estos pedacitos deberían ejecutarse sin problemas en C#, Java, C y C++ (simplemente cambiando la última línea por la llamada a System.out.println, printf o cout << apropiada). ¡Siento no haber podido hacer versiones en otros lenguajes!

empezando por el principio
26/12/2006 12:04

Como en programancia101 estamos solo empezando, creo que lo más apropiado es empezar por el principio, pero claro, esto sería si hubiera un principio.

Lo ideal sería poder identificar cuál es la habilidad más importante que debe tener un desarrollador y decir: "¡aha! éste es el truco y éste es el problema que necesitáis para afinar la capacidad X". Pero esto creo que es un problema bastante difícil. ¿Cuál creéis vosotros que debería ser la habilidad número uno del buen programante?

Yo he sido incapaz de decidirme sólo por una, pero sí que he visto una actitud común en muchos programantes avezados: no se conforman con saber que algo funciona, sino que quieren saber por qué funciona, o por qué no funciona, o por qué funciona mejor en tal o cual caso. Saber este tipo de cosas está directamente relacionado con la curiosidad por conocer cómo maneja cada concepto "por dentro" nuestro lenguaje favorito, nuestro entorno, nuestro marco de trabajo...

Una de las típicas preguntas que suelen hacerse cuando se quiere comprobar qué tal maneja alguien los conceptos desde el principio es: ¿sabes darle la vuelta? Sí, exactamente, darle la vuelta a las cosas es un procedimiento poco usual en la "programación estándar", pero nos viene al pelo para empezar a proponer el que se vean las cosas de un modo distinto

Vamos a plantear esta pregunta a distintos niveles:

  • la idea más básica sería: ¿sabrías escribir un trozo de código que reciba una cadena de texto y le dé la vuelta? Es decir, si nuestra entrada es "abc", la salida sería "cba"
  • Bajando un poco más dentro de nuestros tipos de datos: ¿y un trozo de código que le de la vuelta a los bits de un byte? Es decir, si la entrada es 1, la salida sería 128
  • Y para terminar, uno un poco más complejo: en C# (y muchos otros lenguajes) los tipos flotantes se representan mediante el estándar aritmético IEEE 754. ¿Sabrías escribir un trozo de código que le de la vuelta a los bits del exponente y la mantisa de esa representación IEEE 754? Es decir, si la entrada es -118,625, la salida sería -17.180.580.000 (nota: en español la coma "," es decimal y el punto "." el separador cada 3 números de la parte entera)

Podéis poner vuestras respuestas, preguntas o ideas en los comentarios o bien poner un post con la solución en vuestro propio blog y dejar aquí un enlace (¡es mejor que mandármelas por mail, porque así todos podemos opinar!)

Preparados, listos... ¡ya! }:)

¿qué es programancia?
25/12/2006 23:11

Si buscais en un diccionario "programación", os encontraréis con algo como: "acto de crear un programa de computadora, un conjunto concreto de instrucciones que una computadora puede ejecutar" (Wikipedia dixit)

Quiero empezar diciendo que este blog no trata de eso

Quiero decir, no trata de eso únicamente. Seguro que a algunos de vosotros os gusta programar. Quiero decir que os gusta mucho. Vamos, que os apasiona. Para vosotros, es posible que la definición anterior se quede un poco corta. Sí, el mecanismo de programar está contenido en esa definición pero... falta algo....

Programación en vuestra cabeza suena a reto, suena a crear algo fantástico que funciona a partir de la nada, sólo con ideas y líneas de código, suena a la lucha cuando las cosas no funcionan y a la sensación de triunfo cuando por fin das con el problema y todo encaja.

Aunque puede que me equivoque y para ti programar sea solamente eso que te obligan a hacer en tu trabajo, de 9 a 18 (con pausa para comer), y a lo que prefieres no dar muchas vueltas...

En ese caso, puede que este blog no te interese

Por supuesto yo intentaré convencerte de lo contrario. De que sí te interesa porque hay más cosas en la programación que escribir líneas sobre siempre lo mismo

Si me pidieran una definición para qué quiero decir con programancia yo diría que es algo como "el conjunto de técnicas, ideas y mecanismos de pensamiento que hacen del acto de crear programas una actividad creativa, divertida y útil".

Y es que tal y como yo lo veo, desarrollar aplicaciones es uno de los campos más intelectualmente estimulantes en la actualidad. ¿Conocéis muchos más campos en los que haya tantas posibilidades de probar nuevos conceptos, mejorar día a día y disfrutar de la sensación de haber realizado un trabajo que va a ahorrar trabajo a otras personas?

Programancia101 es un experimento que pretende que todos aprendamos un poco más sobre distintas formas de abordar problemas y/o practicar esas técnicas e ideas que a veces tenemos un poco olvidadas, pero que hacen del desarrollo algo mucho más entretenido.

Desde aquí iremos planteando distintos tipos de problemas interesantes, divertidos o simplemente que nos obliguen a revisitar conceptos que puede que nos sean útiles en un futuro (o que al menos nos sirvan para desconectar un poco y ver las cosas de un modo distinto) y comentarlos. Ejemplos de problemas que podrían ser interesantes son:

  • Programación genérica: a partir de una descripción, llegar al código para resolverlos (preferentemente en términos que nos permitan independencia del lenguaje)
  • Problemas de tipo "puzzler" en los que se presenta un trozo de código y se intenta que determinemos qué hace exactamente (sin ejecutarlo, claro)
  • Problemas de depurar pensando ("debugging by thinking") en los que el código mostrado contiene errores y tenemos que localizarlos
  • Otras habilidades relacionadas con la programación, como trucos matemáticos o representación de datos.

Y por supuesto, estamos más que abiertos a recibir otras recomendaciones o sugerencias de actividades. Esto no sería ni la mitad de interesante si no os animáis a colaborar, proponer nuevas ideas y discutir los problemas entre todos. Yo haré lo que pueda por aportar mi granito de arena

Asi que... ¿qué me decís? ¿Os animáis a probar? }:)

por phobeo | 12 comment(s)
Archivado en: