Uno de los motivos que me han llevado a estudiar Marketing es la falta de perspectiva sobre las necesidades de nuestros clientes-usuarios  que adolecemos algunos ingenieros que trabajamos en el área de producción. Ahora que estoy aprendiendo algunos conceptos sobre Gestión Financiera me doy cuenta de la importancia que tiene también que conozcamos, aunque sea a grandes rasgos, la situación económica-financiera de nuestra empresa a la hora de tomar decisiones que atañen al área de producción y ventas.

En esta primera entrada de la serie sobre mis apuntes de Gestión Financiera que pretendo publicar voy a intentar sintetizar lo que debemos saber los ingenieros sobre Activo y Pasivo en la empresa.

Activo – Izquierda – Debe

  • El activo es todo lo que hace que la empresa sea productiva.
  • Los activos tienen que ser productivos y estrictamente necesarios.
  • Cuando un activo no es necesario conviene deshacerse de él (venderlo).
  • El activo tiene que ser rentable.

Pasivo – Derecha – Haber

  • El pasivo es lo que financia al activo de la empresa.
  • Debe sumar lo mismo que el activo. Lo que tengo se lo debo a alguien.
  • El pasivo es documental, no interviene en la actividad de la empresa.
  • El pasivo es costoso.

Dicho esto, que me parecen obviedades ahora, no me lo parecieron la primera vez que me enfrenté al PGC. ¿El debe no se supone que es lo que debemos a la gente? ¿El haber no es lo que teóricamente tenemos? Me fui a un recibo del banco y vi que no era así y desde entonces el debe y el haber me parten los esquemas por lo que a partir de ahora hablaré de Activo – Izquierda, Pasivo – Derecha y será la última vez que nombre a los malditos debe y haber.

A los directivos de producción y marketing de una empresa, probablemente no les interese conocer al detalle el significado de cada una de las entradas de un Balance Contable como marca el PGC, sino que les interesará conocer la evolución (un vídeo) de la situación de la empresa a lo largo del tiempo para poder tomar decisiones. Es por esto, que es necesario estructurar la información contable para formar un Balance orientado a la Gestión, que pueda ser comprensible por los directivos no financieros de una empresa.

Estructura del Activo para un balance orientado a la gestión

  • Activo Fijo
    • A.F. Material (se puede peritar para obtener su valor)
    • A.F. Inmaterial (intangible, caracterizado por ser su valor no transmisible y volátil)
  • Activo Circulante
    • A.C. Material
      • Existencias o stocks
      • Cuentas por cobrar de clientes
      • Dinero en efectivo
    • A.C. Inmaterial (no es frecuente)

Estructura del Pasivo

  • Capital propio
    • Capital social (aportaciones de accionistas durante toda la vida de la empresa)
    • Reservas (reinversiones de beneficios obtenidos)
  • Exigible (Deuda que tenemos con alguien)
    • Largo Plazo
    • Corto Plazo

El total del valor del activo debe estar empatado con el pasivo (lo que tengo se lo tengo que deber a alguien), salvo que la empresa se encuentre en quiebra.

La proporción del activo fijo respecto al activo circulante depende del tipo de empresa (sector) y es posible detectar anomalías en la estructura fijándonos en ella. Por ejemplo, una empresa de servicios con un activo circulante mucho mayor que el activo fijo, nos indica que algo extraño sucede en dicha empresa de servicios.

Por el contrario, la composición del pasivo, esto es, cómo se financian los activos de mi empresa, puede variar drásticamente aún entre empresas del mismo sector. El pasivo no define a una empresa, su activo sí lo hace.

Con todo esto somos capaces de identificar y agrupar los activos y pasivos de una empresa (o de nosotros mismos). A partir de aquí podemos realizar disttintos análisis, como por ejemplo, comparar la rentabilidad de los activos con el coste medio del pasivo, que nos permita valorar si es conveniente, por ejemplo, abordar un nuevo proyecto de I+D o lanzar una agresiva campaña de publicidad de uno de nuestros productos. En definitiva, podremos tomar decisiones apoyándonos en nuestros datos económicos-financieros.

Espero seguir publicando sobre este tema según vaya ahondando en la materia, cualquier puntualización o corrección es bienvenida.

Bibliografía: Finanzas para profesionales de Marketing y Ventas de Joan Massons.

:wq

Anuncios

Liderazgo

6 octubre 2008

