¿Por qué? Porque sí.
Una vez resuelto el misterio del por qué, pasemos a los objetivos.

Objetivos

Venga va, una introducción con los motivos: Hace tiempo compré de segunda mano un servidor IBM x3650 7979 para utilizarlo de servidor en casa. Lo que nadie me contó es que el bicho soltaba 70dB en reposo (una burrada), algo así como si encendiese una aspiradora y te animase a conciliar el sueño con semejante escándalo incesante. Traté de regalarlo pero parece ser que un servidor IBM no lo quiere nadie. Y eso que el aparato era una bestia parda, ruido incluido. A saber: dos procesadores Xeon E5450 con cuatro núcleos cada uno y 3Ghz por núcleo, 8GB de ram fully buffered, controladora raid IBM canela canela con batería incluida, dos discos SAS de 72GB a 15.000 rpm, refrigeración redudante, fuente de alimentación redundante, sistema de administración remoto independiente del SO (IBM RSA II) y un largo etcétera con la mierda fresca habitual de IBM.

El problema es que uno tiene muy arraigada la manía de dormir por las noches y por muy al fondo que se colocase, no había manera. Traté de alojarlo en un armario pero los espacios cerrados no le sentaban demasiado bien y se sobrecalentaba. Resignado por no poder alojar el servidor en un lugar donde los dos estuviésemos conformes, decidí aprovechar el mayor número de partes del servidor y montar otro nuevo desde cero algo más silencioso. Eso si, conservando un mínimo de calidad. Objetivos:

• Utilizar partes del servidor IBM para construir el nuevo servidor
• Mantener un mínimo de calidad y características
• Reducir el ruido emitido por el servidor

Los componentes utilizados

Partamos de una base, los componentes aprovechados del IBM:

• Los dos procesadores Xeon E5450 con socket LGA771 (esto es importante)
• La RAM FB-DIMM, 8GB
• Los dos discos duros SAS 72GB 15.000rpm
• Tarjeta ethernet con dos puertos RJ45
• Parte de la caja, concretamente donde se alojan los discos duros.

Los componentes que necesito para completar el servidor:

• Placa base
• Ventiladores
• Fuente de alimentación
• Controladora RAID
• Caja

Bien, comentemos un poco cada uno de los componentes que necesito para completar el servidor.

La placa base

Lo primero que comencé a buscar fue la placa base del cacharro. Para esta tenía varias limitaciones a la par que requisitos propios. Para empezar los procesadores son socket LGA 771 y creedme cuando os digo que encontrar una placa base con dual socket LGA 771 es… Jodido. Mi primera y única opción fue ebay (oh, amigo ebay). Una vez asumido que la placa debía de ser de segunda mano, comencé a buscar una placa base con estas características mínimas: Dual socket LGA 771, ranuras de sobra para RAM FB-DIMM (es una ram «diferente») y puertos PCIe x8 como mínimo. ¿Resultado tras días y días de búsqueda? Una Supermicro X7DBE que además de todo eso venía con puertos SATA a porrillo con soporte RAID integrado (que por el momento no voy a usar), dos puertos RJ45 GLAN, puerto para módulo IPMI, puertos PCI-X y alguna que otra chorradita más, típica de placas de servidor. Esta placa se la compré a ehrer_hardwareshop -tienda completamente recomendada- por el módico precio de 183€.

Los ventiladores

Los ventiladores son una parte fundamental para los objetivos del proyecto por lo que era necesaria una buena refrigeración con una baja emisión de ruido. Escogí unos Dynatron H6EG que pedí a una tienda que no enlazaré ya que los mandaron sin protección ninguna y llegaron con varios golpes. Las características interesantes de los ventiladores:

• Al 20% de capacidad: 8.75CFM 16.85dBA 1600rpm
• Al 50% de capacidad: 21.88CFM 35.94dBA 4000rpm
• Al 100% de capacidad: 43.75CFM 51.0dBA 8000rpm

Con estos ventiladores espero mantener una buena refrigeración usando entre el 20% y el 50% de capacidad. En caso de subida anormal de temperatura se usaría el 100% de capacidad con sus inherentes 50dBA (esto ya molesta), pero la idea principal es que no sea necesario.

Además hay que sumar un ventilador de caja o «system fan» que coloqué enfocado a la RAM ya que se sobrecalentaba de forma alarmante. Para esto escogí un Tracens Aura II de 12cm comprado a pc componentes

