El Test de Turing fue una de las maravillas de ingenio que ideó Alan Turing (1912-1954) para determinar cuándo “algo” es inteligente o no. Este test se enmarcaba en las teorizaciones sobre inteligencia artificial de Turing, padre de la computación y precursor de la informática moderna. Básicamente Turing estableció que si “algo” se comportaba como si fuera inteligente, entonces era inteligente. Efectivamente inteligente (y no falsamente o solo aparentemente inteligente).

La forma de hacer pasar el test a un ordenador (por ejemplo, para detectar si el ordenador es inteligente o no) consiste básicamente en una persona hablando con un ordenador que está en otra habitación mediante un sistema de chat. Si la persona es incapaz de determinar si habla con otra persona o con un ordenador, entonces el ordenador es considerado inteligente (no “inteligente”, sino verdaderamente inteligente). Ninguna máquina ha sido capaz de superar el Test de Turing, de momento.

Esto puede parecer puramente anecdótico, pero hay versiones del Test de Turing que nuestros ojos están acostumbrados a ver en el día a día. Es el caso del Captcha: Completely Automated Public Turing Test to tell Computers and Humans Apart (Prueba de Turing pública y automática para diferenciar a máquinas y humanos). Son las típicas letras retorcidas o preguntas del tipo “dos más dos” que protegen formularios y demás en internet. La prueba asume que un robot no humano es incapaz de comprender lo que pone en las letras, y por tanto no es capaz de superar la prueba que un humano encuentra fácilmente superable.

No es un Test de Turing puro, y lo lleva a cabo una máquina y no un humano, y sin embargo se ha demostrado muy eficaz. Por supuesto detrás lleva una escalada imaginativa de robots cada día más capaces de un reconocimiento de caracteres e interpretación de los mismos, etcétera. Toda esta creatividad volcada en violar los Captcha redunda luego en beneficio, por ejemplo, de los discapacitados, al mejorar mucho el software de reconocimiento de voz o de escritura humana.

No deja de ser interesante que muchas de los problemas y situaciones que ya se planteaban antes de la creación (física) de los ordenadores hayan tardado décadas en empezar a darse en el terreno práctico. ¿Estará cercano el día en el que una máquina supere el Test de Turing? ¿Será inteligente de verdad? ¿Y si supera otras pruebas más restrictivas? ¿Qué pasará?

Pero… ¿qué es un servidor? No es más que una aplicación informática o programa que realiza algunas tareas en beneficio de otras aplicaciones llamadas clientes. Algunos servicios habituales son los servicios de archivos, que permiten a los usuarios almacenar y acceder a los archivos de un ordenador y los servicios de aplicaciones, que realizan tareas en beneficio directo del usuario final.

Con ocho núcleos y 64 subprocesos, el procesador UltraSPARC T2 es un “servidor en chip”, que combina el alto rendimiento con un menor consumo energético con tres funciones esenciales integradas en el chip: red de 10 GbE de múltiples subprocesos, aceleración de cifrado y expansión de E/S PCI-Express.

UltraSPARC T2 fue lanzado el pasado día 8 de agosto y pasa por ser el único procesador de volumen que integra en un único chip 8 núcleos y hasta 64 hilos de ejecución, reuniendo además las funciones clave de un servidor: gran capacidad de proceso (tanto en punto fijo como en punto flotante), conectividad, virtualización y seguridad. Y todo ello optimizado para el sistema operativo Solaris.

Más rendimiento, más fiabilidad, y una mayor eficiencia energética en menor espacio. Todo ello se traduce en una importante reducción de costes.

Basado en la revolucionaria tecnología Chip MultiThread (CMT), este nuevo procesador marca nuevos récords mundiales en rendimiento y permite ahorrar energía, ya que consume menos de 2 vatios por hilo de ejecución. Esta empresa siempre ha estado concienciada con la eficiencia energética y lidera el mercado de procesadores co-responsables de alto rendimiento.

