Lo interesante fue que me quedaron varias secuencias de números y decidí ir a OEIS para testearlo. Me encontré entonces con una serie de resultados interesantes que decidí publicar acá para revisarlos mas adelante.

Resultados simples

• Si m=n=k , la función devuelve una permutación. m!
• si m=n, m<k => f(n, m, k) = k!/(k-m)!

Resultados interesantes

• n libre, m=3, k=4

  Devuelve permutación(4) * Stirling numbers of second kind, S(n,3) ( http://oeis.org/A000392 )

• n libre, m=4, k=4

  Devuelve permutación(4) * Stirling numbers of second kind, S(n,4) ( http://oeis.org/A000453 )

• n libre, m=3, k=5

  Devuelve 5*4*3 * Stirling numbers of second kind, S(n,3) ( http://oeis.org/A000392 )

• n libre, m=4, k=5

  Devuelve 5*4*3*2 * Stirling numbers of second kind, S(n,4) ( http://oeis.org/A000453 )

• n libre, m=5, k=5

  Devuelve 5*4*3*2 * Stirling numbers of the second kind, S(n,5) (http://oeis.org/A000481 )

• n libre, m=3, k=6

  Devuelve 5*4*3*2 * Stirling numbers of second kind, S(n,3) ( http://oeis.org/A000392 )

• n libre, m=4, k=6

  Devuelve 6*5*4*3 * Stirling numbers of second kind, S(n,4) ( http://oeis.org/A000453 )

• n libre, m=5, k=6

  Devuelve 720 * Stirling numbers of the second kind, S(n,5) ( http://oeis.org/A000481 )

Parece existir algún tipo de patrón, lamentablemente no tengo el tiempo en este momento y sobre todas las cosas el nivel de matemática suficiente como para investigarlo un poco más. Escribo este post más que nada para revisarlo nuevamente después de haber pasado por Concrete Mathematics, que todavía no pude estudiar.

Algún otro resultado

• n=2, m=2, k libre

  Oblong (or promic, pronic, or heteromecic) numbers: n(n+1) ( http://oeis.org/A002378 )

• n=3, m=2, k libre

  6 times triangular numbers: a(n) = 3*n*(n+1) ( http://oeis.org/A028896 )

Da la sensación de que jugando con las variables del cubo se encontrarían un montón de resultados interesantes.

Para resolver este problema primero vamos a resolver lo siguiente:

Cuantas cadenas de tamaño n pueden ser creadas con todos los símbolos de un alfabeto de k símbolos?

Se propone la siguiente relación de recurrencia de 2 variables, donde:

n: representa el tamaño de la cadena

k: representa la cantidad de símbolos en el alfabeto

f(0, k) = 0

Para todo k, ya que la cantidad de cadenas de tamaño 0 que pueden formarse con todos los símbolos de A es 0.

f(1, 1) = 1

Ya que existe solo una cadena de tamaño 1 con 1 símbolo.

f(n, k) = k( f(n-1,k) + f(n-1, k-1) )

Demostración

Llamemos A_n,k al conjunto de todas las cadenas de tamaño n que contienen a todos los símbolos de A e intentemos construir todas las cadenas que pertenecen a este conjunto.

Para cada símbolo a de A_n,k vamos a realizar el siguiente procedimiento:

1. Llamemos A_n-1,k al conjunto de todas las cadenas de tamaño (n-1) con exactamente k símbolos de A (o sea con todos los símbolos de A).

Para cada cadena α de A_n-1,k construimos una nueva cadena concatenandole a, nos queda así una nueva cadena: aα. Como α tiene tamaño (n-1), la nueva cadena aα tiene tamaño n.

Ademas por definición de A_n-1,k, α contiene a todos los símbolos de A, y en particular contiene a a. Entonces de esta manera hemos formado todas las cadenas de A_n,k que comienzan por a y tienen al menos 2 ocurrencias de a.

Nos queda todavía construir todas las cadenas de A_n,k que comienzan por a pero tienen solo una ocurrencia de a.

2. Llamemos A_n-1,k-1 al conjunto de todas las cadenas de tamaño (n-1) que están formadas por todos los símbolos de A menos a.

Para cada cadena β de A_n-1,k-1 construimos una nueva cadena aβ. Se cumple entonces que aβ tiene tamaño n y ademas dado que β contiene a todos los símbolos de A menos a a y le hemos concatenado a, aβ contiene los k símbolos de A.

A partir de estos dos pasos hemos construido todas las cadenas de A_n,k que comienzan con a. Como por definición de A_n,k, cualquier cadena de A_n,k necesariamente tiene que comenzar con un símbolo de A y a es un elemento arbitrario podemos aplicar el procedimiento para construir todas las cadenas del conjunto A_n,k.

Como por hipótesis, |A_n-1,k-1| = f(n-1,k-1), |A_n-1,k| = f(n-1,k) y como existen exactamente k símbolos de A se cumple que f(n, k) = k( f(n-1,k) + f(n-1, k-1) ).

Cuantas cadenas de tamaño n pueden ser creadas con exactamente m símbolos de un alfabeto de k símbolos?

Asumiendo que la función anterior es correcta, podemos proponer la siguiente función:

Llamemos A_m al conjunto de todos los subconjuntos de A con exactamente m elementos. Es conocido que la cantidad de subconjuntos de tamaño m de un conjunto se puede calcular como:

(Ver Combination) . Sabemos ademas por el resultado anterior que la cantidad de cadenas de tamaño n que pueden hacerse de un conjunto de tamaño m es igual a f(n,m), a partir de lo cual derivamos la formula.

Lo interesante fue que en este proceso fui probando los limites de mi PC y tuve que buscar diferentes soluciones para lograr los resultados que buscaba, ese es el tema de este post, cuyo código se puede encontrar aquí.

Primer Intento en Javascript

Mi primer intento fue simplemente hacer una variedad de diferentes loops en Javascript generando las diferentes combinaciones. Use Javascript porque ingenuamente pensé que era un problema simple y lo que quería resolver rápido.

No hay nada muy complejo en esta solución y se pueden ver una versión para 4 y 5 elementos en la carpeta de Github.

El problema es obviamente que hay que hacer un nested loop para cada tamaño de cadena y alfabeto distinto, era evidente que necesitaba una versión mejor.

Segundo Intento en Javascript

El segundo intento es una versión general que usando recursividad busca generar las diferentes combinaciones y además cuenta la cantidad de símbolos que tiene cada cadena y genera un reporte. De nuevo, fue una versión rápida codificada sin mucho razonamiento previo, pero que era lo suficientemente general como para poder resolver el problema.

El problema fue que cuando intente correrla con valores mayores a 6 o 7, mi navegador se tildaba y tenía que reiniciar la maquina. Bueno, es bien sabido que javascript sobre un browser no es un entorno muy confiable cuando se le demanda demasiado, por otro lado todas las cadenas de tamaño 7 con un alfabeto de 7 son 7⁷=823543 variaciones. Además por como funciona javascript en la función donde se generan estas cadenas, se copia un array, pero cuando se agrega un elemento a un array o se concatenan dos array en javascript (a diferencia de por ejemplo Python, donde las listas se concatenan por referencia) se genera un array nuevo con el consiguiente uso de memoria que esto implica.

function generarCombinaciones(depth, size) {
	if(depth==1) {
		var arr = [];
		for(var x=0; x<size; x++) {
			arr[x] = x;
		} 
		return arr;
	} else {
		var arr = new Array();
		var pre = generarCombinaciones(depth-1, size);
		for(var x=0; x<size; x++) {
			for(var y=0; y<pre.length; y++) {
				var arr2 = new Array();
				arr2.push(x);
				arr2 = arr2.concat(pre[y]);
				arr.push(arr2);
			}
		}
		return arr;
	}
}

Decidí para mejorar la performance pasar a C.

Primer intento en C

El primer intento en C tenía en cuenta este problema y lo que hacia para resolverlo era a través de punteros ir generando recursivamente las nuevos elementos como referenciando a los elementos anteriores. Por ejemplo: primero se generaba la lista [1,2] y luego para generar [[1,1], [1,2], [2,1], [2,2]] se utilizaba el mismo [1] para [1,1] y para [2,1] o sea el puntero de estas dos listas apuntan al mismo nodo en las dos listas. De esta manera se va generando recursivamente un árbol en el que cada sublista es reutilizada por la lista que las listas que la contienen.

Esta versión se puede encontra aquí y se puede correr, haciendo gcc contar_combinaciones.c -lm -o contar_combinaciones. Además esta versión genera una página HTML con las tablas de resultados y también una tabla con los resultados factorizados. La porción de código a la que se hace referencia es:

Result_list generar_combinaciones(int depth, int size) {
	Result_list results = NULL;
	Result_list cursor;

	int x;	

	if(depth == 0) {
		for(x=0; x<size; x++) {
			List temp;
			temp = (List) malloc(sizeof(struct Node));
			temp->value = x;
			temp->next = NULL;

			Result_list temp_result;
			temp_result = (Result_list) malloc(sizeof(struct Result));
			temp_result->list = temp;
			temp_result->next = NULL;

			if(results == NULL) {
				results = temp_result;
				cursor = temp_result;
			} else {
				cursor->next = temp_result;
				cursor = cursor->next;
			}
		}
		return results;
	} else {
		Result_list previous_results;
		Result_list previous_temp_cursor;

		previous_results = generar_combinaciones(depth-1, size);
		
		while(previous_results != NULL) {
			for(x=0; x<size; x++) {
				List temp;
				temp = (List) malloc(sizeof(struct Node));
				temp->value = x;
				temp->next = previous_results->list;

				Result_list temp_result;
				temp_result = (Result_list) malloc(sizeof(struct Result));
				temp_result->list = temp;
				temp_result->next = NULL;

				if(results == NULL) {
					results = temp_result;
					cursor = temp_result;
				} else {
					cursor->next = temp_result;
					cursor = cursor->next;
				}
			}
			previous_temp_cursor = previous_results->next;
			free(previous_results);
			previous_results = previous_temp_cursor;			
		}
		return results;
	}
} 

Me resulto muy interesante de hacer el tener que generar una lista de resultados en cada iteración recursiva que va hilvanando las listas finales.

Sin embargo había otro problema, cuando se van generando cada una de las combinaciones se mantienen en memoria antes de ser computados la cantidad de símbolos que contienen. Bueno con parámetros lo suficientemente grandes, me quedaba sin memoria! y empezaba a tocar el swap (a pesar de que mi maquina de desarrollo tiene 16 gigas de ram). Por lo que tuve que buscar otra solución que fue la solución final.

Solución final en C

En la versión final se me ocurrió simplemente contar la cantidad de símbolos luego de generar la lista. Como las listas se van generando recursivamente me pareció una solución bastante elegante.

void generar_contar_combinaciones(int depth, int size, List lista, int arr[MAX_ALPHABET_SIZE]) {
	int x, c;	
	List cursor_ultimo = lista;

	if(cursor_ultimo != NULL) {
		while(cursor_ultimo->next != NULL) cursor_ultimo = cursor_ultimo->next;
	}

	if(depth == 0) {
		for(x=0; x<size; x++) {
			List temp;
			temp = (List) malloc(sizeof(struct Node));
			temp->value = x;
			temp->next = NULL;

			if(cursor_ultimo == NULL) {
				c = contar_elementos_distintos(temp, size);
				arr[ c ]++;
				free(temp);
			} else {
				cursor_ultimo->next = temp;
				c = contar_elementos_distintos(lista, size);
				arr[ c ]++;
				free(temp);
				cursor_ultimo->next = NULL;
			}
		}
	} else {
		for(x=0; x<size; x++) {
			List temp;
			temp = (List) malloc(sizeof(struct Node));
			temp->value = x;
			temp->next = NULL;

			if(cursor_ultimo == NULL) {
				generar_contar_combinaciones(depth-1, size, temp, arr);
				free(temp);
			} else {
				cursor_ultimo->next = temp;
				generar_contar_combinaciones(depth-1, size, lista, arr);
				free(temp);
				cursor_ultimo->next = NULL;
			}
		}
	}
}

Resultados

Los resultados de esta exploración pueden encontrarse aquí y proximamente voy a hacer un post con la respuesta al problema.

Algunas notas sobre la simulación

Me interesaba analizar específicamente el comportamiento de la porción del algoritmo en la que se itera a travéz de la lista pasados que es la porción variable del mismo. Para hacer esto, cree una variable global total y en cada iteración por la lista pasados en la función esta_en_lista() se la incrementa en uno. El programa escribe luego en STDOUT el valor de esta variable al finalizar. Ver algo.c.

En el script de Python se genera una lhttps://github.com/emluque/Post_Stuff/blob/master/Problema_Algoritmia_Basico/Simulacion/version-1-0.pyista randomizada se levanta un proceso al que se le pasa esta lista como argumento y luego se lee el STDOUT del proceso para obtener el costo. Esto se hace en el archivo: muestras.py y la porción de código que hace esto es:

  def generar_lista(self):
    lista = []
    for i in range(self.n):
      lista.append(random.randint(1, self.k))
    return “,”.join( [str(x) for x in lista])

  def generar_resultado(self, lista ):
    process = subprocess.Popen(["algoritmo/algo", lista] , shell=False, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
    res = “”
    for char in process.stdout.read():
      res += char
    
    process.wait()
    #Esta linea que sigue es medio al dope
    if (process.returncode != None):
      if(process.returncode < 0):
        print(”—-”)
        print(process.returncode)
        print(”—-”)
        raise NameError(”Tio, No andubo el proceso.”) 
    else:   
      process.kill()

    return int(res)

  def generar_resultados(self):
    for i in range(self.cant):
      strr = self.generar_lista();
      a = self.generar_resultado( strr )
      self.resultados.append(a)

Resultados

Un conjunto de resultados pregenerados (una corrida completa del programa puede tardar varias horas) puede verse aquí.

Reportes de Tipo 1

Lo primero que podemos ver en los reportes de tipo 1 es como a mayor tamaño de muestra, la función va tendiendo a un tipo de gráfica especifica. Que no es exactamente igual para diferentes tamaños de alfabeto y cadena, pero se acerca a un Campana de Gauss aunque un poco deformada en la región derecha y con una media corrida un poco hacia la izquierda del rango de valores posibles.

Por ejemplo, este es el gráfico obtenido para tamaño de cadena 10, tamaño de alfabeto 10 con 100000 muestras:

Y este es para 200,200,100000:

Reportes de Tipo 2

Los reportes de tipo 2, permiten ver el comportamiento de la gráfica manteniendo fijo el tamaño de cadena y de muestra.

Que nos muestra el reporte de tipo 2?

Bueno lo que vemos es que manteniendo el tamaño de cadena fijo, al ir aumentando el tamaño de alfabeto, los valores estadísticos (promedio, mediana, modo) van siendo cada vez mayores, lo mismo sucede con la gráfica. Podemos pensar que la posibilidad de ocurrencia de un elemento mayor a los elementos precedentes aumenta a mayor tamaño de alfabeto, lo cual mueve los valores hacia la derecha. Ver el comportamiento de los valores en el reporte para tamaño de cadena 200.

Por otro lado si el tamaño de alfabeto es significativamente mayor al tamaño de cadena, este comportamiento va disminuyendo. Lo cual indica que luego de un determinado valor en función al tamaño de la cadena, la posibilidad de que ocurra un elemento mayor a los elementos anteriores va estabilizándose. Ver reporte para tamaño de cadena 10.

Reportes de Tipo 3

Los reportes de tipo 3, nos muestran que la gráfica de la función se encuentra corrida hacia la izquierda en relación al rango de valores posibles, y que a mayor valor de n y k más hacia la izquierda se mueve en proporción al rango. Esto parecería coincidir con nuestras intuiciones de los posts anteriores, y parecería confirmarse gráficamente los factores de atenuamiento que habíamos considerado en estey este posts.

Gráfico de la función con alfabeto n=50, k=50 y muestra de tamaño 500:

Voy a continuar en este post trabajando sobre la solución básica, analizando el comportamiento de la función esta_en_lista() ante diferentes inputs.

Listas ordenadas con un alfabeto finito

Supongamos que el alfabeto que tienen las listas posibles tiene un tamaño finito, o lo que es lo mismo que el numero de ints posibles es finito, y ademas que las listas son ordenadas y de mayor tamaño al tamaño del alfabeto.

Por ejemplo, tomemos un alfabeto de tamaño 3:

[1,2,3,1,2,3,1,2,3,....]

Sabemos por el análisis del post referido que mientras se va construyendo la lista pasados, se necesita iterar por cada elemento menor hasta incluirlo en la lista. Sabemos así mismo que una vez construida la lista pasados por cada elemento repetido se necesita pasar por todos lo elementos anteriores antes de encontrar al elemento. Por esto, sabemos que el costo asociado a cada elemento es:

T(n%3 == 0) = 2a + w
T(n%3 == 1) = 1a + w
T(n%3 == 2) = 0a + w

Donde a es el costo de iterar por cada elemento de la lista y w es una constante que representa el resto de las operaciones (constantes) de la función, n es la posición del elemento en la lista y Usamos la notación n%3 == x para representar aquellos valores de n en el que el modulo 3 es igual a x

Para el resto del post vamos a olvidarnos de w y preocuparnos solamente por a ya que es aqui donde se producen las operaciones que son variables de la función (por el costo de iterar por la lista).

Es evidente que en una sucesión de listas ordenadas de tamaño 3, la cantidad de veces que se cumplirá la llamada a cada uno de los valores de la recurrencia es 1/3 * n. O sea, en el total de la lista se cumple que 1/3 de los valores son 1, un tercio son 2 y un tercio son 3.

Nos queda entonces el costo total de las llamadas a la función por iterar por cada uno de los elementos como:

Total = 1/3 * n * T(n%3==0) + 1/3 * n * T(n%3 == 1) + 1/3 * n * T(n%3 == 2)

Esta formula puede ampliarse para cualquier tamaño de alfabeto:

Total = 1/k * n * T(n%k == 0) + 1/k * n * T(n%k == k-1) + 1/k * n * T(n%k == k-2) + … + 1/k * n * T(n%k == 1)

Donde k es el tamaño de alfabeto. Ademas sabemos (de acuerdo al análisis del post anterior) que:

T(n%k == 0) = (k-1)a
T(n%k == 1) = (k-2)a
T(n%k == 2) = (k-3)a
...
T(n%k == k-2) = 1a
T(n%k == k-1) = 0a

Por lo que esta formula puede plantearse entonces como:

Total = 1/k * n * (k-1)a + 1/k * n * (k-2)a + 1/k * n * (k-3)a + … + 1/k * n * 1a

O lo que es lo mismo:

Repensando el peor caso

En el peor caso se cumple que la lista esta ordenada y el tamaño del alfabeto es igual al tamaño de la lista, por consiguiente la formula:

Se reduce a:

Que es la equivalencia que vimos anteriormente.

Que pasa si no es una lista ordenada?

Supongamos que la lista no es ordenada y supongamos un alfabeto de tamaño k. En este caso hasta que no se sucedan los k valores del alfabeto, el costo asociado a cada entero no se corresponde directamente con la tabla planteada anteriormente. Por ejemplo si se presenta un 3 como primer elemento, no se van a cumplir 2 iteraciones sino 0, ya que la lista pasados esta vacia. Esto sucederia hasta que aparezcan en la lista todos los elementos del alfabeto.

Podemos plantear (ingenuamente) para este caso una funcion de aproximacion que seria la siguiente:

Total = 1/k * n * (k-1)a + 1/k * n * (k-2)a + 1/k * n * (k-3)a + … + 1/k * n * 1a - j

Donde j representara la disminucion producida en relacion a la formula anterior hasta que se suceden todos los valores de la lista.

Es evidente que, manteniendo fijo el tamaño de alfabeto, y con un tamaño de lista lo significativamente mayor al tamaño de alfabeto, j se vuelve en el caso tipico despreciable en el costo total de la funcion.

Sin embargo analizar el caso promedio sigue siendo muy complicado. Hica varios intentos y me quedaba una formula enorme, por consiguiente decidi hacer una simulacion matematica para evaluarlo y es el tema del ultimo y final post de esta serie.

Referencias

Foundations of Computer Science: C Edition; Aho, Ullman; W. H. Freeman; 1994

Introduction to Algorithms, 2nd Edition; Cormen, Leierson, Rivest, Stein; MIT Press; 2009

Usar un array

La solución mas inmediata es cambiar la lista pasados por un array. Esta version se puede ver en solucion-array.c.

La gran diferencia entre ambas versiones es la función esta_en_lista(), que ahora nos queda:

int esta_en_lista(int value, char pasados[ MAXINT ]) {	

	if( pasados[value] == 1) return 1;
	pasados[value] = 1;
	return -1;

}

Código en solucion-array.c

Porque es una mejora?

El acceso a un array es siempre O(1). Por consiguiente el costo total del algoritmo seria O(n) * O(1), que es equivalente a O(n).

Cuales son las desventajas?

La desventaja principal es que lo que ganamos en la mejora de la complejidad de la función, lo perdemos en la complejidad espacial. Basicamente porque ahora necesitamos alocar e inicializar memoria para un array del tamaño del mayor int posible en la lista.

La otra desventaja es que es necesario inicializar el array a 0. Lo cual hace que el algoritmo de por si tenga una cota minima de O( MAXINT ), en el caso (esperable) de que la lista sea de tamaño mayor que el MAXINT posible este no es un problema ya que la porción del algoritmo que es O(n) es mayor que el MAXINT, pero si estuvieramos trabajando con un input de listas chicas, la solución anterior podria ser preferible.

En definitiva, esta solución es mas efectiva cuando el mayor int posible es pequeño y la lista es muy larga.

Usar un Binary Search Tree

Esta versión se puede ver en solucion-binary-search-tree.c. El código nos queda:

int esta_en_lista(int value, BSTree *pasados) {	
  BSTree cursor = *pasados;

  //El nodo esta vacio
  if( cursor == NULL) {
    BSTree temp = (BSTree) malloc(sizeof(struct BST_Node));
    temp->value = value;
    temp->right = NULL;
    temp->left = NULL;
    *pasados = temp;
    return -1;
  }

  //El nodo tiene el mismo valor
  if( cursor->value == value ) return 1;

  if( cursor->value < value) {
      //Fijarse en el nodo derecho
      return esta_en_lista(value, &(cursor->right));
   } else {
      //Fijarse en el nodo izquierdo
      return esta_en_lista(value, &(cursor->left));
   }
}

La ventaja inmediata de un Binary Search Tree es que la inserción y la busqueda tienen para un input promedio, complejidad O(log(n)). Esto nos mejoraría el algoritmo, llevandolo a O(n log(n)).

Sigue existiendo, sin embargo, el problema de que en el peor caso posible de una lista ordenada ascendentemente: [1,2,3,4,..]; el binary search tree se comporta exactamente igual que una lista. Esto se puede arreglar usando un Balanced Binary Search Tree, aunque es una estructura de datos un poco compleja para acordarse de su implementación y codificarla en una entrevista.

Soluciones esotéricas

Usar un bit array

Si se quiere tener una performance similar a la de un array pero con un uso menor de memoria, se puede usar un Bit Array, aunque tampoco escala bien a nivel espacio.

Usar un hashtable de binary trees

Esta es la ultima opción que codifique y se puede encontrar en solucion-hashtable-de-binary-search-trees.c. Analizar las ventajas y desventajas de esta solución se las dejo al lector.

Referencias

Foundations of Computer Science: C Edition; Aho, Ullman; W. H. Freeman; 1994

Introduction to Algorithms, 2nd Edition; Cormen, Leierson, Rivest, Stein; MIT Press; 2009

Codigo con anotaciones

Para el análisis voy a hacer algunas anotaciones sobre el código, básicamente con comentarios sobre el mismo para dividirlo en diferentes partes. El código que se va a usar en el post es el siguiente:

int esta_en_lista(int value, List *pasados) {

/* B0 */
	List rList, prev;

	rList = *pasados;
	prev = NULL;

	if(rList == NULL) {
/* /B0 */
/* B01	*/
		//Agregarlo antes
		List temp;
		temp = (List) malloc(sizeof(struct Node));
		temp->value = value;
		temp->next = *pasados;
		*pasados = temp;
		return -1;
/* /B01 */
	}

/* B1 */
	while(rList != NULL) {
/* /B1 */

/* B11 */
		if(rList->value == value) return 1;
/* /B11 */
/* B12 */
		if(rList->value > value) {
/* /B12 */
/* B121 */
			List temp;
			temp = (List) malloc(sizeof(struct Node));
			temp->value = value;
			temp->next = rList;
			if(prev==NULL) {
				*pasados = temp;
			} else {
				prev->next = temp;
			}
			return -1;
/* /B121 */
		}
/* B13 */
		prev = rList;
		rList = rList->next;
/* /B13 */
	}
/* B3 */
	//Agregarlo al final
	List temp;
	temp = (List) malloc(sizeof(struct Node));
	temp->value = value;
	temp->next = NULL;
	prev->next = temp;
	return -1;
/* B3 */
}

List * sacar_duplicados(List *lista, List *pasados) {
	//Caso Base
/* A0 */
	if( (*lista) == NULL) {
/* /A0 */
/* A01 */
		return lista;
/* /A01 */
	} else {
	//PASO INDUCTIVO
/* A1 */
		if( esta_en_lista( (*lista)->value, pasados) > 0 ) {
/* /A1 */
/* A10 */
			List next = (*lista)->next;
			free( (*lista) );
			return sacar_duplicados( &(next), pasados);
/* /A10 */
		} else {
/* A11 */
			(*lista)->next = *( sacar_duplicados( &((*lista)->next), pasados) );
			return lista;
/* /A11 */
		}
	}
}

Se ve que estan separadas en el codigo las secciones que se ejecutan independientemente. Una aclaración, jamas en la practica se hace una análisis de complejidad con el nivel de detalle que tiene este post y dudo fuertemente que fuera lo que buscaba el entrevistador (la parte intuitiva de cada caso, alcanzaria), pero ya que estoy haciendo un post y considerando que hay pocos ejemplos en castellano, lo vamos a hacer relativamente riguroso y pedagógico.

Mejores Casos

Lista vacia

Este caso es trivial, pero de todas maneras es importante marcarlo. Se llama a la función sacar_duplicados() con lista igual a NULL, se llega al caso base y se retorna NULL. No hay mucho que analizar.

Lista con todos el mismo elemento

Ej: [1,1,1,1,1,1,1,1,1 ...] .

Vamos a pensarlo intuitivamente:

Básicamente lo que pasa en este caso es que en el primer llamado a sacar_duplicados(), pasados esta vacio por consiguiente en la llamada a esta_en_lista() se agrega el elemento a pasados y se devuelve -1.

Ahora, lo interesante es que en todas las sucesivas llamadas, cada vez que se llame a esta_en_lista() esta función va a iterar por pasados, encontrarlo en el primer intento y devolver 1.

Es evidente que salvo para el primer elemento de la lista, para todos los demas el código va a tardar exactamente lo mismo (O sea que las llamadas a esta funcion son O(1) ). Como la función sacar_duplicados() pasa recursivamente por cada uno de los n elementos de la lista, la complejidad en este caso para todo el algoritmo es O(n).

Pensemoslo más detalladamente. En la primer llamada se ejecutan: A0, A1, A11, B0, B01 y la llamada recursiva al siguiente elemento. En cada una de las siguientes llamadas se ejecuta: A0 + A1 + A10 + B0 + B1 + B11 y la llamada recursiva al próximo elemento. En la ultima llamada, la que se hace cuando ya se recorrio toda la lista y se pasa el ultimo nodo que es NULL se ejecutan: A0 + A01 .

Podemos establecer una relación de recurrencia para analizar el algoritmo pensando en cuantas veces se ejecuta cada una de las partes. Llamemos T(n+1) a la ultima llamada, T(n) a la ultima llamado con un elemento, T(n-1) a la anterior, hasta llegar a T(1) la primer llamada. Nos queda entonces, la siguiente ecuación:

T(n+1) = A0 + A01 + T(n)
T(n) = A0 + A1 + A10 + B0 + B1 + B11 + T(n-1)
T(n-1) = A0 + A1 + A10 + B0 + B1 + B11 + T(n-2)
...
T(2) = A0 + A1 + A10 + B0 + B1 + B11 + T(1)
T(1) =  A0 + A1 + A11 + B0 + B01

La relación de recurrencia es la que va de T(n) a T(2) ya que esta es la parte recurrente, por otro lado, se podría haber planteado todo el problema solo pensando en esto, ya que es aquí donde se hace la parte del procesamiento que crece al crecer el tamaño de la lista y como tal es la que afecta la complejidad del algoritmo.

Es evidente que de 2 a n hay n-1 llamados, entonces la relacion de recurrencia nos queda resuelta como: (n-1)(A0 + A1 + A10 + B0 + B1 + B11) . El total de toda la ecuación ( sumando T(1) y T(n+1) y llamandola f(n) ) es: f(n) = (n-1)(A0 + A1 + A10 + B0 + B1 + B11) + ( A0 + A01) + (A0 + A1 + A11 + B0 + B01) o f(n) = (n+1)(A0)+(n)(A1+B0)+(n-1)(A10+B1+B11)+A01+A11+B01 .

Es evidente que esta función crece linealmente, o sea que en este caso es O(n).

Lista ordenada descendentemente

Ej: [n, n-1, n-2, n-3, ...] .

Este caso es exactamente igual al anterior con la diferencia en que en cada llamado a esta_en_lista() se encuentra que el elemento nuevo es menor a todos los elementos anteriores de pasados en la primera iteración del while y se lo agrega a la misma. De nuevo, las llamadas a esta función son O(1) y el total es O(n)

Peor Caso

Lista ordenada ascendentemente

Ej: [1,2,3,4,5,6 ...]

Bueno, este caso es bastante mas interesante. Intuitivamente, en este caso en cada llamado a esta_en_lista(), el while itera por cada uno de los elementos anteriores que son menores que el nuevo elemento, hasta que se termina el while y se agrega el nuevo elemento. Claramente en cada nueva llamada a la función el numero de iteraciones crece en 1. Intuitivamente podemos pensaer que como el numero de elementos de pasados es función del tamaño de la lista, esta parte es O(n) y como en sacar_duplicados() se itera por cada uno de los elementos de la lista el algoritmo total es O(n^2).

Analizemoslo más en profundidad y hagamos la recurrencia, los casos para el T(1) y T(n+1) son iguales. Luego para cada llamado en un elemento en posicion j de la lista se ejecuta (en orden): A0 + A1 + B0 + (j-1)(B1 + B11 + B12 + B13) + B3 + A10 ( que incluye la llamada recursiva al proximo elemento). La parte a ver y que es la que cambia radicalmente en relación con los casos anteriores es (j-1)(B1 + B11 + B12 + B13), que es la porcion del codigo donde se itera por cada elemento de pasados que preexiste al elemento actual. Esta parte ya no es constante para cada llamada a esta_en_lista(), efectivamente esta parte crece (linealmente) con cada nuevo llamado y luego de un suficiente numero de llamados es donde se concentrara la mayor parte de las operaciones de la función y de todo el algoritmo. Es fácil ver que para un j lo suficientemente grande, el resto de las operaciones se vuelve despreciable en relación al tiempo que se pasa en esta parte. Por ejemplo supongamos que j=1000, nos queda: A0 + A1 + B0 + (999)(B1 + B11 + B12 + B13) + B3 + A10 .

Hagamos la relación de recurrencia:

T(n+1) = A0 + A01 + T(n)
T(n) = A0 + A1 + A10 + B0 + B3 + (n-1)(B1 + B11 + B12 + B13) + T(n-1)
T(n-1) = A0 + A1 + A10 + B0 + B3 + (n-2)(B1 + B11 + B12 + B13) + T(n-2)
...
T(2) = A0 + A1 + A10 + B0 + B3 + (1)(B1 + B11 + B12 + B13) + T(1)
T(1) =  A0 + A1 + A11 + B0 + B01

Centremonos en la parte recurrente, llamemos k a (B1 + B11 + B12 + B13), l a (A0 + A1 + A10 + B0 + B3) y z a T(1) nos queda:

T(n) = l + (n-1)k + T(n-1)
T(n-1) = l + (n-2)k + T(n-2)
...
T(2) = l + (1)k + z 

Para poder pensar la recurrencia vamos a ir asignando los valores en cada paso y tratar de ver si existe algún patrón, intentemoslo:

T(2) = l + k + z
Total = l + k + z

T(3) = l + 2k + T(2)
Total = 2l + (1 + 2)k + z


T(4) = l + 3k + T(3)
Total = 3l + (1 + 2 + 3)k + z

T(5) = l + 4k + T(3)
Total = 4l + (1 + 2 + 3 + 4)k + z

...

T(n) = (n-1)l + (1 + 2 + 3 + 4 + ... + n-1)k + z

La parte del k es simplememnte una sumatoria hasta (n-1), existe una formula bastante básica para la misma que se puede encontrar acá y existe una anecdota muy simpática sobre Gauss sobre la misma. Aplicando equivalencias de sumatoria nos queda para toda esa parte (n * (n-1))/2 = (n^2 - n)/2 = (n²)/2 - n/2.

Veamos entonces como nos queda la recurrencia total (llamando w a T(n+1)): f(n) = (n-1)l + ((n^2)/2)k - (n/2)k + z + w . Esta función es cuadratica y el algoritmo total nos queda O(n^2).

Caso Medio

Pensar sobre el caso medio es todavia mas interesante, porque antes que nada tendriamos que definir exactamente que significa el caso medio y este seria el momento en el que le preguntariamos al entrevistador sobre más precisiones para poder entender el problema. Las preguntas básicas serian:

• El numero de int posibles es finito?
• Cuan ordenada esta la lista?
• Cual es la probabilidad de que que se repitan elementos?
• Es una distribución uniforme?

Intuitivamente, cuando pense el problema originalmente, mi idea era considerando:

1. si la lista no es ordenada se puede dar que en la primera aparicion de un elemento este sea mayor a x elementos que vengan despues que fueran menores en este elemento no se tendria que iterar por todos los anteriores sino solamente por una porción de estos. Ej:

[5,1,6,3,4,2,7]

Iteraciones para cada elemento y como queda pasados:
5 : 0
[5]

1 : 0
[1,5]

6 : 2
[1,5,6]

3 : 1
[1,3,5,6]

4 : 2
[1,3,4,5,6]

2 : 1
[1,2,3,4,5,6]

7 : 6
[1,2,3,4,5,6,7]

Se ven claramente dos cosas, el numero de iteraciones no coincide directamente ni con la posición n del elemento en lista, ni con su orden dentro de pasados; lo otro es que cuando un elemento es mayor a todos los elementos anteriores, si o si, se debe iterar por todos los elementos n-1 de pasados y ahí si, el numero de iteraciones coincide con la posición n del elemento en lista (menos 1).

2. Cuando un elemento se repita, independientemente del factor de ordenamiento de la lista, solo debe iterar hasta encontrarse a si mismo dentro de la lista.

Considerando estas 2 cosas habia pensado ingenuamente en considerar arbitrariamente una constante k, llamemosla factor de atenuación por ordenamiento y otra constante l llamemosla factor de atenuación por duplicados; que combinadas darian una constante c que se podria considerar como afectando la funcion anterior quedando el algoritmo dentro de alguna funcion del tipo f(n): c * n^2; 0 < c < 1 o sea terminando en O(n^2). Especificamente porque quedaria en una funcion cuadratica, porque todos los casos en que un elemento sea mayor a todos los anteriores, si o si, la función esta_en_lista() es lineal.

El problema es que cuando me puse a pensar un poco mas sobre el problema para escribir el post, me surgieron algunas preguntas y honestamente es un problema mucho más complicado de lo que pensaba. Voy a escribir un cuarto post con algunas de las conclusiones a las que llegue, incluyendo la muy sorprendente de que si el número de ints posibles es finito y el tamaño de la lista es mayor a este numero, la función puede ser expresada como una función lineal.

Pero bueno, siendo estrictos una función lineal esta acotada por una función cuadratica y por consiguiente sigue siendo O(n^2).

Referencias

Foundations of Computer Science: C Edition; Aho, Ullman; W. H. Freeman; 1994

Hace unos días estuve hablando con un ex-compañero de la facultad sobre una entrevista de trabajo que había tenido en una empresa muy grande de estados unidos. Me comento muy rapidamente y sin muchos detalles sobre el problema que le habían presentado y me resultó interesante como un buen ejercicio de Algoritmia básica.

Descripción del problema

El problema consiste en dado una lista de numeros enteros, remover los duplicados de la lista. Asumí al hacer el codigo, que interesa mantener la estructura de la lista ( O sea dado una lista: [5,3,4,5,3,2]; encontrar la misma lista pero con los duplicados removidos: [5,3,4,2] ).

Obviamente el problema no es solamente solucionar este problema, sino razonar sobre la corrección y eficiencia de la solución encontrada y ademas codificarlo en algun lenguaje ( especificamente C ).

Algunos pasos previos

Antes de comenzar a trabajar en el problema, me parecio conveniente hacer algunas funciones para poder testear y probar el codigo.

Struct de la lista

La estructura de datos que se va a utilizar en el ejercicio

typedef struct Node *List;
struct Node {
  int value;
  struct Node *next;
};

Función para mostrar la lista

Una función para mostrar la lista por pantalla.

void mostrar_lista(List lista) {
	//Este primer paso es para el pretty print de la lista
	if(lista != NULL) {
		printf("%d", lista->value);
		lista = lista->next;
	}
	while(lista != NULL) {
		printf("-%d", lista->value);
		lista = lista->next;
	}
}

Función para cargar una lista de prueba

Una función que dado un string con una lista de enteros separados por comas, lo parsea a un linked list.

Esta es una versión mejorada sobre la que hice originalmente, esta versión es forgiving con aquellos caracteres que pueden haber sido mal tipeados por el usuario o por input malintencionado, tomando solo los caracteres que representan dígitos ( el string: “1,a2,3b,d4d,xxxx,5,,,,6,a8b0,10″ se tranforma en la lista: [1,2,3,4,5,6,80,10] ). La versión original era un poco más simple y no anticipaba malas entradas.

List crear_lista(List lista, char str[2000]) {
	int i=0;
	List rList = lista;

	//Es forgiving, solo lee los digitos y descarta lo demas.
	while( str[i] != ‘\0′ ) {
		while( str[i] != ‘\0′ && (str[i] < ‘0′ || str[i] > ‘9′) ) i++;
		if(str[i] == ‘\0′) break;

		int pre = 0;
	    
		//Calcular el int
		while( str[i] != ‘,’ && str[i] != ‘\0′ ) {
			if(!(str[i] < ‘0′ || str[i] > ‘9′)) { 
				pre = pre * 10;
				pre = pre + (str[i] - ‘0′);
			} 
			i++; 
		}
	    
		//Crear el nodo nuevo    
		List temp;
		temp = (List) malloc(sizeof(struct Node));
		temp->value = pre;
		temp->next = NULL;

		//Primera iteracion
		if(lista==NULL) {
			//Agregar nodo a lista
			lista = temp;
			//Lista de retorno
			rList = lista;
		} else {
			//Agregar nodo, mover cursor.
			lista->next = temp;
			lista = lista->next;
		} 
		i++;
	}
	return rList;
}

Ejemplo de uso:

	char str[2000] = “”;
	scanf(”%s”, str);
	lista = crear_lista(lista, str);
	printf(”La lista es: \n”);
	mostrar_lista(lista);

Solución básica

La solución básica consiste de 2 funciones. Una función int esta_en_lista(int value, List *pasados) que dado un entero value y una lista pasados verifica si el valor existe en la lista. Si ya existe devuelve 1, si no, devuelve -1 (podría haber usado constantes TRUE y FALSE como macros y el codigo seria mas bonito) y agrega este valor a la lista pasados en orden ascendente. La lista pasados se pasa por referencia ( efectivamente es un puntero a puntero ) dado que como side effect de la función se modifica esta lista, agregandosele ordenadamente cualquier valor que no pre-existe. O sea, en sucesivas llamadas a la funcion se va creando una lista ordenada de valores. La otra función List * sacar_duplicados(List *lista, List *pasados), recibe 2 punteros a listas, la lista de enteros de la que queremos sacar duplicados y una lista donde se guardan los valores que ya existen en la lista. Esta es la función que devuelve la primer lista con los valores removidos. Esta pensado para ser llamada con pasados siendo una lista vacia.

//Version basica a ser mejorada
//Se pasa un puntero al puntero de lista para hacer los side effects
int esta_en_lista(int value, List *pasados) {

	List rList, prev;

	rList = *pasados;
	prev = NULL;

	if(rList == NULL) {
		//Agregarlo antes
		List temp;
		temp = (List) malloc(sizeof(struct Node));
		temp->value = value;
		temp->next = *pasados;
		*pasados = temp;
		return -1;
	}

	while(rList != NULL) {
		if(rList->value == value) return 1;
		if(rList->value > value) {
			List temp;
			temp = (List) malloc(sizeof(struct Node));
			temp->value = value;
			temp->next = rList;
			if(prev==NULL) {
				*pasados = temp;
			} else {
				prev->next = temp;
			}
			return -1;
		}
		prev = rList;
		rList = rList->next;
	}
	//Agregarlo al final
	List temp;
	temp = (List) malloc(sizeof(struct Node));
	temp->value = value;
	temp->next = NULL;
	prev->next = temp;
	return -1;
}



//ESTA ES LA FUNCION QUE IMPORTA EN UN PRIMER PASO
//EN UN SEGUNDO PASO LO QUE IMPORTA ES MEJORAR LA FUNCION ANTERIOR
List * sacar_duplicados(List *lista, List *pasados) {
	//Caso Base
	if( (*lista) == NULL) {
		return lista;
	} else {
	//PASO INDUCTIVO
		if( esta_en_lista( (*lista)->value, pasados) > 0 ) {
			List next = (*lista)->next;
			free( (*lista) );
			return sacar_duplicados( &(next), pasados);
		} else {
			(*lista)->next = *( sacar_duplicados( &((*lista)->next), pasados) );
			return lista;
		}
	}
}

Se puede testear el programa compilando y corriendo solucion-basica.c .

Razonando sobre la corrección del algoritmo

Primera Parte

Lo primero que habria que considerar es si la función esta_en_lista() es correcta. No voy a hacer un análisis muy formal, pero supongamos los posibles casos:

• pasados es una lista vacia: Se ejecuta el primer if: if(rList == NULL) , se crea un nodo nuevo que se agrega a pasados y se devuelve -1.
• pasados no es una lista vacia y el valor existe en la lista:, se ejecuta el primer if y devuelve falso, se ejecuta la sentencia: while(rList != NULL) , se itera por todos los nodos hasta que se encuentra el nodo en el que pre-existe el valor, se llega a la condición: if(rList->value == value) y se devuelve 1.
• pasados no es una lista vacia, el valor no existe en la lista y es menor a cualquier valor de la lista: se llega al while, en la primera iteración se llega a la condición: if(rList->value > value), se crea el nuevo nodo, se le agrega el resto de la lista como nodo hijo y se evalua la condición: if(prev==NULL), como prev fue inicializado a NULL y es la primera iteración, se asigna este nuevo nodo a pasados y se devuelve -1.
• pasados no es una lista vacia, el valor no existe en la lista y esta entre medio de 2 valores de la lista: se llega al while, se itera por los nodos hasta que se llega a la condición: if(rList->value > value), se crea el nuevo nodo, se le agrega el resto de la lista como nodo hijo y se evalua la condición: if(prev==NULL), como prev esta apuntando al nodo pàdre del actual, se asigna este nuevo nodo como hijo de prev y se devuelve -1.
• pasados no es una lista vacia, el valor no existe en la lista y es mayor a cualquier valor de la lista: se llega al while, se itera por los nodos hasta que se recorre toda la lista y se sale del while, se crea el nuevo nodo, se le agrega null como nodo hijo y se evalua la condición, se asigna este nuevo nodo como hijo de prev (que en este momento es el ultimo nodo de la lista) y se devuelve -1.

Razonar sobre la corrección del valor que devuelve (1 o -1) es trivial. Asi como razonar que no agrega un valor que ya existe.

Lo que es importante ver es que si se llama a la función con una lista ordenada y un valor que no existe en la misma, por los 3 ultimos casos (y el primero siendo estrictos, ya que una lista vacia es una lista ordenada), a esta lista se le agrega el valor en orden.

Segunda parte

Asumiendo que la función anterior es correcta y que la función esta_en_lista() devuelve un valor correcto y asi mismo que en sucesivas llamadas a la lista pasados se guardan en esta todos los elementos anteriores, podemos razonar sobre la función sacar_duplicados() que es la que nos importa.

La función es recursiva, por lo que para pensar sobre su corrección alcanza con hacer induccion para demostrar que la función retorna la misma lista sin duplicados. Voy a hacer un esquema del razonamiento que nos llevaria a una demostracion.

Paso base

El paso base es que la lista esta vacia. En ese caso se retorna una lista vacia, como una lista vacia es una lista sin duplicados, no hay nada más que demostrar. El codigo que soporta este caso es:

	//Caso Base
	if( (*lista) == NULL) {
		return lista;
	} 

Paso Inductivo

Ahora tenemos que demostrar que si llamamos a la funcion con una lista con n elementos sin duplicados entonces llamando a la función con la lista con n+1 elementos tambien se retorna una lista sin duplicados.

Para razonar sobre esto alcanza pensar que en el caso en que se llama a la función con (n+1) elementos, se llega a la siguiente porción de codigo:

		if( esta_en_lista( (*lista)->value, pasados) > 0 ) {
			List next = (*lista)->next;
			free( (*lista) );
			return sacar_duplicados( &(next), pasados);
		} else {
			(*lista)->next = *( sacar_duplicados( &((*lista)->next), pasados) );
			return lista;
		}

Analizemos los dos casos:

• Si el valor (n+1) ya existe en la lista, se devuelve la lista hasta n. Como por la hipótesis inductiva, la lista hasta n es una lista sin duplicados y se devuelve esta, la lista que se devuelve en la llamado con n+1 elementos es así mismo una lista sin duplicados.
• Si el valor (n+1) no existe en la lista, se devuelve la lista hasta n mas el elemento n+1. Como por la hipótesis inductiva, la lista hasta n es una lista sin duplicados y por asunción de caso el elemento nuevo no existe en la lista hasta n, la lista que se devuelve en la llamado con n+1 elementos es una lista sin duplicados.

Por exhaustación de casos, se comprueba que se cumple el paso inductivo.

Algunas observaciones sobre el algoritmo

El proximo paso y va ser el siguiente post es analizar la complejidad del algoritmo y despues buscar formas de mejorarlo. Como observaciones basicas se puede ver que llamando a la función sacar_duplicados() con una lista con n elementos, se itera (recursivamente) por cada uno de los n elementos de la lista, por otro lado la lista pasados va creciendo con cada llamado a esta_en_lista() que tiene un elemento nuevo y en todo caso de que este elemento sea mayor a cualquiera de los j elementos anteriores de pasados, esta_en_lista() itera por cada uno de los j elementos de pasados. Es pensando en estos temas que vamos a encarar el siguiente post.

Referencias

Foundations of Computer Science: C Edition; Aho, Ullman; W. H. Freeman; 1994

Principio de Multiplicación (Regla del producto)

Sean A₁,A₂,…, A_n conjuntos finitos, entonces |A₁ x A₂ x … x A_n| = |A₁| . |A₂|  ….  . |A_n|

Ej:
Tomemos 2 conjuntos:
A = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } ; | A | = 10
B = { a, b, c, d, e, f } ; | B | = 5

Supongamos que quiero saber todos las posibles conjuntos formados por 1 elemento de A y otro de B, por ej: { 3, b }, { a, 2 }.

O visto desde lenguajes formales cual es la cantidad de posibles cadenas formadas por primero un elemento de A y después un elemento de B, Ej: “3b”, “2a”, “9c”, “3c".

Existen 10 elementos en A y 5 en B por lo que la solución es: | A | x | B |  = 50

Principio de Adición (Regla de la Suma)

Sean A₁,A₂,…, A_n conjuntos finitos y disjuntos, entonces |A₁ ∪ A₂ ∪ … ∪ A_n| = |A₁| + |A₂| +  ….  + |A_n|

Ej:

Supongamos que tengo que elegir un elemento de A o de B (del ejemplo anterior). Como |A| = 10 y |B| = 5 y A ∩ B = ∅ entonces |A ∪ B| = 15, o sea que existen 15 posibles elementos que puedo elegir.

Principio de Exclusión y Exclusión

Si A₁, A₂ son conjuntos finitos pero no disjuntos. Entonces |A ∪ B| = |A| + |B| - |A ∩ B|
Esto se generaliza para la unión de varios conjuntos.

Permutaciones

Permutaciones

Supongamos que quiero calcular la cardinalidad del conjunto G formado por las cadenas de 3 caracteres formadas por elementos de C= {n, m, p} tales que no se repita nunca ningún elemento: { “nmp”, “npm”, “mnp”, “mpn”, “pmn”, “pnm” }.
Por el principio de multiplicación, Existen 3 posibilidades para el primero, luego como no se repiten 2 para el segundo y 1 para el tercero.
| G | = 3! = 6

La forma de poner n objetos en ordén es: P(n, n) = n!

R-Permutaciones

Supongamos ahora que quiero saber la cardinalidad del conjunto H formado por todas las cadenas de 3 carácteres formadas por elementos de A= { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } sin que se repita nunca ningún elemento. Hay 10 posibilidades para el primer espacio, 9 para el segundo y 8 para el tercero, por lo que:

| H | = $\frac{10!}{7!}$

El número de permutaciones de r objetos de n en ordén pero sin repetición es: P(n, r) = $\frac{n!}{\left(n-r!\right)}$

Permutaciones con repetición

Supongamos que quiero saber la cardinalidad del conjunto formado por todas las cadenas de 3 caracteres formadas por elementos de A = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 } en las que se puedan repetir los elementos. Por la regla del producto existen 10 posibilidades para el primer carácter, 10 para el segundo y 10 para el tercero, por lo que el resultado es 10³.

El número de permutaciones de r objetos de n en ordén con repetición es: n^r

Selecciones

r-combinaciones

Una r-combinación de elementos de un conjunto es una selección sin ordenar de r elementos del conjunto, es decir, de subconjuntos de r elementos.

El número de r-combinaciones de n elementos, donde n es un entero no negativo y r es un entero tal que 0 <= r <= n es: C(n, r) = $\left(\genfrac{}{}{0ex}{}{n}{r}\right)=$$\frac{n!}{r!.\left(n-r\right)!}$
Ej:

Supongamos que quiero calcular la cardinalidad del conjunto J formado por todos los posibles subconjuntos de 2 elementos que contienen elementos de D = {w, x, y, z},  C(4,2) = 6, ya que J = { {w, x}, {w,y} , {w,z}, {x, y}, {x, z}, {y, z}}.

Relación entre r-permutaciones y r-combinaciones

Las r-permutaciones de un conjunto de cardinalidad n se pueden obtener formando las C(n,r) r-combinaciones del conjunto ( o sea todas los posibles subconjuntos de tamaño r formados por los n elementos del conjunto ) y luego ordenando estos elementos de todas las formas posibles, como cada subconjunto tiene tamaño r esto puede hacerse de P(r, r) formas de lo que sigue que:

P(n, r) = C(n, r) . P(r, r)

Selecciones con repetición

En un conjunto con n elementos hay C(n + r - 1, r) combinaciones con repetición.

Ej:

Supongamos que en un grupo de monedas hay 3 tipos distintos de 1, 5 y 10 centavos y hay por lo menos 5 de cada una de ellas. Cuantos posibles combinaciones de 5 monedas es posible extraer de este grupo?  Es importante recalcar que las monedas de cada valor son indistinguibles entre si  y no importa el orden en que se seleccionan las monedas, por lo que hay 5 combinaciones con repetición de 3 elementos.
Supongamos que cuando elejimos las monedas las metemos en una caja con 3 compartimentos, 1 para cada  tipo de moneda, entre cada compartimento hay una barra que las separa, de esta manera algunas de las posibles combinaciones podrian representarse como:
** | * | **
* | | ****
|*****|
***|*|*
…. etc.
Se ve que el numero de seleccionar 5 monedas de entre 3 tipos distintos corresponde al numero de formas de colocar 2 barras y 5 asteriscos. Por lo que el número de formas de seleccionar las monedas es equivalente al número de formas de seleccionar 5 asteriscos de entre 7 posiciones posibles, que se puede hacer de C(7, 5) maneras.

Equivalencias de Números Combinatorios

$$\left(\genfrac{}{}{0ex}{}{0}{0}\right)=\frac{0!}{0!.0!}=1$$

$$\left(\genfrac{}{}{0ex}{}{n}{0}\right)=\frac{n!}{0!.n!}=1$$

$$\left(\genfrac{}{}{0ex}{}{n}{1}\right)=\frac{n!}{1!.n!}=1$$

$$\left(\genfrac{}{}{0ex}{}{n}{n}\right)=\frac{n!}{0!.n!}=1$$

Números combinatorios complentarios

$$\left(\genfrac{}{}{0ex}{}{n}{k}\right)=\frac{n!}{k!.\left(n-k\right)!}=\frac{n!}{\left(n-k\right)!.k!}=\left(\genfrac{}{}{0ex}{}{n}{n-k}\right)$$

Permutaciones con Objetos Indistinguibles y Distribuciones de Objetos en Cajas

Ej 4.5.8 de MD
¿Cuantas permutaciones se pueden realizar con las letras de la palabra “PAPAYA¨? . No se puede usar la formula general de Permutaciones porque la letra “A” se repite 3 veces y la letra “P” se repite 2. Por lo que debe pensarse así: se pueden seleccionar las posiciones de las 3 letras “A” de C(6, 3) formas distintas, las “P” se pueden colocar en C(3,2) formas distinras quedando C(1, 1) para la “Y”. Por la regla del Producto queda:
C(6,3) . C(3, 2) . C(1,1) =  $\frac{6!}{3!.3!}$. $\frac{3!}{2!.1!}$. 1 = $\frac{6!}{3!.2!}$  = 60

El número de permutaciones diferentes de n objetos; donde hay n₁objetos indistinguibles de tipo 1, n₂ objetos indistinguibles de tipo 2, …, n_k objetos indistinguibles de tipo k; es:
$\frac{n!}{n_1!.n_2!\dots .n_k!}$

Ej 4.5.9 de MD
¿De cuántas formas se pueden distribuir a cuatro jugadores manos de 5 cartas usando una baraja de 5 cartas? . Observese que al primero se le pueden distribuir C(52, 5), al segundo C(47, 5), al terceso C(42, 5) y al cuarto C(37, 5) (Quedando 32 cartas en el maso como una 5ta clase posible). Por la regla del producto queda:
C(52, 5) . C(47, 5) . C(42, 5) . C(37, 5) = $\frac{52!}{47!.5!}$. $\frac{47!}{42!.5!}$$\frac{42!}{47!.5!}$. $\frac{37!}{32!.5!}$=  $\frac{52!}{5!.5!.5!.5!.32!}$

El número de formas de distribuir n objetos distinguibles en k cajas distinguibles de forma que en la caja i-ésima haya n_i objetos, i = 1,2, …, k; es:
$\frac{n!}{n_1!.n_2!\dots .n_k!}$

Referencias

Matemática Discreta y sus aplicaciones; Rosen, Kenneth H.; 5ª edición, Mc Graw Hill, 2004

Algebra I; Rojo, Armando; 21ª ed, Magister Eos; 2006

La pregunta es como una maquina que guarda resultados en memoria en forma de expresiones binarias ( esencialmente números, aunque pueden representar otra cosa ) para hacer esto. La respuesta es que la representación de formulas matemáticas puede ser realizada a través de diferentes estructuras de datos y es manipulando estas estructuras que se pueden realizar estos cómputos.

Como un ejemplo básico de esto acá va un ejemplo sacado de C & Data Structures sobre como se pueden hacer operaciones sobre polinomios.

Una estructura de datos para guardar un polinomio y las funciones para llenarlo y mostrarlo.

# include <stdio.h>

# include <stdlib.h>

struct pnode

   {

      int exp;

      int coeff;

      struct pnode *link;

   };

struct pnode *insert(struct pnode *p, int e,int c) {

   struct pnode *temp;

   temp = p;

   if(p==NULL) {

      p=(struct pnode *)malloc(sizeof(struct pnode));

      if(p==NULL) {

         printf("Error de alocación de memoria\n");

         exit(0);

      }

      p-> exp = e;

      p->coeff = c;

      p-> link = NULL;

   } else {

        //Si tienen el mismo exponente se suman los coeficientes en vez de agregar un nodo.

       if(p->exp == e) {

            p->coeff = p->coeff + c;

       } else {

            p->link = insert(p->link, e, c);

       }

   }

   return (p);

}



void printpoly ( struct pnode *p ) {

      printf("The polynomial is\n");

      while (p!= NULL) {

        if(p->exp != 1) {

            printf("%dx^%d\t", p->coeff, p-> exp);

        } else {

            printf("%dx\t", p->coeff);

        }

        p = p-> link;

      }

      printf("\n");

}

Nota: en la función de insertar si un nuevo termino tiene el mismo exponente que uno anterior se lo suma en vez de agregarlo. Esto es una de las modificaciones al código del libro.

Ordenando el polinomio

/* a function to sort a list */

struct pnode *sortpoly(struct pnode *p)

{

   struct pnode *temp1,*temp2,*max,*prev,*q;

   q = NULL;

   while(p != NULL) {

      prev = NULL;

      max = temp1 = p;

      temp2 = p -> link;

      while ( temp2 != NULL ) {

         if(max -> exp < temp2 -> exp) {

            max = temp2;

            prev = temp1;

         }

         temp1 = temp2;

         temp2 = temp2-> link;

      }

      if(prev == NULL) {

            p = max -> link;

       }  else {

            prev -> link = max -> link;

       }

       max -> link = NULL;

        if( q == NULL) {

            q = max;

        } else {

            temp1 = q;

            while( temp1 -> link != NULL) {

                temp1 = temp1 -> link;

            }

            temp1 -> link = max;

        }

    }

    return (q);

}

Una Función para sumar 2 polinomios

/* A function to add two polynomials */

   struct pnode *polyadd(struct pnode *p, struct pnode *q)

   {

      struct pnode *r = NULL;

      int e;

      int c;

      while((p!=NULL) && (q != NULL)) {

            //p mayor exponente que q

            if(p->exp > q->exp) {

                r = insert(r,p->exp,p->coeff);

                p = p->link;



            //q mayor exponenete que p

            } else if(p->exp < q->exp) {

                r = insert(r,q->exp,q->coeff);

                q = q->link;



            //mismo exponente

            } else {

                c = p->coeff + q->coeff;

                e = q->exp;

                r = insert( r, e,c);

                p = p->link;

                q = q->link;

            }

      }

   //Lo que quede de ambos polinomios

    while(p != NULL) {

        r = insert( r, p->exp,p->coeff);

        p = p->link;

    }

    while(q!=NULL) {

        r = insert( r, q->exp,q->coeff);

        q = q->link;

    }

   return(r);

}

Una función para multiplicar polinomios.

Teniendo una función insertar que sume los términos del mismo exponente y una función de suma es muy fácil agregar una función que multiplique polinomios.

struct pnode *polymult(struct pnode *p, struct pnode *q) {

    struct pnode *r, *r2, *temp;

    r = NULL;

    temp = q;

    while(p != NULL) {

        temp = q;

        while(temp != NULL) {

            r = insert(r, (temp->exp + p->exp), (temp->coeff * p->coeff));

            temp = temp->link;

        }

        p = p->link;

    }

    return r;

}

Probando el programa

int main()

   {

         int e;

         int n,i, c;

         struct pnode *poly1 = NULL ;

         struct pnode *poly2=NULL;

         struct pnode *result;

         printf("Enter the terms in the polynomial1 \n");

         scanf("%d",&n);

         i=1;

         while ( n-- > 0 )

         {

      printf( "Enter the exponent and coefficient of the term number %d\n",n);

               scanf("%d %d",&e,&c);

               poly1 = insert ( poly1,e,c);

         }

        printf("Enter the terms in the polynomial2 \n");

         scanf("%d",&n);

         i=1;

         while ( n-- > 0 )

         {

      printf( "Enter the exponent and coefficient of the term number %d\n",n);

               scanf("%d %d",&e,&c);

               poly2 = insert ( poly2,e,c);

         }

         poly1 = sortpoly(poly1);

         poly2 = sortpoly(poly2);

         printf("The polynomial 1 is\n");

         printpoly ( poly1 );

         printf("The polynomial 2 is\n");

         printpoly ( poly2 );

         result = polyadd(poly1,poly2);

         printf("The result of addition is\n");

         printpoly ( result );

         result = polymult(poly1, poly2);

         printf("The result of multiplication is\n");

         printpoly ( result );

         return 0;

   }

Resultados

Enter the terms in the polynomial1 
5
Enter the exponent and coefficient of the term number 4
5 5
Enter the exponent and coefficient of the term number 3
4 4
Enter the exponent and coefficient of the term number 2
3 3
Enter the exponent and coefficient of the term number 1
2 2
Enter the exponent and coefficient of the term number 0
1 1
Enter the terms in the polynomial2 
2
Enter the exponent and coefficient of the term number 1
2 2
Enter the exponent and coefficient of the term number 0
1 1
sdfsdfThe polynomial 1 is
The polynomial is
5x^5	4x^4	3x^3	2x^2	1x	
The polynomial 2 is
The polynomial is
2x^2	1x	
The result of addition is
The polynomial is
5x^5	4x^4	3x^3	4x^2	2x	
The result of multiplication is
The polynomial is
10x^7	13x^6	10x^5	7x^4	4x^3	1x^2	

Pensando en todo esto es interesante en como en MathML se usan estructuras arboreas ( MathML esta basado en XML ) para representar expresiones matematicas y las implicaciones que puede tener a futuro para la automatización de determinado tipo de calculos.

Referencias

C & Data Structures, Deshpande, Kakde; Charles River Media, 2004