La Sombra de Dijkstra

Sobre el arte y la práctica de la programación

Resultado Desafío Enero - Los Cuatro Cuatros

| Comentarios

Llegó el momento de evaluar a los participantes del desafío de este mes: “Los Cuatro Cuatros”.

Los participantes en esta oportunidad son:

Thomas Hermosilla hizo una propuesta, pero no se ajusta mucho a lo requerido, aunque es interesante: https://gist.github.com/thermosilla/8996333, sin embargo no participa.

Evaluación

Todas las soluciones las coloqué en este repositorio https://github.com/lnds/programando.org/tree/master/cuatrocuatros para mayor comodidad al evaluar y analizar los resultado al momento de sus apelaciones (porque tienen tres días para apelar este resultado).

Para evaluar se les eliminaron los comentarios a los programas.

Se evaluaron 3 variables, Velocidad, Complejidad de Halstead (se tomó el parámetro T) y cantidad de lineas de código.

Para evaluar Halstead se usó una gramática ANTLR4 similar a la usada en el desafío de enero de 2013 (ver acá). Se modificó ligeramente para usarlo en este desafío. La gramática está incluida en el repositorio, las instrucciones para compilarla están en este repositorio: https://github.com/lnds/programando.org/tree/master/halstead

En el caso de Ubaldo y Rodrigo se eligió el programa más rápido, estos corresponden a utaladriz3.py en el caso de Ubaldo, y rchappa4.py en el caso de Rodrigo.

Velocidad

1er Lugar: rchappa, con 0.23 segundos (4 puntos) 2do Lugar: aveloso, con 19.6 segundos (3 puntos) 3er Lugar: utaladriz, con 25.5 segundos (2 puntos) ato Lugar: cleiva, con 30.2 segundos (1 punto)

Las pruebas se hicieron en un macbook pro retina, con un procesador Intel i7 de 2.7 GHz y 16 Gb de RAM.

Complejidad de Halstead

1er Lugar: rchappa, con T=2082.51 (4 puntos) 2do Lugar: cleiva, con T=4715.30 (3 puntos) 3er Lugar: utaladriz, con T=5412.19 (2 puntos) 4to Lugar: aveloso, con T=35904.64 (1 punto)

La complejidad T corresponde al “tiempo de entendimiento”, de acuerdo a lo definido acá: http://www.programando.org/blog/2013/01/desafio-enero-las-metricas-de-halstead/.

Lineas de Código

1er Lugar: rchappa con 28 (4 puntos) 2do Lugar: cleiva con 31 (3 puntos) 3er Lugar: utaladriz con 71 (2 puntos) 4to Lugar: aveloso con 257 (1 punto)

Clasificación General

Ganador: Rodrigo Chappa (12 puntos) Segundo: Cristobal Leiva (7 puntos) Tercero: Ubaldo Taladriz (6 puntos) Cuarto: Alvaro Veloso (5 puntos)

Como es usual tienen 3 días para apelar el resultado, de lo contrario, si no hay objeción entregaré el premio al ganador.

Gracias a todos por participar. Después de entregar el resultado voy a publicar mi solución a este problema.

Desafío Enero 2014 - Los Cuatro Cuatro

| Comentarios

ACTUALIZACION

4 de febrero.

Se agregó una regla adicional para poder representar todos los números de 0 a 100, sin esta regla algunos números no tenían representación.


Este ejercicio lo aprendí cuando tenía unos quince o dieciséis años, en un taller de computación al que asistí. Uno de nuestros guías, un ingeniero matemático, alto, de lentes y pelo enmarañado, estaba jugando con expresiones matemáticas en la pizarra. Lo peculiar es que cada expresión contenía cuatro números cuatro.

Estos son ejemplos de algunas de las expresiones que dibujaba:

0 = 4/4 - 4/4

1 = 44/44

2 = 4/4 + 4/4

5 = r(4) + r(4) + 4/4

12 = 4! -4 - 4 - 4

19 = 4! - 4/4 - 4

32 = 4! + (4*4)/r(4)

Acá r(4) es la raíz cuadrada de cuatro, y 4! es el factorial de 4. En realidad el 32 se representa en una pizarra de este modo:

afío de los cuatro cuatros aparece en un libro llamado “El Hombre que Calculaba”, de Malba Tahan, seudónimo del profesor brasileño Julio César de Mello y Souza. Es una novela que contiene una serie de problemas y curiosidades matemáticas bastante entretenidas.