Quizás, el hito más interesante es que la primera versión, la beta, sale en código abierto para disfrute de los programadores y viciosillos de estos aparatillos. Cualquiera puede echar un ojillo y opinar!

Vía | Sun Microsystem
Web Oficial | UltraSPARC T2
Fuente | Wikipedia
Fuente | OpenSPARC

Dos científicos holandeses han creado un software que es capaz de determinar el grado de felicidad que presenta una persona a partir del análisis realizado en los gestos faciales. Se trata de una técnica capaz de reconocer los gestos faciales de una persona a través de la captura por un sistema de vídeo, posteriormente las imágenes son convertidas en gráficos 3D gracias a un algoritmo y finalmente se elabora el análisis que detecta el grado de placer del sujeto.

El análisis de las emociones por parte del software funciona del siguiente modo: todos nuestros músculos faciales trabajan cuando lloramos, reímos, nos enfadamos, etc., los gráficos 3D son creados estableciendo 12 áreas significativas de nuestro estado de ánimo, como por ejemplo la zona de la boca o los extremos de las zonas donde se encuentran los ojos. Todos los movimientos de los músculos que en ese momento están actuando son agrupados dando una imagen que se compara con los seis patrones básicos que contiene el software, sorpresa, felicidad, miedo, tristeza, etc. El software también logra identificar la mezcla de algunos de los seis patrones mostrando el resultado al operador.

Para probar el nuevo sistema se realizaron varias pruebas con 300 mujeres proporcionándoles helados de distintos sabores, frutas y otros alimentos. Con cada alimento la reacción era distinta, al parecer, el helado y el chocolate producían un grado de felicidad mayor que otros alimentos que incluso llegaban a provocar sentimientos de tristeza, es el caso del yogur.

La empresa responsable del desarrollo del software y sus creadores, Theo Gevers y Nicu Seve, ya ha encontrado una aplicación ideal, comprobar el grado de felicidad que suscitan algunos de los nuevos productos que aparecen en el mercado. Como sistema para comprobar la efectividad y la satisfacción que produce un determinado producto puede estar bien, aunque la verdad, basta con mirar detenidamente a una persona para saber si le satisface lo que está comiendo.

Vía | Clarín
Más información | Unilever
Más información | Wired
Más información | Theo Gevers
Más información | Nicu Seve

Hace unos días escribí una entrada en Genciencia sobre la “biología sintética”, uno de los cuatro submundos que Antinoo Segura establece en su divertido y controvertido artículo “La bioinformática: una ciencia de riesgo”.

Dichos submundos, según el artículo citado, son:

• Computacional Genomics, Genomica Computacional o Genus Compus
• Structural Bioinformatics, Bioinformática Estructural o Estructurus
• Systems Biology, Biología de Sistemas o Sistematicus Biologius
• Algorithms and Databases, Algoritmos y Bases de datos o Datus

El artículo en cuestión nació a raíz de un encargo de “Omnis Cellula”, una revista científico-cultural editada por la Sociedad Catalana de Biología. El autor se planteó inicialmente responder a la pregunta ¿qué hace un bioinformático cuando llega por la mañana al trabajo?

El resultado final es un texto de divulgación muy interesante que, desde una perspectiva humorística, ayuda a aclarar cuáles son los objetivos de la bioinformática. En cualquier caso, y como propone el mismo autor del artículo, se puede encontrar información más detallada en la Wikipedia, un buen punto de partida a partir del cual iniciar una investigación personal más amplia.

Vía | Pensamientos aleatorios
Más información | Omnis Cellula
Más información | Bioinformatics

Genciencia | Ingeniería genética extrema

Un grupo de científicos del Instituto de Ciencias de la Construcción Eduardo Torroja perteneciente al CSIC (Consejo Superior de Investigaciones Científicas), acaba de desarrollar un nuevo material resultante de la combustión del carbón, muy similar al cemento que además supera varias de las prestaciones del cemento convencional.