Cada ventilador de CPU costó unos 28€.

Fuente de alimentación

Para la fuente de alimentación el requisito era una potencia mínima de 700W. Cualquiera vale. No obstante cometí un pequeño error de cálculo, la fuente que compré no tenía conector de 8 pines tal y como requería la placa base así que hubo que hacer una pequeña adaptación. En las fotos del final se puede ver.

Controladora RAID

Las controladoras RAID SAS son jodidamente caras, fue el componente que más tardé en encontrar. Finalmente conseguí una controladora Intel SRCSAS18E. Esta controladora ya no se fabrica, pero la encontré en una tienda de USA llamada OEM XS INC. Esta tienda vende productos originales, recomendable 100%. Eso si, si tenéis oportunidad pedid que NO lo manden por FedEx ya que en FedEx tienen la manía de rastrear tus datos por internet para mandarte papeleo de aduana. Si no respondes te lo pasan por aduana sin consultarte para después cobrarte sin tener oportunidad de gestionarlo tú mismo. JAMÁS uséis FedEx.

El coste de la controladora fue de $100+impuestos. Más barato imposible.

La caja

Para la caja reutilicé una vieja caja ATX que tenía dando vueltas. Esto significa que tuve que adaptar para conseguir que la placa base E-ATX y los discos duros SAS entrasen todos juntitos. En las fotos de la ejecución se puede ver.

La ejecución

A continuación os dejo una galería de fotos con comentarios sobre la ejecución de la construcción:

Y eso es todo. ¡A pasarlo bien!