El problema consiste en encontrar la forma matemática para representar cualquier número usando para ello sólo cuatro cuatros, y a lo sumo algunos símbolos no literales para operaciones básicas.

En nuestro desafío los símbolos adicionales serán:

+,-,/,* : para las cuatro operaciones aritméticas básicas

r(4): para la raíz cuadrada de 4 (es decir 2)

4 ^ 4: para representar 4 elevado a cuatro (256).

4!: para representar a 4 factorial ó 24.

.4: para representar a 0.4, o 4/10.

.4’: representa al número 0.44444…., o 4/9 (0.4 periódico).

El desafío consiste en escribir un programa que sea capaz de generar los números del 1 al 100 como combinación de cuatro cuatros y los símbolos mencionados.

Hay números que tienen más de una representación, basta con entregar la primera que se encuentre.

La salida debe ser similar a la escrita arriba, es decir:

0 = 4/4 - 4/4

1 = 44/44

2 = 4/4 + 4/4

3 = r(4) + r(4) - 4/4

Reglas:

Ganará el que entregue el algoritmo más compacto y eficiente.

El programa debe retornar la respuesta en menos de 10 minutos de ejecución.

Para definir el código más compacto consideraremos la cantidad de lineas de código y luego las métricas de Halmstead.

Tampoco se aceptarán programas que se limiten a imprimir los resultados calculados a mano previamente.

Tienen un mes para entregar sus respuestas.

El premio al ganador será una giftcard Amazon de 30 dólares.

Se debe usar alguno de los siguientes lenguajes de programación: C, C++, Java, Javascript, Python y Haskell. No se aceptan entregas en otros lenguajes.

Los programas deben estar disponibles en un repositorio GitHub o Bitbucket.

Resultados Desafío StartchConf 2013 - JSON Drawing

| Comentarios

Ya tenemos ganadora en el desafío CSS StartechConf 2013 Yin Yang, ahora corresponde determinar el ganador en la categoría JavaScript.

Los concursantes son:

  • Manuel Ortega, mannungo, https://github.com/mannungo/jsondrawing
  • Jaime Guaman, jaimeguaman, https://github.com/jaimeguaman/jsondrawing
  • Juan Pablo Huerta, jphuerta, 2 soluciones, http://jsfiddle.net/45j2v/9/ y http://jsfiddle.net/GTY7Z/
  • Aldrin Martoq, aldrinmartoq, https://github.com/aldrinmartoq/lnds-jsondrawing/
  • Hans Roman, shanor: https://github.com/aldrinmartoq/lnds-jsondrawing/

Proceso de Clasificación

§ 1: que todos sean capaces de dibujar la figura propuesta en el enunciado del ejercicio. Dibujar además de esta figura:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[
{   "background": "#BADA55",
    "pen": "orange",
    "fill": "white"

},
{   "fill": "red",
    "pen":"blue",
    "width":3,
    "box": [400, 300, 150, 100] 
},

{
    "width": 25,
    "fill": "#FAECA1",
    "box": [200, 200, 250, 250]
},
{
    "width": 7,
    "line": [300, 30, 400, 250]
}
]

Visualmente se ve así:

Etapa 2: Complejidad Halstead, se calcula la complejidad de cada función con esta herramienta, se suman, y se divide por 18 para tener T. En esta etapa usé la siguiente instrucción

1
# cr archivo | grep 'Halstead effort' | perl -ne 'END { print $t/18.0 . "\n"} @he = /(\d+\.\d+)/g; $t += $_ foreach @he; '

Esto se aplicó solamente sobre el código javascript, no se consideraron fuentes html ni css, ni tampoco llamadas a javascript desde html.

Ganará el que pase la etapa 1 y tenga un menor valor de T.

Resultados Etapa 1

Todas las entradas son capaces de dibujar la figura definida en el desafío. Sin embargo, en el caso de la segunda figura Shanor no pudo manejar el cambio de fondo expresado en hexadecimal. La solución de Mannungo tampoco dibuja bien el cuadrado azul interno.

Resultados Etapa 2

Los valores de T para los que pasaron la etapa 1 son los siguientes (ordenados de menor a mayor):

Aldrin Martoq: 105.22 Jaime Guaman: 170.99 Juan Pablo Huerta: 272.30 Como dato adicional, el valor de T de la solución de Shanor es de 68.42, pero está incompleta, y la de Mannungo es de 1393.56.