Gracias a este nuevo material, se obtendría hasta una reducción del 50% de las emisiones que se realizan de dióxido de carbono a la atmósfera como consecuencia de la elaboración, ya que se necesita menos temperatura para su fabricación, con lo que la industria cementera podría contribuir al mantenimiento del medio ambiente.

Aunque no todo acaba aquí, el nuevo cemento es también capaz de absorber diversas sustancias volátiles que son nocivas para la salud, dichas sustancias son las que pueden desprender los barnices o productos de limpieza entre otros. Para elaborar cemento Pórtland se necesita una temperatura de 1450 grados centígrados, el nuevo material tan sólo 80 grados centígrados, con lo que la reducción de energía hidroeléctrica sería muy notable.

Las pruebas realizadas indican que el comportamiento de este nuevo material es idéntico al del tradicional Pórtland, es tan similar que incluso un experto no podría distinguir entre los dos materiales. Todas las pruebas realizadas para conocer la respuesta frente a distintas agresiones externas como el fuego, el agua, etc., determinan que incluso presenta mayor resistencia que el tradicional cemento. Al ser un material más ligero también puede utilizarse para hacer diversos componentes de la construcción que serían empleados en las construcciones que requieran menor peso.

Todavía queda una prueba por realizar con el nuevo material, la durabilidad con el paso del tiempo, aunque parece que esta será superada sin problema alguno.

Vía CSIC

Igualmente, si el ordenador tiene un reloj que genere interrupciones periódicas, se puede usar para forzar el cambio de un proceso a otro; con esta actuación, el tiempo del procesador se distribuye más equitativamente entre los procesos, llegando así al tiempo compartido.

Referencias | Wikipedia.org
Referencias | Universidad Nacional del Nordeste

Tim Berners-Lee, el artífice del World Wide Web y uno de los responsables de esta nueva iniciativa, indica la necesidad de elaborar una ciencia específica para entender lo que representa la red y los escollos que en ella se pueden encontrar. En la nueva ciencia se conjugarán todos los aspectos contenidos en la red, sea sociología, consumo, derechos de autor, cualquier aspecto que se relacione y que haya ganado presencia gracias a la red.

Los nuevos títulos empezarán a ser ofrecidos en el año 2008 y estarán dirigidos a los estudiantes de master para más tarde comenzar con las titulaciones de Grado (licenciaturas). Se contemplarán aspectos como la teoría de la evolución de la web o la web semántica, donde se pretende una búsqueda con mayor comprensión en la red que proporcione información mucho más certera y rápida.

La red nos cambia en numerosos aspectos e incluso nos moldea físicamente, de eso no hay duda. La nueva titulación será, además de interesante, una puerta abierta para responder a multitud de cuestiones sobre la relación existente entre las personas y la red.

Parece mentira, en 1995 había en todo el mundo 18.000 sitios web, el pasado mes de octubre se supero la barrera de los 100 millones de sitios web y la marcha continúa…

Más información | EL país
Más información | The New York Times
Más información | Massachusetts Institute of Technology
Más información | University of Southampton
Más información | Wikipedia