La esteganografía (del griego στεγανος (steganos):cubierto u oculto, y γραφος (graphos): escritura), es la parte de la criptología en la que se estudian y aplican técnicas que permiten el ocultamiento de mensajes u objetos, dentro de otros, llamados portadores, de modo que no se perciba su existencia. (http://es.wikipedia.org/wiki/Esteganograf%C3%ADa)

Fácil, ¿no?

Bien, para mi pequeño programa he utilizado la esteganografía en imagenes, es decir, ocultar «cosas» en una imagen sin que se perciba. Antes de explicar cómo lo he hecho y mostrar los resultados, os dejo el código del programa que podéis encontrar en https://github.com/NachE/stegapy (donde además lo iré actualizando). Lo he llamado Stegapy:

Nota: He borrado los comentarios del código, haz click aquí para ver la versión con comentarios (en inglés)

#!/usr/bin/env python
# Stegapy
# Copyright 2013 J.A. Nache
# See LICENSE for details.

#python-PIL
import Image, sys, os

class UnestegFile:

	def __init__(self, pathOrigImage, pathDestFile):

		self.pathOrigImage = pathOrigImage
		self.pathDestFile = pathDestFile

		self.file = open(self.pathDestFile, 'wb')
		self.imageObj = Image.open(self.pathOrigImage)
		self.imgPix = self.imageObj.load()

	def readImgInBit(self):
		for x in range(0, self.imageObj.size[0]):
			for y in range(0, self.imageObj.size[1]):
				RGB = self.imgPix[x,y]
				for color in RGB:
					yield bin(color)[-1:]

	def unHide(self):
		bitcount = 0
		bytecount = 0
		byte = str()
		size = str()
		maxeof = 4294967295 # The largest file size in bytes we can hide
		bytes = self.readImgInBit()

		print("\nUnhidding file, wait...\n")
		for bit in bytes:
			byte += bit
			bitcount = bitcount + 1

			if bitcount == 8:
				bytecount = bytecount + 1

				size +=byte
				if bytecount == 4:
					print('-> Size of hidden file: '+
							str(int( size ,2))+' bytes')
					print('\tAn extra 4 bytes (32bits) at header are skipped')
					print('\tThese extra 4 bytes are used to save the original file size')
					print('\tso its not part of file.')
					maxeof = int(size ,2)+4

				if bytecount > 4:
					self.file.write( chr( int( byte ,2)) )

				byte = str()
				bitcount = 0

				if bytecount == maxeof:
					break
		print ('\nDone')
		print ('==================================')
		print (str(bytecount - 4)+' bytes writed on file '+self.pathDestFile)

	def closeFile(self):
		self.file.close()

class EstegFile:

	def __init__(self, pathOrigFile, pathOrigImage, pathDestImage):

		self.pathOrigFile = pathOrigFile
		self.pathOrigImage = pathOrigImage
		self.pathDestImage = pathDestImage

		self.imageObj = Image.open(self.pathOrigImage)
		self.imgPix = self.imageObj.load()

		self.file = open(self.pathOrigFile, 'rb')

		self.imageObjNew = Image.new("RGB", self.imageObj.size, "white")
		self.imgPixNew = self.imageObjNew.load()

	def saveDest(self):
		self.imageObjNew.save(self.pathDestImage,"PNG")

	def readFileInBit(self):
		fsize = os.fstat(self.file.fileno()).st_size
		for bit in bin(fsize)[2:].zfill(32):
			yield bit

		while True:
			character = self.file.read(1)
			if not character:
				break
			else:
				byte = bin( ord( character ) )[2:].zfill(8)
				for bit in byte:
					yield bit

	def buildNew(self):
		inbytes = self.readFileInBit()
		bitscount = 0;

		print("\nHidding file, wait...")
		for x in range(0, self.imageObj.size[0]):
			for y in range(0, self.imageObj.size[1]):

				RGB = self.imgPix[x,y]
				RGBnew = ()

				for color in RGB:
					try:
						RGBnew = RGBnew + ( int( bin(color)[:-1]+inbytes.next() ,2), )
						bitscount = bitscount + 1

					except StopIteration:
						RGBnew = RGBnew + (color, )

				self.imgPixNew[x,y] = RGBnew

		print ('\nDone')
		print ('==================================')
		print ('Orig File: '+self.pathOrigFile)
		print ('Hided with image: '+self.pathOrigImage)
		print ('Result File: '+self.pathDestImage)
		print ('==================================')
		print ('Hidded '+str(bitscount)+' bits | '
				+str(bitscount*0.125)+' bytes | '
				+str(bitscount*0.000122070312)+' kilobytes')
		print ('Extra 32 bits are used (represent the file size)')

def show_about():
	print('\n   Stegapy v0.1')
	print('   Copyright 2013 J.A. Nache under GPL v3\n')

def show_help():
	show_about()
	print ('\n   Usage')
	print ('   =========')
	print ('   Hide file:')
	print ('   '+sys.argv[0]+' h <File To Hide> <Source Image> <New Image File>')
	print ('\n   Unhide file:')
	print ('   '+sys.argv[0]+' u <Image with hidden data> <Dest File>\n')

try:
	if sys.argv[1] == 'h':
		show_about()
		sg = EstegFile(sys.argv[2], sys.argv[3], sys.argv[4])
		sg.buildNew()
		sg.saveDest()

	elif sys.argv[1] == 'u':
		show_about()
		sg = UnestegFile(sys.argv[2], sys.argv[3])
		sg.unHide()
		sg.closeFile()
	else:
		show_help()

except IndexError:
	show_help()

El código de Stegapy aquí arriba es capaz de ocultar cualquier archivo en una imagen (por el momento imagen PNG), además del acto contrario: extraer el archivo oculto. Esto nos lleva al siguiente punto:

¿Cómo funciona la esteganografía en imágenes? (En Stegapy, más bien)

Para ser más precisos, esta es la forma en la que Stegapy hace uso de la «inserción en el bit menos significativo«. Lo primero que debemos saber es que cada pixel de una imágen se puede descomponer en tres valores: Rojo, Verde y Azul, o más comúnmente RGB por sus siglas en inglés, Red Green Blue (sí, en la viña del señor hay de todo, pero me he centrado en el RGB). El rango de valores de cada color va desde el 0 hasta el 255 o dicho en binario, desde el 00000000 hasta el 11111111. De este modo, un pixel completamente blanco de una imagen tendrá un valor RGB de R=11111111 G=11111111 B=11111111. Un pixel completamente negro tendrá un valor RGB de R=00000000 G=00000000 B=00000000, y, como es lógico, un pixel completamente rojo tendrá un valor RGB de R=11111111 G=00000000 B=00000000.

La idea principal de la inserción en el bit menos significativo es utilizar el mencionado bit menos significativo de cada color (el situado más a la derecha) y sustituirlo por los diferentes valores bit a bit del archivo a ocultar. Digamos por ejemplo que queremos ocultar la letra A mayúscula, que tiene un valor binario de 01000001 dentro de una imagen. Para ello necesitaríamos ocho colores (son ocho bits). Dado que cada pixel contiene tres colores (R, G y B), vamos a necesitar casi tres pixels. Digamos que los tres primeros pixels de nuestra imagen tienen unos valores tal que:

Pixel 1: R=01010011 G=00011001 B=11011010
Pixel 2: R=01010101 G=10101010 B=11111100
Pixel 3: R=11111111 G=00000000 B=11111111

Ahora queremos ocultar nuestra letra A mayúscula con valor binario 010000001 en estos pixels, por lo que usando nuestro bit menos significativo, quedaría tal que:

Pixel 1: R=01010010 G=00011001 B=11011010
Pixel 2: R=01010100 G=10101010 B=11111100
Pixel 3: R=11111110 G=00000001 B=11111111

El resultado final serán tres pixeles ligeramente modificados, pero lo suficientemente inapreciable como para que el conjunto no sufra un cambio brusco.

Una vez que sabemos cómo funciona Stegapy, llega el momento de hacer pruebas y comprobar los resultados, lo que nos lleva al siguiente punto:

Obteniendo los resultados de la inserción en el bit menos significativo (Esteganografía)

Para las siguientes pruebas voy a utilizar el texto de la licencia GPLv3 de Stegapy que se puede encontrar en: https://github.com/NachE/stegapy/blob/master/LICENSE. Decir tiene que Stegapy recorre los pixels de la imagen de arriba a abajo, por lo que la información oculta irá formando columnas de izquierda a derecha.

Para las pruebas voy a utilizar una imagen cualquiera, digamos…, esta:

Ahora, vamos a insertar el texto propuesto, el texto que queremos ocultar, dentro de esta imagen y comparar el resultado:

¿Alguna diferencia? A simple vista parece que la imagen no ha sufrido ningún cambio, ¿pero qué tal si echamos un vistazo con un editor gráfico a la imagen generada? Vamos allá:

Según los datos obtenidos y las pruebas realizadas, parece que a simple vista no se aprecia cambio alguno, no obstante modificando los niveles en los colores se intuye una columna de datos que el ojo más hábil será capaz de ver. Para tratar de forzar el florecimiento de esta columna, vamos a hacer un último experimento, coloquemos unas franjas horizontales de color blanco (con pixeles de valor 11111111) en la imagen original y volvamos a esconder nuestro texto en esta nueva imagen para después tratarla con nuestro editor gráfico:

En esta ocasión, tras someter la imagen con datos ocultos a nuestro editor gráfico, observamos como aparece una columna de datos en las franjas blancas, lo que nos indica que cuanto más ruido tiene nuestra imagen, menos perceptible es al ojo humano.

Y este es el fin de la primera parte. Para las siguientes partes de la saga investigaré técnicas de detección de datos ocultos mediante esteganografía y experimentaré con nuevas formas de ocultación para dificultar en mayor medida la detección de nuestros datos.

Hala, hasta la próxima.

Saludos

A lo que vamos: Me he hecho con la versión extendida en BluRay de la trilogía de «El Señor de los Anillos». Además me he dado una vuelta por youtube para ver algunos «cómo se hizo» de ésta obra. Nada del otro mundo. Esta es una obra que, aunque no es de los géneros que más me gustan, está bien hecha y es digna de explorar hasta el más mínimo detalle.

Y es justo esta exploración la que me ha llevado a terminar de una vez por todas algo que me daba pavor desde el primer día que vi la primera película:

Las proporciones de los personajes de «El Señor De Los Anillos».

Y estoy seguro que a Peter Jackson también le aterraban las proporciones de los personajes principales. No quiero ni imaginar lo difícil que fue unir correctamente todas las proporciones. Tan difícil que creo que no hicieron un buen trabajo. La primera vez que vi la película tuve la sensación de que algo no encajaba. Con el tiempo esa sensación se volvió sospecha y finalmente, en convicción. La estatura de nuestros amigos hobbits y el enano Gimli cambian de plano en plano. Si observamos con atención la películas podremos observar que los hobbits y el enano parecen pequeños. Pero sólo eso, lo parecen.

Pongamos dos situaciones: Una, cuando los personajes aparecen solos en la escena. Y otra, cuando aparecen juntos. Cuando nuestros amigos aparecen solos en una escena, la técnica se basa en aparentar. Únicamente dan impresión de tener una estatura reducida. En cambio, cuando estos personajes comparten plano es el momento de usar el retoque digital para reducir su tamaño (o usar dobles, como más abajo os enseñaré WFT!). Esto no queda mal del todo, pero en nuestro subconsciente se genera una extraña sensación de que algo falla. De resaca puede resultar incluso irritante.

Un día me entró la curiosidad y decidí buscar la estatura real de cada uno de los actores del film. imdb, gran fuente de saber para cualquier cinéfilo. Os cuento:

– Gimli (John Rhys-Davies): 1.85 m
– Frodo (Elijah Wood): 1.68 m
– Sam (Sean Astin): 1.68 m
– Merry (Dominic Monaghan): 1.70 m
– Pippin (Billy Boyd): 1.69 m
– Legolas (Orlando Bloom): 1.79 m
– Aragorn (Viggo Mortensen): 1.80 m

Resulta curioso, cuanto menos, que Gimli sea el más alto de todos. Quizás por esto se empeñaron en hacerlo más enano de lo que realmente debería ser.

Vamos a empezar por el principio ¿Cual es la estatura correcta de cada uno de los personajes? Pues sólo tenemos que irnos a la primera película. Nueve compañeros que forman la comunidad del anillo:

Pongamos las cosas sobre la mesa. El enano es más alto que los hobbits. Esta y sólo esta debería ser la proporción de altura entre los diferentes personajes. Se trata de una toma digitalizada, probablemente colocando los actores «enpequeñecidos» sobre sus dobles (jeje, ya veréis). Ahora bien, durante la trilogía no siempre se reduce el tamaño de los personajes, basta con crear la impresión de que son de baja estatura, en general queda bien pero a veces pica cuando son más altos de lo que deberían ser, o más bajos de la cuenta.

Tomemos ahora una de las últimas escenas de la última película. Frodo se despierta en una cama y sus colegas acuden a ver tal hecho (¡viva, viva, Frodo está vivo!). Vemos entrar a Gimli, Pippin, Merry, Legolas, Aragorn y Sam. En ese orden. Pongamos atención a la entrada de los cuatro primeros:

¿Veis algo raro? ¿No? Os daré una pista, fijaos en la puerta, en ese bonito dibujo con círculos. ¿Qué ha pasado? ¿El enano está de rodillas o los hobbits se han subido a un taburete? Os lo pondré más fácil aun. superpongamos las tres imágenes tomando como referencia el dibujo de la puerta, quedaría algo así:

¿Lo veis más claro? Resulta que los hobbits no son tan bajos, casi parece que le falten pocos centímetros para ser tan altos como Legolas. Además, Gimli es más bajo que los hobbits ¿Pero esto que es, qué invento es este? Hagamos algo: Sabiendo que Frodo tiene la misma altura que sus compañeros hobbits, y tomando como referencia el dibujo de la puerta, plasmemos su tamaño en un dibujo comparativo:

Repito: Gimli el enano, según la primera película (escena capturada arriba), es más alto que los hobbits. Pero se lo han pasado por el forro. Este fallo de proporción se repite una y otra vez durante las tres películas creando la impresión de que los hobbits son más altos de lo que deberían ser. La falta de cuidado en este aspecto provoca que algunas bromas, como la pinta que se toma Merry en la posada de Prancing Pony, se vea algo desvirtuada. No se crea la correcta impresión del «enanismo» de los hobbits. No puede ser que un hobbit sobrepase el lomo de un caballo. Fijaos si no cuando los hobbits y Aragorn en la primera película se dirigen a Rivendell.

Bien, y ahora:
El colofón de esta crítica:

Como curiosidad, debéis saber que durante el rodaje de las películas se utilizaron dobles enanos con máscaras para escenas con planos abiertos. No todo iba a digitalizarse (de hecho digitalizaron poco según he descrito en la entrada). Esto da pie a curiosidades como esta:

WTF! ¿Qué ha pasado con Frodo y Sam? Estarían de vacaciones me imagino…

Un saludo, sed buenos y a pasarlo bien x)