And The Winner Is

on estos resultados, el ganador de este desafío es Aldrin Martoq, quien además hizo este dibujo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
[ { width : 10,
     line : [250, 80, 430, 80] },
  {  line : [280, 80, 280, 160] },
  {  line : [330, 80, 330, 160] },
  {  line : [330, 155, 370, 155] },
  {  line : [330, 115, 370, 115] },
  {  line : [390, 80, 390, 160] },
  {  line : [390, 155, 430, 155] },
  {  line : [440, 75, 440, 160] },
  {  line : [480, 75, 480, 160] },
  {  line : [440, 115, 480, 115] },
  { width : 10,
      pen : 'yellow' },
  {  line : [100,  50,  90, 100] },  
  {  line : [ 90, 100,  40, 100] },
  {  line : [ 40, 100,  84, 130] },
  {  line : [ 84, 130,  74, 180] },
  {  line : [120, 100,  170, 100],
      pen : 'lightgray' },
  {  line : [128, 130,  140, 180] },
  {  fill : 'lightblue',
      pen : 'green',
    width : 2,
   circle : [400, 250, 40] }, 
  {   pen : 'red',
      box : [300, 220, 350, 280] },
  {  fill : 0xcafece,
   circle : [200, 250, 40] },
  {  fill : 'black',
     pen  : 'black',
   circle : [220, 250, 35] },
  {   box : [390, 230, 440, 240] },
  {   box : [310, 230, 320, 280] },
  {   box : [340, 220, 330, 270] },
  {   box : [390, 250, 440, 290] },
  {  fill : 'green',
    width : 5,
     pen  : 'yellow',
   circle : [250, 250, 30] },  
]

Así que felicitaciones a Aldrin, y gracias a todos los que participaron. Nos comunicaremos con él para entregarle su premio.

Resultados Desafío StartechConf 2013 - Yin Yang

| Comentarios

Ayer finalizó el desafío doble, auspiciado por nuestros amigos de StartechConf 2013. Este desafío tiene dos partes, una para probar las habilidades en css, y otro con javascript.

El primer desafío CSS recibió 11 participaciones, lamentablemente hubo un usuario anónimo (Guest) quien presentó esta solución http://jsfiddle.net/HGQ3A/1/, bastante buena, pero como no sabemos de quién se trata no vamos a considerar.

Hay otro participante quién se identificó sólo con el nombre Rodrigo con esta solución http://jsfiddle.net/9ttLw/3/ tampoco será considerado por las mismas razones.

Hay dos soluciones que si bien dibujan un yinyang lo hacen colocando una imagen o usando un font, la idea era “dibujar” usando css, como no se cumple el espíritu del concurso tampoco serán consideradas, pero se llevan dos menciones:

Premio LOL: Tomás Mayr por esta solución con una imagen embebida codificada en base64 http://dabblet.com/gist/6583300.

Premio ROTFL: Aldrin Martoq por esta solución que usa el carácter unicode: http://jsfiddle.net/aldrinmartoq/8Nbke/

Pero ahora con los participantes que quedan seleccionados.

  • Rodrigo Aliste, raliste: https://gist.github.com/raliste/6564639
  • Jaime Guaman, guaman, con 4 soluciones
  • Tomás Mayr, tmayr, con 4 soluciones “en serio”
  • Felipe Cabargas, felipecabargas, https://gist.github.com/) felipecabargas/6574545
  • Flavia Ibañez, flaviaza, https://github.com/flaviaza/jing_jang
  • Luis Vega, fodsite, https://gist.github.com/fodsite/6584573
  • Gonzalo Huerta-Canepa, ghuerta, http://jsfiddle.net/45j2v/7/
  • Sonia Espinoza, sespinoza, http://jsfiddle.net/sespinoza/VwM4P/5/

Criterios de Eliminación

Para determinar al ganador se midieron estos criterios, en orden ascendente:

  1. Que la solución se pueda visualizar en Chrome, Firefox y Safari en un MacBook Pro.
  2. Que la solución tenga la menor cantidad de código (menos lineas, y si hay empate en cantidad de lineas, menos caracteres). Para medir el código se contaron los elementos css y html, en algunos casos se fundieron los estilos en un solo html para poder probarlos en el macbook, los códigos fusionados están disponibles en este repositorio github:https://github.com/lnds/programando.org/tree/master/startechconf2013
  3. Que la imagen se parezca lo más posible a la expuesta en el post original del desafío.