Dejo como recuerdo algunas de las notas que tomé durante el seminario sobre Liderazgo y Gestión del Tiempo al que pude asistir la semana pasada.

“El mejor director es el que se va dos días de la oficina y todo sigue funcionando.”

“Un directivo que es imprescindible es un directivo mediocre. Hacerse imprescindible es estar haciendolo mal.”

“El directivo más inteligente es el que se rodea de gente más inteligente que él.”

“El buen directivo proporciona a cada colaborador lo que le haga falta para crecer. Si tus colaboradores crecen tú creces con ellos. Si no dejas a tus colaboradores crecer tu tampoco crecerás.”

“La responsabilidad NO se delega.”

“Es mejor esperar a tener toda la información a equivocarnos en la toma de una decisión.”

Espero haber asimilado todo esto y que no se me olvide ponerlo en práctica siempre.

:wq

Para identificar una dirección MAC multicast tenemos que fijarnos en el primer byte (octeto) de los 6 byte que forman la dirección MAC. Si el bit menos significativo está fijado a 1 se trata de una MAC multicast.

Ejemplo MAC:

01:80:c2:00:00:00 en binario el primer octeto equivale a 00000001, por lo que se trata de una MAC multicast.

:wq

Algoritmos Voraces

9 agosto 2007

Los algoritmos voraces son algoritmos genéricos que se usan normalmente para intentar resolver problemas de optimización. Esto es, problemas en los que hay que maximizar o minimizar una función objetivo.

Se parte de un número de elementos de entrada y se van seleccionando o descartando formando el conjunto final de seleccionados que cumplen las restricciones del problema inicial.

No se tiene la posibilidad de dar marcha atrás y rehacer la selección. La solución no tiene porque ser óptima siempre.

Podemos utilizar el siguiente esquema para resolver problemas mediante algoritmos voraces:

alg
   inicializa()
   mientras (No fin() )
      seleccionaYElimina()
      si prometedor():
         anotaEnSolucion()
      fsi
   fmientras
fin

Con la función inicializa() pretendemos establecer las variables necesarias para resolver el problema y asociarles un valor. La función fin() establece el final de las iteraciones sobre el conjunto de elementos de entrada. seleccionaYElimina() es la encargada de elegir el elemento de entrada que se va a procesar y lo elimina del conjunto. prometedor() se encarga de determinar si el elemento elegido añadido al conjunto de salida hace que este mantenga las restricciones del problema. En ese caso se anotaEnSolucion().

Partiendo de este esquema podemos intentar solucionar algunos problemas mediante algoritmos voraces que suelen tener unos ordenes de complejidad bajos.

:wq

En otro ejercicio de clase se nos pide que diseñemos una función que, dado un natural h, devuelva un árbol binario que cumpla que es el árbol equilibrado de altura h con el menor número de nodos posible. El contenido de los nodos de dicho árbol será un natural en el rango de 1 hasta el número de nodos del árbol, de forma que todos los nodos tengan información diferente y el árbol esté ordenado.

Recordemos los conceptos de,

Árbol equilibrado: es un árbol binario de búsqueda en el que para cada nodo el número de niveles de sus subárboles izquierdo y derecho no debe diferir en más de una unidad.

Árbol binario de búsqueda: es un árbol binario que tiene la propiedad que hace que todos los elementos almacenados en el subárbol izquierdo son menores que la raíz y ésta es menor que todos los elementos del subárbol derecho.

Veamos algunos ejemplos de árboles equilibrados,

Árboles equilibrados para una altura dada

Podemos ver que el número de nodos para una altura dada coincide con la expresión 2^(altura – 1). Mi implementación se basa en una función auxiliar recursiva que vaya construyendo los árboles binarios desde las hojas a la raíz sabiendo que los nodos que compondrán el árbol irán ordenados desde 2 hasta el número de nodos además de la primera hoja etiquetada con 1 que hace que se alcance la altura pedida con el mínimo número de nodos.

Esta es mi implementación:

func generaAVL (h: natural) dev (a: BinaryTree)
alg
	// Funcion recursiva auxiliar que genera el arbol binario de búsqueda
	// a partir del número de nodos del árbol que viene dado por 2^(altura -1)
	a := generaAVLaux(2, 2^(h-1)) 
fin

func generaAVLaux (ini, fin) dev (a: BinaryTree)
var
	raiz: Entero
	izq, der: BinaryTree