Y heme aquí, viendo a Uma Thurman desmembrar Yakuzas cuando sin esperarlo, así, de repente, me he topado con este señor tan apañado.

Cierto es que no hace falta ir frame a frame para toparse con este profesional actor de doblaje. Basta con notar como el culo y las curvas de Uma se desvirtúan en las de alguien más varonil con un centro de gravedad más apto para ejecutar esas cabriolas.

Defectos como éste se dejan ver durante todo el film (que cool queda decir film). No voy a criticar los chorros de sangre a presión, ya se que una katana realiza cortes lo suficientemente limpios como para dejar arterias abiertas a tutti pleni. En cualquier caso, debería criticar esos cortes casi imposibles en los que una persona es convertida en dos por su simetría. O quizás esos saltos y vuelos que lejos de indignar, recuerdan a aquellas películas japonesas de familia, respeto, honor y sablazos en las tripas (o más bien «katanazos»).

Y es que a decir verdad, los defectos de ésta película son en realidad Odas a toda una cultura de comics, películas de serie b y películas japonesas que, como ya digo, lejos de hacernos soltar el recurrido «venga ya…», nos esbozan una cómplice sonrisa a todos aquellos que hemos tenido la oportunidad de indagar por este tipo de producciones un tanto «underground».

En cuanto a la V.O. he de decir que ha sido una grata sorpresa ver (mas bien oír) esa gran banda sonora, esas interpretaciones increíbles y esos efectos sonoros tan envolventes que no lo son tanto en su versión traducida.

