Disclaimer: If after listening to this you feel like staying inside all day, I’m not liable.

New screenshot and link:

Click en “Read More” para ver todo el post.

En primer lugar tengo que mencionar que la respuesta me la dio la computadora, así que si alguno de ustedes lo resolvió solamente usando los jugos cerebrales, tienen el doble de mérito.

El trasfondo

Éste es un clásico problema de combinaciones y permutaciones.

• Una combinación consiste en tomar diferentes elementos y colocarlos en todas las posiciones posibles: Tenemos una de esas acuarelas que usábamos en la primaria, y tiene 10 colores. Si nos ponemos a mezclar 2 colores a la vez, estaremos combinando.
  • Nota: En la combinación, la posición del elemento no importa, si las los colores son (C₁, C₂ C₃…) la combinación C₁C₂ se considera idéntica a C₂C₁
• Permutar, significa que el orden si importa. La forma de la que siempre recuerdo esto, es el café: Cada combinación de ingredientes es diferente, pudiendo empezar por el azúcar, luego el agua, luego la leche y luego el café. Para ser honesto, en términos prácticos no se si el sabor se vea afectado, pero una permutación es eso: cambiar el orden de los elementos. Otro ejemplo: Vamos a la heladería y nos encontramos con 20 sabores, de los cuales podemos elegir tres, y además su posición en el cono, ya sea abajo, en el medio o arriba. La posición si importa, Banana-Limón-Chocolate es diferente de Chocolate-Limón-Banana
• Por ultimo, tenemos un caso especial. Supongamos que en el ejemplo anterior de la heladería, queremos tomar un helado que sea únicamente de chocolate, podríamos pedir un helado Chocolate-Chocolate-Chocolate y como pueden imaginarse, las posibilidades su multiplican.

Las fórmulas

En las fórmulas se usan 2 símbolos:

• E = Número de elementos, ya sean colores, sabores, etc.
• P = Número de “espacios” o “posiciones” disponibles. Por ejemplo, para las acuarelas 2, para los helados 3, etc.

La fórmula para calcular cuantas combinaciones existen, es la siguiente:

E!/((E-P)!*P!)

La fórmula para permutaciones es:

E!/(E-P)!

Y por último la fórmula para el caso de las repetidas:

EP

El método

El método se divide en dos partes:

1. Generamos todas las combinaciones posibles de pesas, desde 1 hasta el total (40 en éste caso)
2. Verificamos la combinación a ver si es válida.

Generar las combinaciones es simple, leer el código debería ser suficiente, sin embargo, el paso de verificar si una combinación de pesas es válida, es mas interesante:

1. Generamos un arreglo [0,0,0,0]
2. Sucesivamente cambiamos los valores de 0 a 1 y de 1 a -1 hasta cubrir todas las posibles permutaciones. Tenemos 3 elementos (0,1,-1) y 4 posiciones, y como se pueden repetir, la fórmula es 3⁴=81. Existen 81 posibles combinaciones entre estos elementos.
3. Multiplicamos la combinación de pesas por el arreglo que creamos en el paso 1 y luego sumamos los elementos individuales. Inicialmente verificamos si la combinación es capaz de pesar 1 Kg, despues 2, etc. Ejemplo: Supongamos que queremos verificar si con las pesas [5, 7, 9, 11] se puede lograr pesar el peso 16:
   1. [0,0,0,0] x [5,7,9,11] = [0,0,0,0] sumamos todos los elementos individualmente y tenemos 0
   2. [1,0,0,0] x [5,7,9,11] = [5,0,0,0] = 5
   3. [-1,0,0,0] x [5,7,9,11] = [-5,0,0,0] = -5
   4. …
   5. [0,1,1,0] x [5,7,9,11] = [0,7,9,0] = 16 ¡Ésta combinación es válida para pesar 16!
4. Repetimos el proceso para cada número desde 1 hasta el total (40 en éste caso)

El código