• Parseador: Es la clase que se encarga de leer el documento XML. Esta clase contiene varios métodos por defecto: inicioElemento(Avisa que se ha encontrado una etiqueta registro, y de paso almacenamos el atributo definido en ella), finElemento (Tratamos los datos, en nuestro caso almacenamos en el objeto Vector) y characters (recibe la ubicación de los caracteres del elemento y los extraemos almacenándolos en una cadena). En realidad inicioElemento y finalElemento son una versión simplificada de los métodos startElement y endElement. De aquí sacaremos una colección con los datos que hayamos leído durante el proceso de lectura. En la variable valor se irá guardando una cadena que contiene los datos extraídos, es decir, los datos que tendremos que almacenar en la colección. El código es el siguiente:

  import org.xml.sax.helpers.DefaultHandler;
  import org.xml.sax.Attributes;
  import java.util.Vector;
  import org.xml.sax.*;
  import org.xml.sax.helpers.*;
  
  
  	
  public class Parseador extends DefaultHandler  {
    private Vector coleccion; 
    private Acciones actual; 
    private String valor; 
  
    public Parseador (Vector coleccion) {
       this.coleccion = coleccion; 
    }
  
    /*
    localName: contiene el nombre de la etiqueta.
    att: de la clase "org.xml.sax.Attributes",
    es una tabla que contiene los atributos
    contenidos en la etiqueta.
    */
    public void startElement( String namespaceURI,
             String localName, String qName,
             Attributes attr ) throws SAXException {
  
       inicioElemento(localName, attr);
    }
  
    public void endElement (String namespaceURI,
             String localName, String rawName)
             throws SAXException {
        finElemento(localName);
    }
  
     public void inicioElemento(String nombreElemento,
              Attributes atributo) throws SAXException {
  
        if (nombreElemento.equals("entrada")) {
          actual = new Acciones (); 
          coleccion.addElement(actual); 
          actual.setID(
               Integer.parseInt(atributo.getValue("id"))); 
        }
      }
  
      public void finElemento(String nombreElemento)
               throws SAXException {
  
          if (nombreElemento.equals("nombre")){ 
            actual.setNombre (valor);
          } else if (nombreElemento.equals("telefono")) {
            actual.setTelefono (Integer.parseInt(valor)); 
          }
      }
  
      public void characters (char[] ch, int start, int end)
      {
  
         valor = new String (ch, start, end);
         valor = valor.trim();
      }
  }
  

• Acciones: La clase Acciones contiene sencillos métodos get y set utilizando en la aplicación. Viene dada por el siguiente código:

  public class Acciones {
  
     private String documento;
     private String nombre;
     private int telefono;
     private int id;
  
     public void setNombre (String nombre) {
        this.nombre = nombre;
     }
  
     public void setTelefono (int telefono) {
        this.telefono = telefono;
     }
  
     public void setID (int id) {
        this.id = id;
     }
  
     public void setDocumento(String documento) {
        this.documento = documento;
     }
  
      public String getNombre() {
         return nombre;
      }
  
      public int getTelefono()  {
         return telefono;
      }
  
       public int getID() {
         return id;
       }
  
       public String getDocumento() {
         return documento;
       }
  }
  

• Index: Es la clase que contiene el main e invoca a las demás clases. Su código es el que se muestra a continuación:

  import java.util.Vector;
  import org.xml.sax.XMLReader;
  import org.xml.sax.SAXException;
  import org.apache.xerces.parsers.SAXParser;
  import org.xml.sax.*;
  
  	
  public class Index {
  
    Vector coleccion = new Vector ();
    Acciones acciones = new Acciones ();
    XMLReader parser = new SAXParser();
  
   public void ParsearDocumento () throws Exception {
  
        String nombre_de_archivo;
        acciones.setDocumento("index.xml"); 
        nombre_de_archivo=acciones.getDocumento(); 
        parser.setContentHandler(new Parseador(coleccion));
        parser.parse(nombre_de_archivo); 
        Interfaz contenedor = new Interfaz(coleccion);
   }
  
   public static void main(String[] args) throws Exception {
  
        Index ejecutar = new Index();
        ejecutar.ParsearDocumento();
   }
  
  	
  }
  