Como conclusión, una buena película de autor para disfrutar si sabes reconocer los guiños habituales de Tarantino, y te gusta ver sangre a borbotones. Mejor en V.O.

Hace tiempo que venía pensando qué hacer con un viejo portátil que funcionaba a veces si, a veces no. Era un portátil relativamente antiguo, hacía poco ruido y lo quería transformar en un router pero…, el resultado no fue fructífero. La placa base estaba hecha un asco y cuando arreglaba una cosa, se rompía otra. La cuestión es que viendo que la placa base estaba para el arrastre, decidí aprovechar el resto de piezas y, la primera de ellas, fue la pantalla. Así que:

.

.

Cómo convertir una pantalla de portátil en monitor de PC. Fácil, sencillo y para toda la familia.

El primer paso a realizar es identificar el modelo de nuestra pantalla, en mi caso era la LP150X08 de LG PHILIPS, un LCD usado por muchos fabricantes de la época. Una vez detectado el modelo de nuestra pantalla, es hora de buscar el datasheet para comprobar la forma en la que recibe la imágen. Nada más fácil que buscar «LP150X08 datasheet» en google. El mio lo encontré en este enlace. Pude comprobar entonces que mi pantalla tiene un receptor LVDS. Busqué esquemas de circuitos conversores de LVDS a VGA o de LVDS a DVI y a excepción de un extraño circuito en un foro francés, no encontré nada medianamente convincente.