La medición consiste en que cada participantes queme las etapas descritas anteriormente.

Etapa 1: Visualización en Chrome, Firefox y Safari

  1. Rodrigo Aliste, raliste: cumple
  2. Jaime Guaman, 4 soluciones, guaman1.html: cumple, la segunda solución falla con Safari, las soluciones 3 y 4 sólo funcionan con Chrome.
  3. Tomás Mayr,las soluciones 1 y 2 no funcionan con safari, la solución 3 y 4 no funcionan con firefox ni safari.
  4. Felipe Cabargas: cumple
  5. Flavia Ibañez: cumple
  6. Luis Vega: cumple
  7. Gonzalo Huerta-Canepa: cumple
  8. Sonia Espinoza: cumple

Etapa 2: tamaño de la solución

Consideramos sólo las soluciones que cumplen con la etapa 1 y las ordenamos por cantidad de lineas, dejando en primer lugar las que ocupan menos cantidad de lineas:

  1. Gonzalo Huerta-Canepa: 8
  2. Sonia Espinoza: 11
  3. Flavia Ibañez: 13
  4. Felipe Cabargas: 39
  5. Luis Vega: 44
  6. Jaime Guaman (solución 1): 63
  7. Rodrigo Aliste: 65

Etapa 3: similitud con respecto a la imagen original

Este es el aspecto más estético, pero es importante, puesto que de eso se trata css ;).

En este sentido, las 2 mejores soluciones en términos de similitud al original son las siguientes:

  1. Sonia Espinoza
  2. Luis Vega Varios olvidaron el borde negro sobre el lado blanco (Yin) de la figura, dejando un color gris. La solución de Gonzalo Huerta-Canepa es la más breve, pero dibuja un yin yang muy pequeño.

Las soluciones de Guaman y Mayr son las más breves, pero no dibujan la figura como corresponde en todos los browsers, y en algunos casos la figura no se parece a la original.

And the winner is

Con estos antecedentes, y tras superar las 3 etapas, con una solución de 11 lineas de código, la ganadora es Sonia Espinoza.

Felicitaciones, debes enviar un email a ediaz @ dcc8090.cl con tus antecedentes para que el equipo Startech te contacte por tu premio.

Gracias todos por participar, y en unas horas estará el resultado del desafío javascript.

Desafío StarTechConf 2013

| Comentarios

En esta oportunidad les presento dos desafíos que hemos preparado en conjunto con nuestros amigos de StartechConf 2013.

Esta vez queremos desafiar los conocimientos profundos que tengan de css y javascript. Pero, lo mejor es que estos desafíos tienen como premio una entrada a la StarTechConf 2013 cada uno. Esta conferencia se realizará en Santiago de Chile entre el 25 y 26 de octubre de este año.

Desafío Junio - Código De Máquina

| Comentarios

Cuando programamos en bajo nivel, directamente con el código de máquina solemos usar lo que llamamos lenguaje ensamblador. El siguiente es un ejemplo típico de código ensamblador:

1
2
3
4
5
shl eax, 1
shr ebx, cl
and eax, ebx
jnz done
mov eax, cl

Sin embargo, estas instrucciones se traducen en números binarios que son interpretados por la CPU.

Los códigos de máquina se basan en una serie de instrucciones básicas las que se construyen combinando “puertas lógicas”, circuitos digitales que reciben 2 señales que representan los ceros y unos de la lógica binaria. Estas operaciones lógicas pueden ser usadas para construir todas las instrucciones del código assembler. Las operaciones de lógica binaria más comunes son las operaciones NOT, AND, OR, y XOR.

Lo interesante es que es posible construir todas las demás instrucciones a partir de una sola operación básica, siempre que esta operación sea NOR o NAND.

Probando Frameworks Web

| Comentarios

Hay muchos benchmarks de frameworks en la web, uno de los más recientes es este de techempower que mide más de 70 frameworks diferentes.

Como estoy investigando Play Framework, y ya llevo usando Grails hace un par de años hice un pequeño test entre ambos ambientes, usando parte de un proyecto interno de mi trabajo. Publiqué en twitter que Play-Scala era varias veces más rápido que Grails, y mis colegas me pidieron que les “mostrara el código”.