public class Pesas {
	public static void main(String args[]){
		int[] nums = {1,1,1,1,1};//Valor inicial de las pesas
		int max = 40;//Número máximo que debemos pesar
		boolean solution = false;

		//Fórmula de combinaciones repetidas!
		for(int j=0;j<Math.pow(max, nums.length);j++){
			nums[0]++;
			if(nums[0]>max){
				nums[0]=1;
				nums[1]++;
			}
			if(nums[1]>max){
				nums[1]=1;
				nums[2]++;
			}
			if(nums[2]>max){
				nums[2]=1;
				nums[3]++;
			}
			if(nums[3]>max){
				nums[3]=1;
			}

			//Si las pesas todas sumadas no llegan al máximo, saltamos
			if(nums[0]+nums[1]+nums[2]+nums[3]<max)
				continue;

			solution = true;
			//Verificamos la combinación, para los valores del 1 al max
			for(int i=1;i<max;i++){
				if(!checkAgainst(nums, i)){
					solution = false;
					//Si falló para una solución, rompemos
					break;
				}
			}
			if(solution){
				System.out.println("Solucion encontrada: " +
					"("+nums[0]+","+nums[1]+","+nums[2]+","+nums[3]+")");
			}
		}
	}

	//Elementos diferentes que pueden ir en el arreglo
	public static int[] modificadores = {0,-1,1};

	public static boolean checkAgainst(int[] nums, int num){
		int[] mstate = {0,0,0,0}; //Arreglo de estados
		int[] state = nums.clone(); //Copia local!

		for(int i=0;i<Math.pow(modificadores.length, mstate.length);i++){
			mstate[0]++;
			if(mstate[0]>2){
				mstate[0]=0;
				mstate[1]++;
			}
			if(mstate[1]>2){
				mstate[1]=0;
				mstate[2]++;
			}
			if(mstate[2]>2){
				mstate[2]=0;
				mstate[3]++;
			}
			if(mstate[3]>2){
				mstate[3]=0;
			}

			//Multiplicamos la combinación por el estado
			int num1 = state[0]*modificadores[mstate[0]];
			int num2 = state[1]*modificadores[mstate[1]];
			int num3 = state[2]*modificadores[mstate[2]];
			int num4 = state[3]*modificadores[mstate[3]];

			//Si la suma es correcta, no necesitamos ver el resto
			//de los estados, devolvemos verdadero.
			if((num1+num2+num3+num4)==num){
				return true;
			}
		}
		return false;
	}
}

Otras respuestas

Realmente después de ver los resultados, la forma de encontrar respuestas a estos problemas resultó obvia. Al principio intenté usar el sistema binario para resolver el problema, usando pesas [1,2,4,8], y no funcionaba. Sin embargo, la solución utiliza un método muy similar. El hecho de poder restar números y no solamente sumarlos, nos da más flexibilidad. En realidad podemos calcular todos los números siguiendo la regla: partiendo de una pesa inicial P₀, la siguiente pesa P₁ (P₀*2)+1 y la siguiente es

(∑(Pn)*2)+1

(necesito ver como insertar formulas en WordPress para no torturarlos con esta notación tan horrible).

Si comenzamos con una pesa 1, la siguiente es (1*2)+1 = 3, la siguiente es ((1+3)*2)+1 = 9 y la y última es siguiente ((1+3+9)*2)+1 = 27

Nota: Existe una excepción, que nos permite comenzar con una pesa 2, pero no se que ventaja podría tener. Las restas se vuelven más complicadas si tuviéramos que realizar este experimento en la vida real.

Espero que lo hayan disfrutado, y publiquen sus respuestas !!

Mi padre decidió seguir intentando resolver este problema hasta que tuviera éxito, o muriera de agotamiento, y su perseverancia me arrastró a intentarlo yo mismo. He aquí el problema:

El probema es simple:

• Tenemos una balanza de dos platos
• Hay que pesar cosas que fuctuan entre 1 Kg y 40 Kg.
• Los pesos siempre son enteros.
• Hay que encontrar 4 pesas que nos permitan lograr esta tarea.