Mi decisión final: comprar una controladora de LCD. La encontré en ebay, justo aquí, en la sección «LCD controller board kits DIY«. Concretamente este. Es una controladora sencilla. Conector VGA y botonera para brillo, contraste, encendido, etc. El menú viene con diferentes idiomas, entre ellos el español. El adaptador de corriente se vende por separado (así que atención a eso).

Antes de realizar el pedido, no está de más comprobar si la controladora soporta nuestra pantalla. En la misma página del producto podemos encontrar toda la información necesaria.  Si finalmente decidís comprar una controladora en el mismo sitio que yo, tendréis que comunicarle al vendedor el modelo de nuestra pantalla para que nos envíe el inversor y conector adecuado. Otra opción sería comunicarles directamente el número de lámparas y el tipo de conector que necesitamos. Yo opté por comunicarles el modelo además del número de lámparas y conector, que en mi caso es una lámpara y un conector LVDS de 30 pines.

Aviso para despistados: Si vais a comprar el adaptador de corriente, aseguraos de comprar el adecuado, yo casi compro el de enchufe UK. Menos mal que el vendedor me avisó…

En fin, tras una prudencial espera, llegó mi controladora. Así que me puse manos a la obra:

Transformación ilustrada de una pantalla de portátil a pantalla de PC.

Llegados a este punto, se me plantea un problema. Todo funciona correctamente, la pantalla funciona, maneja bien la señal. Tiene incluso un ajuste automático que funciona realmente bien. El menú OSD va de lujo. Si, todo bien, pero… ¿Cómo carajo la pongo en pie? Pues eso, amigos míos, queda a cargo de vuestra imaginación. Yo opté por entrar en un bazar chino cerca de mi casa y dejar volar la imaginación. Esto fue lo que sucedió:

Alzando una pantalla de portátil para transformarla en una pantalla de PC. (Bricolaje informático)

Y esto es todo. Para el próximo proyecto tengo pensado comprar una controladora de LCD con TDT y mando para transformar la pantalla de un portátil que se muere en una televisión. Eso, o transformar un trackpad en un ratón de PC por puerto USB o PS/2, según me de.