Como no podía revelar el código del proyecto de mi trabajo, durante el fin de semana implementé un mini benchmark, y publiqué el código en este repositorio GitHub.

Resultado Final Desafío Marzo Abril - ADN Forense

| Comentarios

Ha terminado la fase de apelación al resultado del desafío Marzo Abril, les pido las disculpas del caso pues había prometido informar esto el domingo pasado.

Hay un cambio importantísimo, puesto que Rodrigo Chappa, acertadamente ha cuestionado la validez de mis pruebas, y como efectivamente tiene razón, corresponde reparar mi error.

El set original de datos sólo consideraba el caso en que las muestras tenían el mismo largo que la evidencia, esto genera que la solución de Sebastián resuelva el problema en tiempo más rápido y resultara ganadora en esas condiciones.

Sin embargo, la solución usando programación dinámica de Rodrigo Chappa es mejor, desde el punto de vista algorítmico, y eso se nota cuando cambiamos ligeramente las muestras.

La solución de Sebastían tiene una complejidad aproximada a O(n!), mientras que la de Rodrigo tiene siempre la complejidad O(n*m), donde n es el largo de la muestra y m el largo del ADN del sospechoso.

Las nuevas muestras están en mi repositorio GitHub corresponden a las muestras set4.adn y set5.adn, en que los largos de las muestras son diferentes. Pueden validar los resultado ustedes mismos.

Al ejecutar el programa de Rodrigo Chappa reconoce adecuadamente al culpable. Lamentablemente la solución de Sebastián empieza a consumir cpu y memoria, al punto que genera una excepción por consumo del heap.

Así que con estos antecedentes tengo que cambiar el veredicto, y otorgar el primer lugar a Rodrigo Chappa, felicitaciones por el algoritmo y por defender su solución.

En virtud de esto, el premio de 40 dólares originales(*), se dividirá en $30 dólares para Rodrigo y $10 para Sebastián como segundo lugar. Me contactaré con ellos para enviarles su giftcard en los próximos días.

Gracias a todos por participar, y gracias a Rodrigo y Sebastián por el espíritu deportivo mostrado.

Los invito a estar atentos pues se viene un nuevo desafío en los próximos días.

(*) recordemos que el premio total era para el ganador sólo si habían al menos 8 participantes, condición que no se cumplió, pero dado el esfuerzo he decidido premiarlos igual de esta forma.

Resultados Desafío Marzo/Abril - ADN Forense

| Comentarios