• Interfaz y Conclusión: La clase Interfaz es la que se encarga de crear la interfaz gráfica dónde se mostrarán los datos en pantalla. La clase Conclusión es una clase auxiliar de Interfaz.

  import java.util.Vector;
  import java.awt.FlowLayout;
  import java.awt.Frame;
  import java.awt.List;
  import java.awt.MenuBar;
  import java.awt.Menu;
  import java.awt.MenuItem;
  import java.awt.Event;
  import java.awt.*;
  import java.awt.image.ImageObserver;
  
  
  	
  public class Interfaz {
  
     public Interfaz(Vector datos) {
  
        int i;
        Acciones[] inserta=new Acciones[datos.size()]; 
        List miLista = new List(15,false);
  
        for(i=0;i<datos .size();i++) {
           inserta[i]=(Acciones)datos.elementAt(i);
           miLista.add(inserta[i].getID()+"."
              <ins>inserta[i].getNombre()</ins>
              " - "+inserta[i].getTelefono());
        }
  
        Frame miFrame = new Frame("Agenda Electrónica XML");
        miFrame.setLayout(new FlowLayout());
        miFrame.add(miLista);
        miFrame.setSize(200,275);
        miFrame.setVisible(true); 
        miFrame.addWindowListener(new Conclusion());
  
     }
  }
  

  import java.awt.*;
  import java.awt.event.*;
  
  	
  public class Conclusion extends WindowAdapter {
      public void windowClosing( WindowEvent evt ) {
           System.exit(0);
      }
  
  }
  
  

  
  

Podemos parsear un documento XML de dos modos: usando SAX o DOM. Podemos distinguir a grandes rasgos el funcionamiento de cada modo de parseo de la siguiente forma:

• DOM: DOM crea un árbol jerárquico en memoria que contiene el todo documento XML, y con él en memoria podemos hacer realizar cualquier tipo de recorrido, movimiento o acción con los elementos que deseemos.


• SAX: SAX significa Simple API for XML. Se usa para realizar un recorrido secuencial de los elementos del documento XML, es decir, vamos tratando la información a la vez que la vamos leyendo.

SAX es menos potente que DOM, pero aún así es más rápido y útil para los casos donde por ejemplo interesa hacer una lectura secuencial o buscar algún fragmento en un documento.

Para mostrar el funcionamiento de un parser de XML, crearemos una pequeña aplicación donde leeremos el contenido de un documento XML usando SAX y lo mostraremos en pantalla. Para escribir el programa usaremos Java, aún así lo podriamos hacer en cualquier otro C++, PHP, Python, ...

Nuestra aplicación parseará el siguiente documento XML de ejemplo, que se trata de una agenda que almacena el nombre y el número de teléfono de cada registro insertado.

< ?xml version="1.0"?>
<agenda>
   <entrada id="1">
      <nombre> Javier </nombre>
      <telefono> 956425981 </telefono>
   </entrada>
   <entrada id="2">
      <nombre> Fran </nombre>
      <telefono> 645675431 </telefono>
   </entrada>
   <entrada id="3">
      <nombre> Alfonso </nombre>
      <telefono> 660137258 </telefono>
   </entrada>
   <entrada id="4">
      <nombre> Manuel </nombre>
      <telefono> 625435431 </telefono>
   </entrada>
   <entrada id="5">
      <nombre> Paco </nombre>
      <telefono> 630603804 </telefono>
   </entrada>
</agenda>

Para parsear el documento usaremos JAXP y Xerces. JAXP (Java API for XML Processing) es un conjunto de clases que permite a las aplicaciones en Java parsear y transformar documento XML independientemente del modo de procesamiento utilizado. La razón de la existencia de JAXP es facilitar el uso de XML en la plataforma Java, garantizando que una aplicación escrita en Java orientanda hacia un parser con soporte JAXP puede ser migrado a otro sin ningún problema. Xerces es un parseador desarrollado por la fundacion Aparche.org disponible para Java y C++. Para escribir nuestro programa usaremos Xerces.

Mañana continuaremos con la segunda parte Parseando XML con Java (II) donde mostraré la implementación de las clases necesarias y subiré el código de fuente.

Entrada

• Conjunto de Símbolos:


• Pesos asociados:

Donde n es la cantidad de símbolos diferentes que existe en la cadena de entrada. Así pues los pesos asociados a los símbolos pertenecientes al conjunto A se encuentran en un rango comprendido entre 1 y n (entendiendo que la entrada no va a ser una cadena vacía), es decir:

Salida

• Conjunto de código binarios:

Meta

• Conseguir que el peso de C sea menor que el de A:

1. Primero calculamos los pesos de los símbolos (¡ojo!, los espacios en blanco también cuentan) y los disponemos siguiente una ordenación ascendente por frecuencia

   p(1)->b(1)->u(1)->n(1)->i(2)->t(2)->c(2)->v(2)->’ ’(3)->a(3)->l(3)->o(3)

2. En el paso anterior obtenemos n árboles. Ahora fusionamos los dos primeros árboles sumando sus frecuencias y volviendo a ordenar

   

3. Seguimos agrupando pares de árboles hasta obtener solamente uno. La raíz del árbol resultante debe de ser la suma de los pesos

   

4. Ahora a partir de nuestro árbol obtendremos la codificación de Huffman para nuestra cadena. La regla que hay que seguir es la siguiente: Cuando nos encontremos en un nodo las ramas a la izquierda valen ceros y a la derecha valen unos. Para nuestra cadena las correspondencias quedarían de la siguiente manera:

   

5. Traducimos la cadena de entrada con nuestras correspondencias y agrupamos en grupos de 8 bits (bytes) la cadena binaria resultante

   

   En la cadena resultante se ha reducido la cantidad de bytes respecto a la cadena original que tenía 24 bytes. Cabe decir que también hay que almacenar información de la codificación, pues para descomprimir los datos hay que conocer las correspondencias ya que es relativo. Por esta razón para ficheros de poco tamaño la compresión no es muy grande, aunque esta afirmación es muy relativa, ya que el porcentaje de compresión depende de la entrada.
   

El otro día alguien preguntó para qué servían los números de Mersenne. El número mínimo de movimientos para resolver el juego de las Torres de Hanoi viene dado por los números de Mersenne (M=2ⁿ-1 con n primo), siendo el n el número de discos a trasladar. Por lo tanto, los monjes hubiesen necesitado 2⁶⁴-1 = 18446744073709551615 movimientos para resolver el juego con 64 discos. Si suponemos que los monjes realizan un movimiento por segundo tardarían 58454204609 siglos y 6 años en completar el traslado, contando con que no descansen ni un solo segundo en ese tiempo ni que cometan ningún fallo, pues el tiempo que hemos calculado ha sido el mínimo número de movimientos, es decir, hemos excluido los posibles fallos. Lógicamente si resolvemos este problema para 64 discos el mundo no se acaba Existe un algoritmo recursivo donde podemos ver una sencilla solución al problema:

hanoi(n, Orig, Aux, Dst)
si (N>0) hacer
hanoi(n-1, Orig, Dst, Aux)
escribir(Movemos Orig a Dst)
hanoi(n-1, Aux, Orig, Dst)

public class TorresDeHanoi {

	
public static void main(String[] args) {
    TorresDeHanoi tdh = new TorresDeHanoi();
    tdh.hanoi(3, "A", "B", "C"); //Modifica el primer argumento
 }

	
private void hanoi(int n, String ini, String aux, String fin) {
 if (n > 0) {
  hanoi(n-1,"A","C","B");
  System.out.println("Mover " + n + " de " + ini + " a " + fin);
  hanoi(n-1,"B","C","A");
 }
 }
}

Esta aplicación imprime en pantalla los movimientos mínimos que hay que realizar para resolver el juego para el número de discos que definimos en la instancia del método hanoi (el primer argumento). Probad la clase y podréis ver el algoritmo recursivo en funcionamiento

Más información | Descartes 3D
Más información | Torres de Hanoi en Wikipedia

Veamos el problema con un ejemplo:

En este ejemplo el viajante tiene que realizar un trayecto de 56 km. En su ruta dispone de 5 gasolineras, siendo conocedor de sus distancias entre ellas (vector g[i]). El número de kilómetros máximos que puede realizar sin repostar es 30, por lo tanto repostamos en una gasolinera si no podemos llegar a la siguiente. Si el viajante del problema avanza hasta la primera gasolinera se encuentra con lo siguiente:

Vemos que no es necesario repostar puesto que podríamos llegar a la siguiente gasolinera sin problemas. Esto no ocurre cuando llegamos a la tercera gasolinera:

Aquí calculamos los kilómetros que tendríamos que realizar para llegar a la siguiente gasolinera y nos indica que no poseemos suficiente combustible. Por lo tanto, debemos de repostar en la tercera gasolinera. Cabe decir que cuando repostamos los kilómetros que hemos realizado desde la última vez que repostamos (kms) vuelven a 0.

El mejor caso posible (que no tuviéramos que parar a repostar en ninguna gasolinera) tendríamos que recorrer el vector una sola vez, por lo que la complejidad sería O(n). El peor de los casos evidentemente sería tener que parar en todas las gasolineras, por lo cual tendríamos una complejidad O(n²). Así pues, la complejidad de este algoritmo se encuentra en un punto intermedio entre O(n) y 0(n²), según el número de gasolineras donde haya que parar.

Más información | Algoritmos Voraces en Wikipedia

En este ejemplo nos proporcionan un sistema monetario que contiene monedas de valor 10, 6, 5 y 1. La cantidad que debemos cambiar es C=12. El algoritmo voraz siempre intentará realizar el cambio mediante monedas del mayor valor posible. Si en algún paso C es menor estricto que S[t] (t≤K), se incrementará t y repetiremos el mismo paso para la siguiente moneda de S. Al finalizar, el algoritmo voraz nos indica que el cambio resultante para 12 son dos monedas de 1 y una de 10. Cómo he comentado al principio los algoritmos voraces en muchas ocasiones no presentan la mejor solución, pues en éste ejemplo sería mejor cambiar 12 por dos monedas de 6, entendiendo por mejor solución devolver el menor número de monedas posibles.

También cabe decir que a veces los algoritmos voraces nos indican que no existe solución cuando realmente sí la hay. Un ejemplo de ello es el siguiente:

El esquema básico de un algoritmo voraz es el siguiente:

Clase EsquemaVoraz
proc voraz()
    alg
       inicializa()
       mientras (No fin())
seleccionaYElimina()
si (prometedor()):
   anotaEnSolucion()
fsi
      fmientras
   fin

Para usar el esquema para resolver el Problema del cambio de moneda debemos de implementar los métodos inicializa, fin, seleccionaYElimina, prometedor y anotaEnSolucion.

• inicializa(): Crea e inicializa a ceros el array de enteros dónde se anotará la solución y pone a cero el puntero k.
• fin(): Comprueba si hemos terminado verificando que se cumpla que hemos llegado al final del recorrido del sistema monetario (es decir, que ya no hay monedas de valor más pequeño) o el cambio se haya completado (c=0).
• seleccionaYElimina(): Incrementamos el puntero k para seleccionar una moneda de menor valor.
• prometedor(): Nos indica si la moneda candidata es solución para realizar el cambio (condición: que la moneda tenga un valor inferior al cambio).
• anotaEnSolución(): Si el candidato cumple la condición lo anotamos en el array de solución.

Clase CambiodeMonedas hereda EsquemaVoraz
m: array[1..n] de Entero
c: Entero
k: Entero
sol: array[1..n] de Entero

	
proc inicializa()
    alg
       sol:=
       k:=0
    fin

	
func fin() dev (b: Lógico)
    alg
       b:=((k=n) ó (c=0))
    fin

	
proc seleccionaYElimina()
    alg
       k:=k+1
    fin

	
func prometedor() dev (b: Lógico)
    alg
       b:=(m[k] 

	
Más información | <a href="http://en.wikipedia.org/wiki/Greedy_algorithm">Greedy algorithm en Wikipedia</a>