Ale, a pasarlo bien.

Supón que estás en un concurso, y se te ofrece escoger entre tres puertas: detrás de una de ellas hay un coche, y detrás de las otras, cabras. Escoges una puerta, digamos la nº1, y el presentador, que sabe lo que hay detrás de las puertas, abre otra, digamos la nº3, que contiene una cabra. Entonces te pregunta: «¿No prefieres escoger la nº2?». ¿Es mejor para ti cambiar tu elección?

La solución: Dado que en un principio nuestras posibilidades de fallar eran mayores, probablemente fallasemos. Al reducir el problema descartando una de las puertas erróneas, obtenemos la puerta elegida inicialmente (la que probablemente sea la errónea) y la contraria (la que probablemente sea la correcta). Es decir, si tenemos una alta probabilidad de fallar, fallaremos. Por lo tanto, la solución a este problema es que es prudente cambiar de puerta ya que tendremos más probabilidades de acertar.

En esta escena de no se que película se explica el problema: http://www.youtube.com/watch?v=_mbO-ndr740

Aqui la entrada en la wikipedia del problema de Monty Hall: http://es.wikipedia.org/wiki/Problema_de_Monty_Hall

Y para los que se aburran: http://es.wikipedia.org/wiki/Teorema_de_Bayes

Y ahora, el código PHP que lo demuestra:

<?php

/*****Sin cambiar de puerta******/
$puertas=array(1=>'cabra', 2=>'coche', 3=>'cabra');
$aciertos=0;

for($i=0;$i!=10;$i++){
     $puerta_elegida=rand(1,3);
     // ya que en ningun momento vamos a cambiar de puerta, si acertamos a la primera,
     // apuntamos acierto. Si no acertamos, no se hace nada.
    if($puertas[$puerta_elegida] == "coche"){ $aciertos++; }
}
echo "Aciertos sin cambiar de puerta: $aciertos/10 <br />\n";

/******Cambiando de puerta*****/
$aciertos=0;

for($i=0;$i!=10;$i++){
     $puerta_elegida=rand(1,3);

     foreach($puertas as $key => $valor){ //recorremos el array
         //determinamos la puerta a eliminar
         if($key != $puerta_elegida && $valor == "cabra"){ $puerta_eliminada=$key; }
     }

     //detectamos la puerta contraria a la elegida de las dos que nos quedan
     foreach($puertas as $key => $valor){
         if($key != $puerta_elegida && $key != $puerta_eliminada){
        //si la puerta a la que cambiamos es un coche, apuntamos acierto
             if($puertas[$key] == "coche"){ $aciertos++; }
         }
     }
}
echo "Aciertos cambiando de puerta: $aciertos/10 <br />\n";

?>

Este script realiza 10 veces el problema en cada caso, tanto sin cambiar de puerta (la primera porción) como cambiando de puerta (la segunda porción). Ejecutando el script diez veces, obtengo estos resultados:

Aciertos sin cambiar de puerta: 2/10
Aciertos cambiando de puerta: 6/10

Aciertos sin cambiar de puerta: 3/10
Aciertos cambiando de puerta: 10/10

Aciertos sin cambiar de puerta: 7/10
Aciertos cambiando de puerta: 7/10

Aciertos sin cambiar de puerta: 5/10
Aciertos cambiando de puerta: 6/10

Aciertos sin cambiar de puerta: 3/10
Aciertos cambiando de puerta: 9/10

Aciertos sin cambiar de puerta: 2/10
Aciertos cambiando de puerta: 7/10

Aciertos sin cambiar de puerta: 3/10
Aciertos cambiando de puerta: 7/10

Aciertos sin cambiar de puerta: 3/10
Aciertos cambiando de puerta: 9/10

Aciertos sin cambiar de puerta: 2/10
Aciertos cambiando de puerta: 10/10

Aciertos sin cambiar de puerta: 3/10
Aciertos cambiando de puerta: 5/10

Queda demostrado pues, que cambiar de puerta es la elección correcta.

Actualización [20/05/2010]:  Me comenta Jony que la escena de la película (el enlace a youtube) es en realidad una escena de la serie Numb3rs (http://www.imdb.com/title/tt0433309/). Gracias por la corrección x).

http://www.youtube.com/watch?v=TzSPx95K604

http://www.youtube.com/watch?v=FzL8u9iZYQw

Podéis comentar, se agradece. Así no tendré la sensación de estar sólo :(.