alg
	raiz := (ini + fin) / 2
	
	si ((raiz - ini) = 1):		// Caso base
		si (ini = 2)
			izq := BinaryTree(BinaryTree(null,1,null), ini, null )
		| otras:
			izq := BinaryTree(null, ini, null)
		fsi
		der := BinaryTree(null, fin, null)
		a := BinaryTree(izq, raiz, der)
	| otras:			// Caso recursivo
		a := BinaryTree( generaAVLaux(ini, raiz-1), raiz, generaAVLaux(raiz+1, fin) )
	fsi
fin

Creo que se trata de una implementación un poco sucia en cuanto al código pero creo que es bastante eficiente. Se trata del ejercicio 4 del boletín de árboles de EDA.

:wq

Código de Huffman

20 abril 2007

Hace poco intenté explicar cómo se utiliza el algoritmo de Huffman para codificar e incluso encriptar una cadena de caracteres.

Llegamos a un punto en el que tenemos un árbol de Huffman y tenemos que recorrerlo para obtener la codificación asociada a cada carácter.

Arbol binario algoritmo Huffman

Esto es precisamente lo que se nos pide en clase: realizar un algoritmo que recibe un árbol binario de Huffman y devuelve dos listas, una con los caracteres y otra con las cadenas que representan el código que se le asigna al carácter. Carácter y código en las listas están relacionadas por la posición que ocupan.

Mi solución en pseudo-código sería la siguiente:

alg codigoHuffman
var
	lcar: Lista de Cadena 	// Lista de caracteres
	lcod: Lista de Cadena 	// Lista de codigos asociados a los caracteres
	a: BinaryTree		// Arbol binario de Huffman
	aux: Cadena		// Cadena auxiliar para ir almacenando los codigos
prin
	recorridoArbolHuffman (a, aux, lcar, lcod) 	//Funcion recursiva
fin

proc recorridoArbolHuffman (a: BinaryTree, aux: Cadena, ent/sal lcar, lcod: Lista de Cadena)
var
	numcar: Entero		// Número de caracteres que tiene el árbol
alg
	si a.isLeaf():		// Caso base
		numcar:= numcar + 1
		lcar.add(numcar, a.getRoot())
		lcod.add(numcar, aux)
	| otras:
		recorridoArbolHuffman( a.Left(), aux.addCaracter("0"), lcar, lcod )
		aux.removeLast()	// Borramos el último elemento de la cadena auxiliar
		recorridoArbolHuffman( a.Right(), aux.addCaracter("1"), lcar, lcod )
		aux.removeLast()
	fsi
fin

Se trata del ejercicio 3 del boletín de árboles de EDA.

:wq

Árbol monodistante

17 abril 2007

Un árbol monodistante de orden N es un árbol binario de números enteros en el que la suma de los valores de los nodos de cada camino que va desde la raíz a un nodo hoja es igual a N.

Ejemplo de árbol monodistante de orden 15:

arbol monodistante de orden 15

En un ejercicio de clase se nos pide que diseñemos una función que compruebe si un árbol es monodistante o no.

El prototipo de la función puede ser el siguiente:

func esMonodistante(a:BinaryTree; n: Natural) dev b:Boolean

La función tiene como entrada un arbol binario (BinaryTree) y un natural que indica el orden y devuelve cierto si el árbol es monodistante o falso en cualquier otro caso.

Siempre que vayamos a trabajar con árboles conviene pensar en una solución recursiva. El caso base de esta función recursiva podría ser que el árbol estuviera vacio o que el árbol sólo tuviera una hoja. En el resto de casos sólo tendríamos que comprobar que el subarbol derecho y el subarbol izquierdo son monodistantes haciendo una llamada recursiva y decrementando el orden del árbol.

Mi solución recursiva es esta:

func esMonodistante (a:BinaryTree, n:Natural) dev (b:Logico)
alg
	si a.isEmpty():   //el árbol está vacio
		b := cierto
	| a.isLeaf():     //el árbol es una hoja
		b := ( a.getRoot() = n )
	otras
		b := (esMonodistante(a.left() , n-a.getRoot())
		    Y esMonodistante(a.right(), n-a.getRoot()) )
	fsi
fin

Por si os sirve de algo se trata del Ejercicio 19 del Boletín de Árboles de la asignatura Estructuras de Datos y Algoritmos

:wq