Llegó el final del plazo para el desafío Marzo/Abril. A pesar de que hubo varios comentarios y consulta sólo llegaron a la fecha del 30 de abril 6 participantes, por lo que el premio prometido no podrá ser entregado (la giftcard de 40 dólares), puesto que no se cumple el mínimo de 8 participantes :-(

Sin embargo, vamos a revisar la participación de los otros seis y elegiremos al mejor. A continuación voy a publicar los resultados de las pruebas y tendrán una semana para apelar, al final de ese periodo entregaré un premio definitivo (distinto al ofrecido originalmente).

Desafio Marzo/Abril ADN Forense

| Comentarios

ACTUALIZACIÓN 1 DE MAYO 21:00 horas Estimados amigos, el plazo para participar ya se cumplió, tenemos 6 participantes. Lamentablemente no he podido organizar el tiempo para revisar las participaciones. Así que los resultados estarán dentro de los próximos días. Saludos y gracias a todos los que han participado.


Uno de los problemas comunes en bio informática es el de tratar de encontrar similitud entre secuencias de genes.

Los genes, en bio informática, se representan como secuencias de 4 posibles letras A,C, G o T (A de Adenina, C de Citosina, G de Guanina y T de Timina, las cuatro bases de los ácidos nucléicos como el ADN o el ARN).

Una manera de determinar la similitud de dos secuencias de ADN es usando una técnica conocida como alineamiento de secuencias.

El proceso de alineamiento de secuencias de genes es como sigue.

Dados dos genes, por ejemplo: AGTGATG y GTTAG, lo primero que se hace es insertar espacios (representados mediante el símbolo guión ‘-‘) en las secuencias de modo que ambas queden de igual largo. Los espacios se deben insertar de manera tal que permitan aumentar el grado de similitud entre ambas secuencias.

Para calcular este grado de similitud se asigna un puntaje de acuerdo a una matriz del modo que se explicará a continuación.

Una forma de alinear los genes AGTGATG y GTTAG es la siguiente:

1
2
AGTGAT-G
-GT--TAG

En este caso tenemos 4 coincidencias G en la segunda posición, T en la tercera, T en la sexta y G en la octava posición.

Otra forma de alinear ambos genes es la siguiente

1
2
AGTGATG
-GTTA-G

Acá tenemos también 4 coincidencias, G en la segunda posición, T en la tercera, A en la quinta posición y G en la octava posición.

¿Cuál alineamiento es el mejor?

Para determinarlo calculamos el puntaje de alineamiento, usando la siguiente matriz simétrica de puntajes:

Lo que hacemos es que vemos todos los pares que se forman y sumamos los valores de acuerdo a la matriz (el asterisco indica que no pueden haber pares -,-).

En el caso del primer alineamiento tenemos los siguientes pares:

1
A-,GG,TT,G-,A-,TT,-A,GG

Buscamos en la matriz de acuerdo a estas “coordenadas”:

1
A-=(-3), GG=5, TT=5, G-=(-2), A-=(-3), TT=5, -A=(-3), GG=5

Sumamos: (-3)+5+5+(-2)+(-3)+5+(-3)+5=9

Hagamos el mismo cálculo para el segundo alineamiento:

1
A-=(-3), GG=5, TT=5, GT=(-2), AA=5, T-=(-1), GG=5

Sumamos: (-3)+5+5+(-2)+5+(-1)+5 = 14

En este caso el puntaje de alineamiento es 14 por lo tanto este alineamiento es mejor.

El problema es encontrar un algoritmo que dados dos genes encuentre el alineamiento con el mayor puntaje.

Desafío Marzo-Abril 2013

Se ha cometido un asesinato. Entre las evidencias se tiene ADN de la víctima y del presunto asesino. Sin embargo, después de secuenciar el ADN el servidor que contienen el software que permite comparar las muestras ha sufrido un crash de disco. El equipo forense ha sido descuidado y no tiene respaldos.

Lo lamentable es que el computador contenía la implementación de un notable algoritmo de Alineamiento de Secuencias de Genes desarrollado por un prestigioso investigador con el que se ha perdido contacto.

Por lo tanto nos han pedido que propongamos distintos algoritmos de alineamiento de secuencias y que comparemos el ADN recogido en la escena del crimen contra el genoma de varios sospechosos.

Así que el desafío de esta oportunidad consiste en construir un programa que reciba un archivo con la siguiente forma: - En que la primeras 5 lineas viene la matriz de puntajes - Después viene la evidencia (el ADN recogido en la escena del crimen) - Finalmente vienen las secuencias de ADN de varios sospechosos. - El archivo puede venir con comentarios, los que empiezan con el carácter #. - Las lineas que comienzan con las letras A,C,G,T y el guión corresponden a los datos de la matriz, la linea que comienza con el numero 0 corresponde a la evidencia, y las lineas que comienzan con un número mayor o igual 1 corresponden a los ADN de los sospechosos.

El siguiente es un ejemplo de archivo de entrada:

1
2
3
4
5
6
7
8
9
10
11
12
13
# Matriz
A:5,-1,-2,-1,-3
C:-1,5,-3,-2,-4
G:-2,-3,5,-2,-2
T:-1,-2,-2,5,-1
-:-3,-4,-2,-1,*
          # Evidencia
0:AGTGATG
          # ADN Sospechosos
1:AAATGC
2:AGGAA
3:AGTGATA
4:GATTACA

El programa debe entregar como resultado el número del sospechoso cuyo ADN se parece más al de la evidencia.

En este caso, con el archivo de entrada mostrado anteriormente la salida del programa debe ser:

El culpable es el sospechoso número 3 (AGTGATA).

Opcionalmente el programa puede mostrar los alineamientos y el puntaje de alineamiento, pero no es necesario para participar (aunque si hay un empate, el programa con más “features” tiene más “puntos”).

Ganará el programa que se demore el menor tiempo en calcular el culpable. En caso de haber empate, o tener tiempos muy similares, se calculará el valor E de acuerdo a las métricas de Halstead.

El premio por este desafío será una Giftcard Amazon de 40 dólares la que se entregará sólo si participan 8 o más concursantes.

El código fuente de los programas debe estar disponibles en un repositorio público GitHub o Bitbucket, no se aceptarán programas entregados en otro medio.

Que empiece la competencia, y que gane el “más mejor”, el ganador se determinará el día 1 de mayo.