Primera pista: se pueden poner pesas en ambos lados de la balanza (el lado que tiene el objeto a pesar, y el lado que solo contiene pesas)

Para no dejar a la audiencia con la duda, o resolvimos, o más bien, utilicé el “poder bruto” de mi laptop para calcular los 2,560,000 posibles combinaciones de pesas para encontrar al respuesta.

Mañana revelaré la respuesta y el código con el que la encontré, mientras tanto, intenten resolverlo

It all starts last Sunday (the 29th) at 6:30 in the morning. My cellphone wakes me up and I’m a man on a mission:

Yours truly in deep concentration

All we knew about the competition was that it would be a strictly programming competition, so no “advantages” depending on the language of choice, and that we could bring 30 pages with documentation.

• The first part was very relieving: since we are all hardcore Java developers, its hard to compete against c/c++ code on time and memory management (even tho sometimes Java wins…)
• 30 pages of documentation was more of a question than a rule. What do you mean by “documentation“? We had no clue of what it meant, but we assumed that it had to be related to simple operations that yet are not so common, for instance, painting to the screen, visualizations, etc etc. So I grabbed some of sample code to read files from a buffer and stuff  like that, and printed them.

Our surprise was great when we get to the event at 8:40am and find lots of people reading stuff… reading the Java API!!!!!!!!!! LOL LOL Someone was able to see what class they were reading about, it happened to be the String class… Obviously that didn’t make any sense, UNLESS, code completion was disabled in the computer that we were using… A friendly staff member was around and we proceeded to ask him about code completion:

It was pretty clear that the guy either didn’t know what he was talking about, OR he didn’t understand my first question and that we were headed for a programming slaughter without autocompletion in Eclipse.

We step in the computer lab: every table has a computer, pencils, en envelope and a sign. It was pretty straight forward to find our group: the Pink Unicorns (Later I was reminded by a friend that a Pink Unicorn is a metaphor that atheists use lot, completely coincidental).

The competition starts, we realize that Eclipse has ALL the standard features, so the guy we talked to early was confused.

…

Four hours later, with 4/6 programs done, two of them working 100%, the other two completed but not working, the competition ended. We grabbed 8th place, but we could have been 2nd or 3rd. Let me explain our mistakes:

We (three of us) worked in ONE problem at the time, we did this for over 45 minutes, compete waste of time.

Solution: Every team member has to work in their own problem. Don’t ask for help before you have read your problem

Don’t open the envelope and read one problem at the time and try to solve it.

Solution: Read 2 problems, determine which one is the easiest, and solve that one first

Finally, have a good night of sleep and a good breakfast before the competition.

We think we have potential, and in 25 days when the next (and this time important) competition will take place, we will do better than 8th.

Some of the participants. The teams that did very bad had already left. Guys in yellow are organizers/staff. I'm around the center of the picture, with a brown shirt. To my left and right are Gio Ascencio and Javier Soto.

As a little background, I never thought this was actually possibly done by a normal human with a 10cm tongue (thats the real size, wikipedia doesn’t let me lie), but yet against all my predictions, I was able to pull it off. Proof below:

Get ready for tomorrow: finally a more technical post. I will be talking about my experience in the preliminary ACM ICPC Monterrey competition this morning. Sneak preview? even with out inexperience in this kind of competition we got 8th out of 30 teams… more tomorrow.

Good night peoplessss

If you ask me, three hours is right in the edge between too little and too much time spend in something like this, and the breakdown is:1:45 hours developing it and the rest of the time trying to get the info and finish some other work, which makes me feel better about myself, since all of the unfinished details can be blamed upon the lack of time oh yeah, my excuses rock!

Sometime in the future I will clean up the code and let anybody use the it (hopefully somebody will find it useful)

Obligatory screenshot and link:

Good night!

UPDATE: New version of the timeline here.

That wraps up the “starting somewhere” post.

PD: Before I forget, please click ‘n drag the logo